Algebra booleana

Quello dell’I2C è una versione che ho riadattato da un sorgente per CCS e funziona bene, la libreria per il DS1307 me la sono scritta io e si appoggia alla libreria I2C, pare che funziona benone ma non si può mai dire (la sfiga è sempre dietro l’angolo).

E’ una cosa fatta bene, come avrai potuto vedere non si trova niente di buono già pronto in giro: sempre codici “mozzicati”, non documentati e lacunosi. Appena ho tempo di cercarli e se li trovo te li mando al tuo indirizzo email, tanto i codici come mio solito sono abbastanza commentati e dovrebbe essere chiaro tutto. Per i collegamenti però te la vedi tu, tanto non è niente di difficoltoso: basta ricordarsi di mettere le resistenze di pullup sulle due linee I2C, per il resto fa tutto il codice.

I forum dove in genere “opero” io sono quelli di Sergio Fiocco (che ora si è spostato su http://www.taliaki.net) o quello di robot-italy (www.robot-italy.net). C’è anche il forum di roboitalia: forum.roboitalia.com

Il codice me lo manderai quando è a buon punto ;) tanto per ora non ho nemmeno il tempo di provarlo.

Quell’errore di “expected ;” non ha senso, è capitato alcune volte anche a me mettendo delle routine di delay sui pic12, mi dava un errore del genere o errore di sintassi, quando la sintassi era assolutamente corretta, preso dallo sconforto i ritardi poi li gestii con gli interrupt. Secondo me si tratta di un altro bug. Dovresti postarlo nel forum della microchip.

Allora, guarda il DAC è l’unica cosa che funge, insomma 5 bit son veramente pochi, però non ci possiamo lamentare, al massimo si aggiunge un passa basso e tagliamo la testa al toro; se levo tutta quella “meccanica” per la temporizzazione, ho una sinusoide “perfetta”, l’oscilloscopio mi caccia una bella sinusoide, ovviamente la precisione è direttamente proporzionale al numero di punti, ed inversamente proporzionale alla frequenza. Il quarzo interno, anche non calibrandolo con OSCCTUNE (come si fà?) funziona bene o male a dovere.
Quindi diamo per funzionante la generazione della sinusoide.

Il problema è il calcolo del “del”; praticamente lo noto anche perchè, notato il malfunzionamento, ho dichiarato una variabile char da uguagliarla a del, giusto per inserirla nel watch del pickit, però non mi compila dandomi un errore strano, secondo me sbaglia a convertire in char.

******************************************************************************
char del=dlcal;
….
Error [314] C:\Users\Luca\Desktop\Programmazione Pic\16F1827\generatoresinusoidale.c; 33.28 “;” expected
******************************************************************************

ovviamente il 33.28 è esattamente 12 caratteri dopo il punto e virgola, sembrerebbe non riesce a convertire a char.
A maggior ragione lo noto, che praticamente indipendentemente dalla freq assegnata, la sinusoide generata è sempre la stessa!

Poi non parliamo di un’altra cosa stranissima, tipo che la fmax varia, ieri pomeriggio era a 1720 ieri sera a 1240 (ed il quarzo lavora bene…); hai presente quando si parla di “ripetibilità degli strumenti”? Mah..

Siano benedetti di dspic.
Comunque ci sbatterò un altro po la testa fra oggi e domani, magari ti faccio sapere, bisognerebbe analizzare tutti i calcoli che fà inserendoli nel main e controllando gli arrotondamenti, comunque ovviamente l’errore in frequenza è elevatissimo, questo già me lo aspettavo, del tipo anche 200Hz per uS in più o meno, però almeno sulle basse frequenze dovrebbe funzionare.
Bisogna analizzare il del, e vedere come lavora il preprocessore, c’è qualche modo per analizzare le costanti col pickit? A quanto ho notato non c’è modo di inserirle nel watch, ci trovo solo le variabili che effettivamente variano, nemmeno quelle che rimangono costanti pur definendole variabili.

