ElectroYou

Salve ragazzi buon giorno , sto programmando in c un PIC 16f628, utilizzando come compilatore xc8 della mplab e come ide x-mplab, ho un problema nella gestione della ram dati del PIC, in pratica nel mio codice ho dichiarato quattro Array, di tipo caratteri, con questa dimensione fissa
64 byte
22 byte
3 array da 11 byte…. Quindi con un totale di 119 byte

Ora la cosa che non capisco è perche il compilatore, mi restiturisce error 1250, cioè di memoria esaurita, eppure lo stesso compilatore mi dichiara in fase di compilazione che ho ancora disponibili altri ben 72 byte di memoria liberi, dei 224 del PIC 16f628 (vedi foto):



Ma se provo ad avviare la compilazione
Log dell'errore 1250 del compilatore :

Codice: Seleziona tutto

main.c:43: error: (1250) could not find space (64 bytes) for variable _dte
nbproject/Makefile-default.mk:135: recipe for target 'dist/default/production/ComSeriale.X.production.hex' failed
make[2]: Leaving directory 'D:/Dati/Elettronica/Progetti C/ComSeriale/ComSeriale.X'
nbproject/Makefile-default.mk:78: recipe for target '.build-conf' failed
make[1]: Leaving directory 'D:/Dati/Elettronica/Progetti C/ComSeriale/ComSeriale.X'
nbproject/Makefile-impl.mk:39: recipe for target '.build-impl' failed
(908) exit status = 1
make[2]: *** [dist/default/production/ComSeriale.X.production.hex] Error 1
make[1]: *** [.build-conf] Error 2
make: *** [.build-impl] Error 2

BUILD FAILED (exit value 2, total time: 1s)

Mi chiedo quale sia il problema, in pratica riesco a compilare solo se diminuisco l'array più grande da 64 byte a 58 byte, eppure se compilo array a 58 byte il compilatore come dicevo prima mi dichiara 70 byte di memoria disponibili .
Come prima impressione, mi viene da pensare, che essendo la memoria del PIC divisa in diversi banchi, il compilatore in fase di allocazione vada a cercare una memoria libera contigua, e quindi anche se risultano 72 byte liberi questi sono su 2 banchi separati, dando l'erroe 1250. Mi chiedo se c’è un modo per ovviare a questo problema in c, è possibile dichiarare degli array magari forzando il compilatore a usare per uno specifico array un banco piutosto che un altro ?

Oppure errore è da ritrovarsi altrove ?

Grazie sempre per la gentilezza e della professionalità .... che mettete a disposizione di tutti

Il problema è proprio la paginatura della memoria, come tu sospetti. Prova a suddividere l'array da 64 byte in 4 array da 16 byte ciascuno.

Per l'indirizzamento dovrai poi considerare il fatto che hai suddiviso in 4 il tuo array originale, ma non è una cosa complessa.

Se non riesci, fammi sapere.

Ciao.

Paolo.

mmm capito, in effetti vedendo il datasheet o meglio come sono divisi i banchi della ram per il 16f628,
questo lo divide in banchi da 80 Byte.

Da come ho capito se mette insieme l'array 58 e il 22, che appunto equivale a 80 byte allora tutto va bene, perché 58 + 22 =80
ma se aumento di un solo byte ad esempio 59 allora mi da l'errore, perche appunto 59 + 22 = 81 e non lo accetta,
perche superiore ai banchi del 16f628.

La tua soluzione di dividere un array in 4 mi piace un casino ... pero non riesco a capire come fare, ci sono epr caso esempi da cui posso studiare e trarre spunto, magari qualche suggerimento, non dico il codice già bello è fatto ma come procedere nella maniera migliore :/.

Mi viene da creare una matrice di 4 array da 16 caratteri, ma poi dovrei creare procedure ad ok per la scansione giusto ?

magari tu hai idee più semplici e più corrette !
i


intanto provo con la matrice di array ... vediamo che compbino

Ho provato la soluzione con un array multidimensionale [x][y]

ma sembra che il compilatore c ...è ostinato anche in questo caso a volere una locazione contigua x*y
non so potrei provare a dichiarare tanti array separati ma mi sembra una soluzione poco elegante

qualcuno ha qualche idea migliore ??

ok forse ho capito ho fatto cosi per ora sembra funzionare .... è l'unica soluzione funzionante anche se poco elegante, utilizzando tanti array separati da 8 byte, in questo modo si frega il compilatore ....

