PIC timer preimpostato

[simo85]

Mi riferisco a nRBU, non a TRISA, PORTA etc.
Comunque vedi che ho editato il mio messaggio precedente mentre scrivevi.

Vedo che hai deciso di usare MicroC. Io non lo conosco e non l'ho mai usato.

[bebos89]

L'ho visto e ho editato la risposta nel frattempo, comunque mi sono limitato a seguire le indicazioni di chi ne sa più di me e prossimamente inserirò con il tag CODE così:

Codice: Seleziona tutto

# define piccolo PORTB.F4
# define grande PORTB.F5
# define stop PORTB.F6
# define rele1 PORTA.F1
# define rele2 PORTB.F2
# define rele3 PORTB.F3

void main() {
     nRBPU    =   0;
     TRISB           = 0b11110011; // RB2-RB3 output
     TRISA           = 0b11111101; // RA1 output
     PORTA           = 0b11111101; // RA1 LOW
     PORTB           = 0b11110011; // RB2-RB3 LOW
     while(1) {                       //ciclo infinito
   if (piccolo){                  // se il pulsante è a livello logico alto
   rele1=1;                          //il rele1 si accende
   Delay_ms(500);                     //ritardo di mezzo secondo
   rele2=1;                            //accendere rele 2
   rele3=1;                            //accenere rele3
   Delay_ms(1500);                    //dopo 1.5 secondi
   rele1=0;                            //spegnere rele1
   Delay_ms(2500);                    //dopo 4.5 secondi dall'inizio
   rele2=0;                            //spegnere rele2
   Delay_ms(5500);                    //dopo 7.5 secondi
   rele3=0;                            //spegnere rele3
   }
  else rele1=0;                      //altrimenti rimane spento
}
}

[IlGuru]

Mi riferisco a nRBU (che poi non serve se rappresenta il flag di pull-up)

Ho il codice di un vecchio firmware in cui scrivevo su MPLABX:

Codice: Seleziona tutto

OPTION_REGbits.nRBPU = 0;


Ma con MicroC le definizioni dei pin e dei flag possono essere diverse.

[IlGuru]

Codice: Seleziona tutto

if (piccolo){                  // se il pulsante è a livello logico alto
   rele1=1;                          //il rele1 si accende
} else {
   rele1=0;                      //altrimenti rimane spento
}


Se il pulsante è a livello logico alto, vuol dire che non è premuto, perché i pull-up lo mantengono a livello logico altro e solo se viene premuto si collega verso massa.
Inoltre metterei un ritardo di qualche millisecondo, tipo 100, prima dell'IF così pressioni più brevi, sfioramenti, rumori, rimbalzi ecc vengono ignorate.

[bebos89]

così va meglio?