Luca

(OT dell’OT, ti ricordi quando ti chiedevo dell’interrupt su portB e tu mi dicesti a che ti serve?, ecco, la risposta più sensata ( e più utilizzata ) è: “per svegliare il pic dallo stato sleep” )

******************************************************************************

#include
#include
#define PIC_CLK 32000000
#include “delay.c”

// Fuses di configurazione
__CONFIG (FOSC_INTOSC & WDTE_OFF & PWRTE_OFF & MCLRE_ON & CP_OFF & CPD_OFF & BOREN_OFF & CLKOUTEN_ON & IESO_OFF &
FCMEN_OFF & WRT_ALL & VCAPEN_OFF & PLLEN_OFF & STVREN_OFF & BORV_19 & DEBUG_ON & LVP_OFF);

//Faccio fare i conti al preprocessore invece che al pic, e svolgo tutti calcoli possibili a priori
#define punti 180//selezionare quanti punti per sinusoide mettere (45/90/180/360)
#define pnt punti-1
#define mul (360/punti)*(3.14159265359/180)

#define fre 100 //frequenza desiderata
#define fmax 1240 //frequenza massima generata commentando la riga di ritardo nella generazione
#define del (((1/fre)/punti)-(1/fmax)/punti)/1000000

//mi calcolo il ritardo da aggiungere ad ogni ciclo in modo da raggiungere la frequenza desiderata
//ho la frequenza massima, mi calcolo il quanto di tempo per ogni ciclo, faccio la differenza
//con il quanto di tempo ideale per ogni ciclo, e lo converto in microsecondi

unsigned char dac[pnt]; //lo inserisco qui per evitare il bug secondo il quale se non dichiarata globale
//l’array non può superare gli 80 char
int t=0;

void main(void)
{
OSCCON=0b11110000; //Oscillatore a 32MHz
TRISA=0b00000100;
TRISB=0b00000000;
ANSELA=0b00000100;
ANSELB=0b00000000;
DACCON0=0b11100000;

for(t;t<pnt;t++)
dac[t]=0b10000+(char)(0b1111*sin(t*mul));

while(1)
{
t=0;
for(t;t<pnt;t++)
{DACCON1=dac[t];
DelayUs(del);
}
}

}

#include
#include
#define PIC_CLK 32000000
#include “delay.c”

// Fuses di configurazione
__CONFIG (FOSC_INTOSC & WDTE_OFF & PWRTE_OFF & MCLRE_ON & CP_OFF & CPD_OFF & BOREN_OFF & CLKOUTEN_ON & IESO_OFF &
FCMEN_OFF & WRT_ALL & VCAPEN_OFF & PLLEN_OFF & STVREN_OFF & BORV_19 & DEBUG_ON & LVP_OFF);

//Faccio fare i conti al preprocessore invece che al pic, e svolgo tutti calcoli possibili a priori
#define punti 180//selezionare quanti punti per sinusoide mettere (45/90/180/360)
#define pnt punti-1
#define mul (360/punti)*(3.14159265359/180)

#define fre 100 //frequenza desiderata
#define fmax 1240 //frequenza massima generata commentando la riga di ritardo nella generazione
#define del (((1/fre)/punti)-(1/fmax)/punti)/1000000

//mi calcolo il ritardo da aggiungere ad ogni ciclo in modo da raggiungere la frequenza desiderata
//ho la frequenza massima, mi calcolo il quanto di tempo per ogni ciclo, faccio la differenza
//con il quanto di tempo ideale per ogni ciclo, e lo converto in microsecondi

unsigned char dac[pnt]; //lo inserisco qui per evitare il bug secondo il quale se non dichiarata globale
//l’array non può superare gli 80 char
int t=0;