Codice: Seleziona tutto

     [b]//Dichiarazione[/b]
     #define MATRIX 8//
    .........................................

    unsigned char matrix0[MATRIX];
    unsigned char matrix1[MATRIX];
    unsigned char matrix2[MATRIX];
    unsigned char matrix3[MATRIX];
    unsigned char matrix4[MATRIX];
    unsigned char matrix5[MATRIX];
    unsigned char matrix6[MATRIX];
    unsigned char matrix7[MATRIX];
.................................

[b]//Inserimento[/b]
void inserisciMatrice(unsigned char c, int pos){
    int j=pos/8;
    int i=pos%8;   

    if(j==0) matrix0[i]=c;
    if(j==1) matrix1[i]=c;
    if(j==2) matrix2[i]=c;
    if(j==3) matrix3[i]=c;
    if(j==4) matrix4[i]=c;
    if(j==5) matrix5[i]=c;
    if(j==6) matrix6[i]=c;
    if(j==7) matrix7[i]=c;
 
}

//Lettura di un carattere
unsigned char leggiMatrice(int pos){
    int j=pos/8;
    int i=pos%8;   
    unsigned char c;
   
    if(j==0) c=matrix0[i];
    if(j==1) c=matrix1[i];
    if(j==2) c=matrix2[i];
    if(j==3) c=matrix3[i];
    if(j==4) c=matrix4[i];
    if(j==5) c=matrix5[i];
    if(j==6) c=matrix6[i];
    if(j==7) c=matrix7[i];   
    return c;   
}

//Scansione lineare





Dove pos sarebbe la posizione all'interno di una stringa se supponiamo che questa si a in un array unico

Fra qualche giorno se riesco ad avere tempo posto la soluzione più completa .... magari puo essere utile a qualcuno

Una possibile soluzione la trovi nel seguito.
Il codice, scritto per XC8, mostra l'accesso in scrittura di un char data all'indirizzo pos, andando a selezionare il byte corretto tra gli 8 disponibili.

La procedura è semplice: si memorizza l'indirizzo di base di ogni vettore da 8 byte e si calcola su quale byte andare a scrivere e la posizione esatta all'interno di tale byte.

Codice: Seleziona tutto

#include <xc.h>

/* Aggiungere i CONFIGURATION BITS */

void insert (char data, char pos);

/* Un po' di vettori che consumano RAM... */

char v1 [8];
char v2 [8];
char v3 [8];
char dummy1[12];
char v4 [8];
char v5 [8];
char v6 [8];
char dummy2[2];
char v7 [8];
char v8 [8];

char globalIndex = 0;

char large1[64];

/* Indirizzi di base dei singoli vettori */
unsigned char addr1;
unsigned char addr2;
unsigned char addr3;
unsigned char addr4;
unsigned char addr5;
unsigned char addr6;
unsigned char addr7;
unsigned char addr8;

void main(void)
{
    /* Memorizzo gli indirizzi di partenza degli 8 vettori che mi servono */
    addr1=v1[0];
    addr1=v2[0];
    addr1=v3[0];
    addr1=v4[0];
    addr1=v5[0];
    addr1=v6[0];
    addr1=v7[0];
    addr1=v8[0];
   
    /* Chiamo la funzione di inserimento */
    insert('A',7);
    insert('B',12);
    insert('C',22);
    insert('D',26);
    insert('E',35);
    insert('F',44);
    insert('G',52);
    insert('H',58);
   
    while(1);
    return;
}

void insert (char data, char pos)
{
    char vectorIndex;
    char byteIndex;
   
    /* Calcolo del numero del vettore sul quale accedere */
    vectorIndex = pos/8;
   
    /* Calcolo dell'offset all'interno del byte */
    byteIndex = pos-8*vectorIndex;
   
    /* Una volta selezionato il vettore, posso scrivere */
    switch (vectorIndex)
    {
        case 0:
            v1[byteIndex] = data;
        break;
       
        case 1:
            v2[byteIndex] = data;
        break;
       
        case 2:
            v3[byteIndex] = data;
        break;
       
        case 3:
            v4[byteIndex] = data;
        break;
       
        case 4:
            v5[byteIndex] = data;
        break;
       
        case 5:
            v6[byteIndex] = data;
        break;
       
        case 6:
            v7[byteIndex] = data;
        break;
       
        case 7:
            v8[byteIndex] = data;
        break;
    }
}

L'accesso in lettura lo lascio fare a te.

Il codice è senz'altro ottimizzabile. Tieni conto che per queste poche righe, il compilatore dice che sto consumando un sacco di risorse:



Fammi sapere se è tutto chiaro.

Ciao.

Paolo.

grazie Paolo scusa se rispondo solo ora .. causa tempo ...
grazie per il codice ora vedo di migliorare il mio tramite il tuo esempio
grazie ancora