Codice: Seleziona tutto

     while(1) {                       //ciclo infinito
     Delay_ms(100);                   // ritardo
   if (piccolo=0){                  // se il pulsante è a livello logico basso
   rele1=1;                          //il rele1 si accende


[IlGuru]

Mi sembra che così il codice vada.
Credo però che l'alimentazione dei relè non dovrebbe stare a valle del regolatore di tensione, ma a monte di questo o addirittura sotto una linea di alimentazione dedicata.

[WALTERmwp]

così va meglio?

... direi di no.
Intanto quel ritardo dopo lo statement del ciclo infinito non capisco che funzione possa avere e poi la sintassi, la comparazione la esegui con due "==", altrimenti è una assegnazione, ma probabilmente si tratta di una svista.
Io ti ho dato prima una indicazione col proposito di indirizzare un metodo, tale cioè, e comunque, a prescindere dal contenuto da me fornitogli, poi fai come credi ma ho la sensazione che si possa andare in "confusione" anche con due timer(s).
In ogni caso, buon lavoro.

Saluti

[bebos89]

Scusa Walter ma la soluzione che sono andato a scrivere mi sembrava la più semplice e lineare per ora tanto per capirci qualcosa visto che non ho mai usato i PIC. Se ho capito bene il tuo metodo è quello di fare una serie di loop con comparazione dei timer in modo tale da avere delle variabili incrementate (tempo trascorso) che vengono comparate continuamente con delle variabili fisse (step prefissati) finché il verificarsi della condizione non ci fa uscire dal loop ed entrare nella condizione successiva. Se pensiamo a 10 variabili abbiamo almeno 10 loop.
Ora la domanda mia domanda da assoluto neofita di questi integrati è quali vantaggi ci porta questo genere di discorso? Nel senso che probabilmente ho capito male io il tuo ragionamento e vorrei capirlo per fare un programmino il più regolare possibile.
Un 16f84 riesce a essere programmato con tanti cicli e lavorare bene?

[WALTERmwp]

Scusa Walter (...)

non ti devi scusare per nulla, tanto meno per le scelte che operi.

(...) Se ho capito bene il tuo metodo (...)

no, sei sulla strada sbagliata e mi sa che Paolino, anticipandoti un suggerimento sulla gestione dei pulsanti, aveva già chiara la situazione.

Mi sono permesso di suggerirti di "impostare" il tuo codice in modo tale da avere le idee abbastanza chiare prima di iniziare a scrivere righe di software.
Che poi tu lo faccia seguendo quello che ho scritto oppure no, poco cambia.

Non devi fare "tanti loop(s)" quanti sono i timer(s), il loop deve essere solo uno, quello principale,
All'interno di questo dovresti "interrogare" le variabili, in un flusso continuo, e agire di conseguenza, in base al loro valore.
Il TIMER, invece, costituisce una risorsa unica e condivisa; quando scade (ogni volta che scade) può scatenare l'interrupt che ti porta ad eseguire il codice della "routine di interrupt".
Nella routine di interrupt puoi gestire gli incrementi delle variabili (ovvero i timer(s)) che sono stati innescati ed eventualmente, se non si tratta di un TIMER che si "ricarica da solo", riattivarlo, oltre, naturalmente, ripristinare l'abilitazione generale per gli interrupt(s) (o comunque assolvere alla pratica necessaria affinché la gestione degli interrupt(s) possa riprendere una volta abbandonata la routine stessa).

Nel tuo loop principale, invece, oltre ai controlli degli input (i pulsantini) devi/dovresti comparare (sempre) il valore della tua variabile timer con il valore del parametro relativo; questo, come gli altri quattro (in tutto io te ne ho proposti cinque) sarebbe un'altra variabile "pre-inizializzata", per esempio ad una valore corrispondente a 4,5 secondi, che funge da termine di comparazione.

L'esito di una comparazione, nel caso risulti positiva, come avevo già scritto, implica l'esecuzione di una azione definita dalle tue esigenze.

Di per sé è un programma veramente molto semplice ma, se uno certe cose non le ha mai fatte (questo mi pare il tuo caso ma potrei sbagliarmi), mi rendo conto possa risultare complicato da realizzare.

Tu ragionaci sopra, ammesso sia riuscito ad esprimermi in modo comprensibile, poi, se vuoi, sulla scorta di questo puoi estendere l'impostazione del codice che ti è stata proposta.
Credo proprio che l'aiuto non verrà meno.

Saluti

[WALTERmwp]

Dunque, mi sembravi un pochino in difficoltà quindi, sulla scorta di quanto ho descritto, ho pensato di proporti qualcosa sul quale ti potresti basare:

Codice: Seleziona tutto

void main()
{
    // ...
    // inizializza tutte le variabili

    while(1)
    {                   
        // ...     

        //### timer1 ###
        if (evento1 || evento2)
        {
            if ((timer1 < comp_timer1)&&(flag_timer1==abilitata))
            {                 
                // ... attivo uscita Relè 1
            }
            else
            {                 
                // ... disattivo uscita Relè 1
       
                //disabilita flag
                flag_timer1=disabilitata;
            }

            //### timer2r ###       
            if ((timer2r >= comp_timer2r)&&(flag_timer2r==abilitata))
            {
                // ... attivo uscita Relè 2

                //disabilita flag
                flag_timer2r=disabilitata;
                //abilita flag
                flag_timer2=abilitata;
            }
            else
            {                 
                // ... nulla !?
            }

            //### timer3r ###       
            if ((timer3r >= comp_timer3r)&&(flag_timer3r==abilitata))
            {
                // ... attivo uscita Relè 3

                //disabilita flag
                flag_timer3r=disabilitata;
                //abilita flag
                flag_timer3=abilitata;
            }
            else
            {                 
                // ... nulla !?
            }
        }

        //### timer2 ###
        if ((timer2 >= comp_timer2)&&(flag_timer2==abilitata))
        {                 
            // ... disattivo uscita Relè 2
            //disabilita flag
            flag_timer2=disabilitata;
        }
        else
        {                 
            // ... nulla ! ?
        }

        //### timer3 ###
        if ((timer3 >= comp_timer3)&&(flag_timer3==abilitata))
        {                 
            // ... disattivo uscita Relè 3

            // ciclo (1 o 2) terminato
            // inizializza tutte le variabili
        }
        else
        {                 
            // ... nulla ! ?
        }

        //### pulsanti ### 
        if ((pulsante1 == pulsantePremuto)&&(evento1 == assente))
        {                 
            evento1 = presente;
            comp_timer1 = 2;
            comp_timer2 = 2;
            comp_timer3 = 2;
            comp_timer2r= 2;
            comp_timer3r= 2;     
            flag_timer1=abilitata;
            flag_timer2r=abilitata;
            flag_timer3r=abilitata;
        }
        if ((pulsante2 == pulsantePremuto)&&(evento2 == assente))
        {                 
            evento2 = presente;
            comp_timer1 = 3;
            comp_timer2 = 3;
            comp_timer3 = 3;
            comp_timer2r= 3;
            comp_timer3r= 3;     
            flag_timer1=abilitata;
            flag_timer2r=abilitata;
            flag_timer3r=abilitata;
        }
    }
}


//ROUTINE DI INTERRUPT
ISR()
{
    // TEST IRQ TIMER
    if(IRQ_TIMER)
    {
       if (flag_timer1==abilitata)
           ++timer1;
       if (flag_timer2==abilitata)
           ++timer2;
       if (flag_timer3==abilitata)
           ++timer3;
       if (flag_timer2R==abilitata)
           ++timer2R;
       if (flag_timer3R==abilitata)
           ++timer3R;

       // ... RIPRISTINO CONDIZIONI PER GESTIONE IRQ MICRO
    }
}


Ad una prima occhiata potrebbe risultarti già ovvio, comunque, leggilo con attenzione, verifica che non ci siano errori e incongruenze nella logica e, sopratutto, valuta se lo ritieni adeguato.
Dopo di ché puoi "adattare" le dichiarazioni delle variabili e di tutto quello che occorre per rendere compatibile lo script per l'interprete del tuo ambiente di sviluppo.

E' strutturato in modo molto lineare, vi sono anche diverse ridondanze (innocue) che in altri casi andrebbero evitate.
Anche alcuni test si potrebbero evitare ma, lasciando il codice in questo modo, dovrebbe risultare più immediata la tua interpretazione; quindi a scapito della sua leggerezza ma, non mi pare, ci siano problemi di "performance".

A livello di inizializzazioni devi provvedere con le define adeguate, magari anche sulla logica puoi intervenire.
Per il TIMER devi scegliere e impostare il prescaler e il valore da caricare nell'apposito registro in modo tale da determinare un tempo al quale ti puoi riferire per assegnare i valori adeguati ai parametri di comparazione e, di conseguenza, e per incrementare le variabili timer.

Andando oltre, il programma te lo scriveremmo tutto ma non sarebbe giusto per più motivi.

Saluti

p.s.
dovresti anche inserire i controlli di incongruenza, insomma "irrobustire" il codice.
Ho omesso il pulsante di stop che invece ti avevo suggerito, dato che non l'ho visto nello schema.