void main(void)
{
OSCCON=0b11110000; //Oscillatore a 32MHz
TRISA=0b00000100;
TRISB=0b00000000;
ANSELA=0b00000100;
ANSELB=0b00000000;
DACCON0=0b11100000;

for(t;t<pnt;t++)
dac[t]=0b10000+(char)(0b1111*sin(t*mul));

while(1)
{
t=0;
for(t;t<pnt;t++)
{DACCON1=dac[t];
DelayUs(del);
}
}

}
******************************************************************************
Ok ci sono parecchie cose da fare, per esempio gestire in automatico il numero di punti ottimale (con 180 non si puo superare il kHz e mezzo), ok bisogna comunque prevenire l'overflow di del quando utilizzato su DelayUs() [Nb. uso le routine di delay di microchipc.com].. ma almeno per grandi linee..perchè non fungeee?

Quando la matematica, approssimata, diventa un opinione.

Ps. debuggando col pickit, controllando i valori con watch expression, inserendo i calcoli nel main, escono valori strani.

Le tue idee a caldo?

Ora devo solo vedere come fare in modo da poter dare in pasto direttamente la frequenza desiderata per vedermi generata la sinusoide corrispondente.

“Making the array global worked just fine! I’m confused.”…”By changing from auto to static duration, you’ve changed the array’s storage class.”…”Upgraded and error dissapeared. ”

Funziona… ma porca..certo che sto hitech è fatto veramente una zoza su certe cose! Con un’upgrade il tizio ha alla fine risolto tutto. Secondo me i bug li hanno inseriti di proposito per farmi uscire pazzo!

Luca

Con array da 90:
******************************************************************************
HI-TECH C Compiler for PIC10/12/16 MCUs (PRO Mode) V9.70
Copyright (C) 2009 Microchip Technology Inc.
Serial number: HCPICP-45553 (PRO)
Error [1250] C:\Users\Luca\Desktop\Programmazione Pic\16F1827\generatoresinusoidale.c; 27. could not find space (89 bytes) for variable _dac
******************************************************************************

Con array da 45:
******************************************************************************
HI-TECH C Compiler for PIC10/12/16 MCUs (PRO Mode) V9.70
Copyright (C) 2009 Microchip Technology Inc.
Serial number: HCPICP-45553 (PRO)

Memory Summary:
Program space used 61Bh ( 1563) of 1000h words ( 38.2%)
Data space used A9h ( 169) of 180h bytes ( 44.0%)
EEPROM space used 0h ( 0) of 100h bytes ( 0.0%)
Configuration bits used 1h ( 1) of 2h words ( 50.0%)
ID Location space used 0h ( 0) of 4h bytes ( 0.0%)

Loaded C:\Users\Luca\Desktop\Programmazione Pic\16F1827\Workspace\generatoresinusoidale.cof.

********** Build successful! **********
******************************************************************************

Come vedi c’è spazio a volontà, facendo delle prove ho visto che il problema è che non riesce a manipolare array da più di 80 char. Ho ottimizzato il codice con più array ora. Ma il problema comunque non cambia. Ora mi chiedo, perchè non riesce a gestire array più grandi? could not find space (89 bytes) for variable _dac? Ma di space ne hai a volontà mio caro! Bah…

Punto secondo:
anche se 8MIPS saranno tanti (relativamente), non è mai un dsPic(con le sue ottimizzazioni circuitali), e calcolare via math.h punto punto il valore, si forma un collo di bottiglia per il quale la max freq generata è 1.6Hz, se invece io effettuo prima tutti i calcoli, dopo farò in modo che l’unico calcolo che devo fare, è l’assegnazione di un valore ad un registro, ed ecco che la freq max sale a 6.5kHz! Ovviamente questo è il valore massimo raggiungibile, con 45 punti per periodo, usarne di meno è troppo distorta, usarne di più ovviamente rallenta!
Ottimizzazione, la quintessenza dell’ingegnere!

Punto terzo:
il passo più lungo della gamba, il dsPic33 è il mio punto d’arrivo, sono un tipo di larghe vedute, c’è prima da solidificare le fondamenta, e poi dopo rompersi la schiena sul dsp con pic, il mio sogno è un’oscilloscopio (con fft e via di lì) fatto con pic display grafico, la teoria c’è tutta (non possiamo lamentarci con questo dell’università, almeno per questo), il problema è la realizzazione, piano piano ci arriveremo.

