Utilizzo del DS1302 con PIC16F690

[Paolino]

ciclingman, prova a inviare il codice che hai scritto, così vediamo cosa c'è che non va.

Ciao.

Paolo.

[ciclingman]

Questo e' il codice del programma gestione datario. Dovrebbe leggere i secondi mediante display.
Per il momento legge 00 sia col datario che senza. Ho messo piu' commenti possibile, grazie ciao e a risentirci.
Fabrizio

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

Microprocessore usato PIC16F690 */

Codice: Seleziona tutto

   #include <PIC.h>           
   
   //Fusibili di configurazione
   __CONFIG(INTIO & UNPROTECT & WDTDIS & BOREN & PWRTEN & MCLRDIS);
   
   //Variabili a livello globale
   
    unsigned int  tempo; //Per interrupt
    unsigned char NumSettaggi;           
    unsigned char scrittura; //Per ciclo for che scrive
    unsigned int  func, funcsinc;       
    unsigned char letturasecondi[9]; //Lettura secondi in datario     
    unsigned int  secondi, secondi2, valore, valore2, decine, unita;   
    unsigned char valoreIO;   
    unsigned char ScritturaControllo(unsigned char valore4);
    unsigned char LetturaControllo(unsigned char valore5);
   
    #define Door   PORTC    //Porta C
   
    #define RS     RB7      //Display
    #define Enable RB5
   
    #define RST    RC5      //Datario
    #define SCLK   RC6
    #define IO     RC4   
   
    unsigned char ScritturaControllo(unsigned char valore4)
    {
    unsigned char valore4_ScritturaControllo;       
   
    SCLK = 0;  //Reset     
    TRISC = 0x00; //Setta la porta IO come output
    RST = 1;   //Abilitazione comunicazione             
               
     for(secondi = 0; secondi < 8; secondi++)
     {
    IO = valore4 & 0x01;
    valore4 = valore4 >> 1;   
    SCLK = 1;
    asm("nop");
    SCLK = 0;   
    asm("nop");                                                                                                
    }
    return valore4_ScritturaControllo;
   }
   
    //Funzione che legge e crea il byte da convertire e scrivere su display
    unsigned char LetturaControllo(unsigned char valore5)
    {
    unsigned char valore5_LetturaControllo;       
   
    TRISC = 0x00; //Setta la porta IO come output           
    RST = 1; //Abilitazione comunicazione                             
      for(secondi = 0; secondi < 8; secondi++)
      {
      IO = valore5 & 0x01;
     valore5 = valore5 >> 1;   
      SCLK = 1;
      asm("nop");                    
       if (secondi == 7) break;  //Non fa fronte discesa per non perdere primo dato restituito
      SCLK = 0;
      asm("nop");                                                
      }   
   
      TRISC = 0x10; //Setta la porta IO come input
      for(secondi = 0; secondi < 8; secondi++)
      {
     SCLK = 0;
     asm("nop");
     valore2 = valore2 << 1;                                           
     valoreIO = IO;
     valoreIO = valoreIO & 1;
     valore2 = valore2 + valoreIO;  //Sommare la cifra per raggiungere ASCII
     SCLK = 1;
     asm("nop");   
      RST = 0; //Disabilitazione per comunicazione
      }
                                                                                                     
      return valore5_LetturaControllo;
   }
   
   void RoutineRitardoSinc(void)    //Funzione di ritardo con bit
   {                               //di sincronismo
   tempo = funcsinc;              //per scrittura display
    Enable = 1;                   
    Enable = 0; 
    while (tempo != 0)
     {
    asm("nop");          
     }         
    }
   
    void RoutineRitardo(void)    //Funzione di ritardo 
   {
   tempo = func;                     
             
     while (tempo != 0)
     {
    asm("nop");          
     }         
    }

   
   void main(void)
              
   {
         
   // INIZIALIZZAZIONE HARDWARE
      
      //RABPU = 0x01;         //Pull Up DISABLED
      ANSEL = 0x00;
      ANSELH= 0X00;           //Esclusione porte analogiche, tutto digitale i/o
       //WPUA = 0x00;            //No pull-up
       
   // PORT A
      TRISA = 0x00;      //Port A tutto OUT            
      
   // PORT B
      TRISB = 0X00;      //Port B tutto OUT             
       
   // PORT C
      TRISC = 0x00;      //Port C tutto OUT (tranne bit 4  per datario prossimamente)                     
   
    // Oscillatore impostato a 4MHz per default
   
       OPTION = 0b00000010; //Prescaler 1:8
       INTCON = 0b10100001;
       OSCCON = 0b01110000; //Settaggio oscillatore interno a 8 MHz
       TMR0 = 6;  //Caricamento TIMER0 a 6 ms             
       
               
               /*INIZIALIZZAZIONE DISPLAY LCD ALFANUMERICO
----------------------------------------------------------------------------------*/               
                     
       func = 500;           //Ritardo all'accensione di 0,5 sec.
       RoutineRitardo();               
                                     
        for (NumSettaggi = 1; NumSettaggi <= 3; NumSettaggi++)
        {                                          
        funcsinc = 100;          //100ms
        RS = 0;   
        Door = 0b00000010; //Comunicazione a 4 bit
        RoutineRitardoSinc();   
               
        Door = 0b00000000; //Incremento DDRAM e spostamento display
        RoutineRitardoSinc();           
        Door = 0b00000100;
        RoutineRitardoSinc(); 
       
        Door = 0b00000000; //Entry mode
        RoutineRitardoSinc();   
        Door = 0b00000110;
        RoutineRitardoSinc();       
                   
        Door = 0b00000000;  //Accensione display
        RoutineRitardoSinc();
        Door = 0b00001100;
        RoutineRitardoSinc(); 
       
        Door = 0b00000000;  //Clear display e counter in posiz. 0
        RoutineRitardoSinc();
        Door = 0b00000001;
        RoutineRitardoSinc();
        }
       
        func = 5;           //5 ms di pausa
        RoutineRitardo();
       
                 /* FINE INIZIALIZZAZIONE DISPLAY ALFANUMERICO
---------------------------------------------------------------------------
                    INIZIO LETTURA E SCRITTURA DATARIO */
                   
        //Chiamata funzioni
        ScritturaControllo(0x8E); //Byte di controllo
        ScritturaControllo(0x01); //Byte di reset CH e settaggio secondi
        ScritturaControllo(0x81); //Scrittura byte per lettura secondi
       
        while (1) 
        {
        func =1000;
        RoutineRitardo();   
        
        LetturaControllo(0x80);  //Lettura byte dei secondi restituito dal datario       

         decine = valore2 >> 4 | 0b00110000; //Conversione in ASCII delle decine
         unita = valore2 | 0b00110000; //Conversione in ASCII delle unita
         
         //Inizio scrittura su display i numeri restituiti dal datario
                   
        funcsinc = 2;    //Tempo assegnato a routine di sincronismo 2ms
        RS = 1;         //Modalita' scrittura                        

        Door = decine >> 4; //Legge le decine (Nibble M)        
        RoutineRitardoSinc();
        Door = decine;   //(Nibble L)
        RoutineRitardoSinc();        
        
        Door = unita >> 4; //Legge le unita' (Nibble M)        
        RoutineRitardoSinc();
        Door = unita;   //(Nibble L)
        RoutineRitardoSinc();
        
        valoreIO = 0b00000000;
        valore2 = 0b00000000;
        
       func = 500;
       RoutineRitardo();  //Pausa di 0,5 sec.   
        RS = 0;            //Modalita' invio comando
        Door = 0b00000000; //Pone cursore in pos. 1 Address Counter a 0
        RoutineRitardoSinc();
        Door = 0b00000010;
        RoutineRitardoSinc();
                          
        }                       
       }                                       
     
       void interrupt intervallo (void)  //Interrupt del TIMER0 settato a 1 ms
       {
       if (T0IF) //Se overflow
       {
       if (tempo != 0)
       {
       tempo--; //Decremento   
         T0IF = 0; //Reset
         }       
       }
         }      

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