Spero di non romperti troppo con tutte queste mie richieste, se posso essere utile qualche volta, non esitare a chiedere!
Luca

Giovanni Bernardo :
…magari cerco di procurarmi pure io quel pic e provo quello che hai fatto tu così metto su un articolo a nome tuo se ti fa piacere.

I samples esistono proprio per questo, dovresti vedere la mia collezione :)

Senti una domanda a bruciapelo, dovendo fare una LUT per memorizzare i valori di una sinusoide, un char valori[360]; non entra nella memoria, ma perchè non ne entrano nemmeno 90? Tutti i valori vanno salvati nella RAM vero? Cioè dove posso stipare tutti i miei dati?

L’idea è questa:

*******************************************************************************
#include
#include
#define PIC_CLK 32000000
#include “delay.c”
#include “lcd.c”

// Fuses di configurazione
__CONFIG (FOSC_INTOSC & WDTE_OFF & PWRTE_OFF & MCLRE_ON & CP_OFF & CPD_OFF & BOREN_OFF & CLKOUTEN_ON & IESO_OFF &
FCMEN_OFF & WRT_ALL & VCAPEN_OFF & PLLEN_OFF & STVREN_OFF & BORV_19 & DEBUG_ON & LVP_OFF);

void main(void)
{
OSCCON = 0b11110000; //Oscillatore a 32MHz
TRISA=0b00000100;
TRISB=0b00000000;
ANSELA=0b00000100;
ANSELB=0b00000000;

DACCON0=0b11100000;
DACCON1=0b00000000;

unsigned int t=0;
unsigned char dac[44]; //le alternative sono 89, 179, 359 ma non c’è spazio dice il compilatore!!

for(t;t<44;t++)
{
dac[t]=0b1111+(char)(0b1111*sin(8*t*((3.14159)/180.0)));
}

while(1)
{
t=0;
while(t<44)
{DACCON1=dac[t];
t++;
}
}
}
*******************************************************************************

Scartata la eeprom, come faccio a salvare un array di 360 char in un pic16f1827? Sembra che non c'è mai spazio! Possibile? Eppure ho una ram di 380 bytes, e non entra nemmeno un array da 180 nè da 90! Mi puzza sta cosa, cioè non capisco il perchè!

Luca

Ecco il codice funzionante:
************************************************************************************
#include
#include
#define PIC_CLK 32000000
#include “delay.c”
#include “lcd.c”
#include “e2prom.c”

// Fuses di configurazione
__CONFIG (FOSC_INTOSC & WDTE_NSLEEP & PWRTE_OFF & MCLRE_ON & CP_OFF & CPD_OFF & BOREN_OFF & CLKOUTEN_ON & IESO_OFF &
FCMEN_OFF & WRT_ALL & VCAPEN_OFF & PLLEN_OFF & STVREN_OFF & BORV_19 & DEBUG_ON & LVP_OFF);

__EEPROM_DATA(0,0,0,0,0,0,0,0);

// funzione principale, eseguita all’avvio del picmicro
void main(void)
{
OSCCON = 0b11110000; //Oscillatore a 32MHz
ANSELA=0;
TRISA=0;
ANSELB=0;
TRISB=0;

int cnt=eei_read_byte(0);
cnt++;

LCD_INIT();
DelayMs(100);
LCD_CLEAR();
LCD_GOTO(1,1);
LCD_PUTS(“Counter: “);
LCD_PUTUN(cnt);
LCD_GOTO(2,1); //
LCD_PUTS(” S a S !”);

eei_write_byte(cnt,0);
SLEEP();
}
*****************************************************************************

Ho risolto il tutto mettendo la scrittura della eeprom distante dalla lettura; sinceramente non capisco come mai non funzionasse, ma sopratutto la cosa strana è: perchè un problema del genere viene fuori dal momento che programmo? Nel senso: il problema ce l’ho o nel momento che compilo, o a runtime; la programmazione non si limita a flashare il pic, salvando l’hex nella memoria? Perchè mai mi ha dato questo errore? Bah…

Comunque ora vedo di ultimare la libreria, casomai ti servisse posso inviartela così la puoi pubblicare.
Grazie del cordialissimo supporto, Luca

********** Build failed! **********
*****************************************************************************

Se levo i numeri 1 e 2 affianco a __CONFIG le cose funzionano, e funzionano allo stesso modo se uso una sola riga.

Ritornando al problema: cancello la eeprom al primo byte, il programma parte, legge il valore all’indirizzo 1, lo aumenta di un unità, lo salva nell’indirizzo 1, e stampa sull’lcd counter: valore, insomma per vedere quante volte è andato in esecuzione in programma.

Il problema sono riuscito ad isolarlo: funge tutto alla perfezione finchè non utilizzo la riga :
eei_write_byte(cnt,1);
sembra sia questa a creare il problema, perchè commentandola fila tutto liscio come l’olio.

Il programma non dovrebbe nemmeno partire, a detta del pickit la programmazione dovrebbe esser fallita, eppure il programma parte, ogni 2 secondi e mezzo la cifra aumenta da sola. se premo il tasto del reset non aumenta subito dopo (come dovrebbe, dal momento che il programma dovrebbe ripartire dall’inizio), ma semplicemente attende sempre quei due secondi e mezzo e và avanti con la cifra. Ti posso assicurare che in fin dei conti l’eeprom la scrive dal momento che se tolgo l’alimentazione e la rimetto il numero stampato subito dopo l’accensione è quello che mi compariva qualche istante prima di togliere l’alimentazione.

Un’ultima cosa strana è che per una frazione di secondo, prima di cambiare cifra, sull’lcd compaiono altri caratteri, ad es:

Counter: 227 questo a 0sec
S a S !

Cou ter: 2u7 questo a +200ms
S a S !

Counter: 228 questo da 500ms a 2,5s
S a S !

In loop, questo è il comportamento, in automatico.
Che stranezza, eppure ho seguito il datasheet nel modificare la libreria, la cosa troppo strana è quell’errore, non capisco da dove salta fuori.

Premettendo che il pickit3 mi spara questo errore:
*****************************************************************************
Programming…
The following memory regions failed to program correctly:
EEData Memory
Address: 00000001 Expected Value: 00000000 Received Value: 00000001
Programming failed
*****************************************************************************

Pur programmando lo stesso la periferica, il semplicemente aggiunge un unità ad un valore memorizzato nella posizione 1 dell’eeprom ad ogni riavvio e lo stampa sull’lcd; vedo che sull’lcd visualizza la cifra, ma aumenta automaticamente (wtd disabilitato!!) e sembra insensibile ai reset.

La libreria è questa (ridotta solo alle operazioni su un byte):
*****************************************************************************
// legge un BYTE (8bit) dall’indirizzo specificato in “address”
unsigned char eei_read_byte(unsigned char address)
{
EEADRL=address; // indirizzo da cui leggere
EEPGD=0; // accesso alla memoria eeprom
CFGS=0;
RD=1; // avvio la lettura
// il valore contenuto in EEDATA è disponibile dal prossimo ciclo
// se effettuo un return EEDATA, non ottengo nulla
char EEVALUE;
EEVALUE=EEDATL;
return EEVALUE;
}