[ciclingman]

Ciao Paolo, non e' che hai guardato il mio codice? Vorrei aggiungere che utilizzo il compilatore HI-TECH SOFTWARE 9.60 e, in questo programma, mi da un warning che dice "Warning [176] C:\Documenti PIC\Programmi PIC\Display alfanumerico\Display alfanumerico.c; 233.0 missing newline"
Non ho idea del perche'.
Ciao

[Paolino]

Riesci a fare una sintesi del tuo codice? Da analizzare tutta quella spataffiata mi ci vuole un po'...

Per il warning: prova a mettere una riga vuota al termine del codice C: alcuni compilatori cercano una riga vuota (newline) per fare il parsing del sorgente e se manca la riga vuota emettono una segnalazione di avviso.

Ciao.

Paolo.

[ciclingman]

Allora faccio una sintesi del mio codice: dopo la dichiarazione di porte, variabili, funzioni, ecc.
inizio con la scrittura delle funzioni: la prima serve a scrivere il byte di controllo e il byte per dire al datario cosa vuoi che ti dica (se secondi, ore, ecc) ed infine la funzione che legge quello che il datario dice, nel mio caso i secondi; prova a controllare se faccio giusto in queste funzioni, l'utilizzo del clock, la scrittura o la lettura bit a bit. Nel main sono richiamate le funzioni col valore: la prima scrive il valore 0x8E (byte di controllo), la seconda scrive il valore 0x01, tutti i bit a 0 tranne il MSB chiamato CH che deve essere a 1 per avviare il clock, la terza scrive 0x80 per dire che leggera' i secondi ed infine, dentro al ciclo while legge i secondi col valore 0x80. Dopodiche' c'e' l'operazione di scrittura su display, ma questa funziona. Spero di essere stato chiaro, capisco che e' un casino leggere i programmi degli altri specialmente i miei.
Ho provato nell'ultima riga ad andare accapo con ENTER, non so se e' quello che intendi dire creare una riga vuota, ma mi da lo stesso warning. Grazie per l'attenzione, ciao.

[Paolino]

Ho cercato di dare una lettura ma continuo a fare moooooolta confusione...
Se vuoi, puoi scaricare i file che ho messo a disposizione in questo articolo ed usare quelli.

Ciao.

Paolo.

[ciclingman]

Ciao Paolo, ho guardato il tuo file sorgente per il ds1302, ma cos'e' "nop() una funzione che tu usi come ritardo? Se si' come l'hai scritta?
Ciao Fabrizio

[Paolino]

La "nop" è una istruzione di no-operation. La uso solo come ritardo tra una istruzione e la successiva, semplicemente invocando la nop assembly. Tu puoi continuamente utilizzare la tua

Codice: Seleziona tutto

asm("nop");


Ciao.

Paolo.

[ciclingman]

E come supponevo, pero' manca un bel po' di programma il quel file. Qualcosa ho visto, pero' sequenzialmente: io scrivo il byte di controllo (0x8E), poi scrivo il byte per leggere i secondi perche' voglio vedere solo i secondi (0x81), poi scrivo 0x80 e, finito di scrivere l'ultimo bit, inizio a leggere il bit 0 del byte che lui mi restituisce sotto forma di secondi; e' giusto?

[Paolino]

Confronta il tuo file con il datasheet: secondo me ti manca una parte di inizializzazione del dispositivo DS1302.

Ciao.

Paolo.