// scrive un BYTE (8 bit) (valore “data”) nell’indirizzo specificato in “address”
void eei_write_byte(unsigned char data, unsigned char address)
{
EEADRL=address; // indirizzo in cui scrivere
EEDATA=data; // dati da scrivere
EEPGD=0; // accesso alla memoria eeprom
WREN=1; // abilito la scrittura
// Controllo se sono attivi gli interrupt e mi memorizzo la condizione
static bit temp=0;
if (GIE)
{
temp=1;
GIE=0; // disabilito gli interrupt
}
// Queste due istruzioni che seguono sono richieste (vedi datasheet) per avviare la scrittura
EECON2=0×55;
EECON2=0xAA;
WR=1; // avvio un ciclo di scrittura
while(!EEIF); // attendo che la scrittura sia completa
WREN=0; // disabilito la scrittura sull’eeprom
EEIF=0; // resetto il flag di scrittura completa
// reimposto gli interrupt allo stato in cui si trovavano
if (temp)
{
GIE=1;
}
}

*****************************************************************************
#include
#include
#define PIC_CLK 32000000
#include “delay.c”
#include “lcd.c”
#include “e2prom.c”

// Fuses di configurazione
__CONFIG (FOSC_INTOSC & WDTE_OFF & PWRTE_ON & MCLRE_ON & CP_OFF & CPD_OFF & BOREN_OFF & CLKOUTEN_ON & IESO_OFF &
FCMEN_OFF & WRT_OFF & VCAPEN_OFF & PLLEN_OFF & STVREN_OFF & BORV_19 & DEBUG_ON & LVP_OFF);

__EEPROM_DATA(0,0,0,0,0,0,0,0);

// funzione principale, eseguita all’avvio del picmicro
void main(void)
{
OSCCON = 0b11110000; //Oscillatore a 32MHz
ANSELA=0;
TRISA=0;
ANSELB=0;
TRISB=0;

int cnt=eei_read_byte(1);
cnt++;
eei_write_byte(cnt,1);

LCD_INIT();
DelayMs(100);
LCD_CLEAR();
LCD_GOTO(1,1);
LCD_PUTS(“Counter: “);
LCD_PUTUN(cnt);
LCD_GOTO(2,1); //
LCD_PUTS(” S a S !”);
SLEEP();

}
*****************************************************************************
Qualche lume? (Prometto che stavolta non manderà tutto all’aria, devo assolutamente scrivermi questa libreria, anche se per le operazioni su 16 bit le cose cambiano parecchio dal momento che ho un’indirizzamento su 10 bit e tante altre cosucce che mi incasineranno le cose)

Grazie,
Luca

Quindi come dicevo l’eeprom la puoi riscrivere un milione di volte (ovviamente lo sarà sicuramente qualcosa di più dal momento che su questi dati si dichiara sempre un valore di sicurezza per stare tranquilli), mentre la memoria programma è più limitata (100mila volte).
Un’eeprom esterna (ho preso ad esempio la 24LC512) porta scritto:
More than 1 Million Erase/Write Cycles
Quindi il parametro è sempre 1milione ma qui c’è scritto “più di”, e comunque se uno ci deve scrivere di continuo, come già detto, è meglio usarne una esterna almeno non si compromette il chip principale. E poi penso che questo parametro sia “per cella” (ma non è specificato quindi non so fino a che punto possa essere vera tale affermazione)

Sto realizzando un tachimetro e dovrei quindi memorizzare in eprom sia i km parziali che i km totali(i totali ogni km, i parziali ogni 100 metri). Essendo quindi la memoria eeprom riscrivibile solo limitate volte(quante volte?), come aggiro il problema?

Riguardo alla piccola chicca…. Che cosa sarebbe? Non ci vedo nulla di particolare

L’unico problema riscontrato, usando un willem prog 5.0 è la lettura della eeprom dal computer, per permettere la lettura della eeprom a posteriori, è necessario settare su ON il flag “CP EEPROM” (anche se sembrerebbe li contrario). Talvolta, ovvero quasi sempre, il programmatore non riesce a leggere i primi 4 byte della epprom. Quindi ho cercato di evitare di usarli.

Piccola chicca: __EEPROM_DATA(“C”,”o”,”u”,”n”,”t”,”e”,”r”,”:”);… &&… eei_write_byte(counter,9); …. ;)