Newsgroup: it.hobby.elettronica.digitale
Titolo: [PIC] Gestire gli eventi nel tempo

Salve,
A scuola ci stanno facendo fare un esercizio con il microprocessore
PIC 16F84. I nostri professori sono abbastanza incapaci e non ci hanno
spiegato niente.
Ci hanno solamente dato dei documenti in pdf dove vengono spiegate
sommariamente le istruzioni del pic e qualche esercizio di esempio.
In passato abbiamo fatto un'esercitazione in cui dovevamo sviluppare
un programma che permettesse al PIC di contare il numero di impulsi
forniti in ingresso e visualizzarli su 4 LED.
Adesso dobbiamo modificare il programma e fare in modo che il PIC
indichi il numero di impulsi in un secondo.
Insomma: un misuratore di frequenza.
Il problema è che non riesco a trovare un modo per gestire il tempo.
Il PIC infatti dovrebbe contare il numero di impulsi (con il codice
vecchio dovrebbe funzionare) ma non so come fargli contare ogni
secondo.
Non so che timer esistono nel PIC. Ho visto che esiste il watch-dog
timer ma sinceramente non ho capito come funziona e come si usa.
In pratica il PIC dovrebbe contare gli impulsi e, ciclicamente, ogni
secondo, azzerarsi e reiniziare da capo.
Voi avete idea di come posso fare? Cosa (e come) posso usare?
Sono abbastanza nel dolore :-(
Grazie mille,
Pictor! :-D

spiegato niente.
[...]
Io farei così:
- imposto un timer per scattare ogni tot millisecondi (tot noto dal
valore del timer + eventuali pre-post scaler)
- nel programma principale ho un loop continuo che conta sempre gli
impulsi
- nella routine di interrupt per il timer conto quante volte è
scattato, so ad es. che per raggiungere 1 sec deve scattare 4 volte
- se è scattato 4 volte, visualizzo il valore del conteggio e azzero
contatore
Se programmate il PIC in C ho alcune routine già pronte per gestire i
timer che posso inviarti, altrimenti prova a cercare, sicuramente
trovi in ASM routine simili
bye


...
Ma la frequenza (o impulsi al secondo) max in gioco qual'č ?
Pochi Hz o qualche Khz / Mhz ... ?

 
<cut>
Chissa' perche' i professori sono sempre incapaci. Mah.
Forse devono insegnarti anche a leggere i manuali e vedere come 
impostare un timer?
Il cellulare hai imparato ad usarlo a scuola o hai imparato da solo?
-- 
---
Giuseppe
-----------------------------------
http://digilander.libero.it/nokappa

Il cellulare hai imparato ad usarlo a scuola o hai imparato da solo?
Ho imparato da solo, idiota :-|


cut

 Chissa' perche' i professori sono sempre incapaci.
Non sempre, ma nella maggior parte dei casi, gli insegnanti sono incapaci
perche' il sistema di istruzione italiano favorisce gli incapaci.
Secondo te una persona capace andrebbe a fare un lavoro mal
pagato, che per essere fatto bene richiederebbe grande impegno
e responsabilita' ma se lo fai male nessuno ti sanziona e dove gli
aumenti di stipendio sono automatici e indipendenti dalle
capacita' e dall'impegno?
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 Ho imparato da solo, idiota :-|
L'unica cosa a cui credo di tutto cio' che hai scritto.
Sono andato a scuola moooolto prima di te, e di professori ne ho visti 
di tutti i tipi e colori (politici).
Ne ho avuti di bravi e meno bravi.
Ma al contrario di te (e se e' vero cio' che hai scritto, della tua 
classe) quando avevamo un professore che se ne sbatteva, la prima tappa 
era un colloquio a quattrocchi con il professore, poi se non si 
ottenevano risultati si andava dal preside, ed infine giu' con gli 
scioperi e le occupazioni.
Ne e' passata di acqua sotto i ponti da allora, forse avevamo un po' di 
motivazione in piu'.
Di gente come te me ne passano sotto le mani almeno due ogni sei mesi, e 
non ti dico che soddisfazione :)
Ti saluto lo stesso, e ti do un consiglio gratis "studia di piu' e 
naviga di meno"
-- 
---
Ciao
Giuseppe
-----------------------------------
http://digilander.libero.it/nokappa


Grande!!
Non intervengo quasi mai ma questa è bellissima!
Ciao
Renato 

><cut>
E la cosa piu' ridicola di tutto il discorso, e' che il manuale del 
16F84 e' di appena 125 pagine (copertine comprese).
Leggendo solo la parte TMR0 si riduce a neanche una decina di facciate.
Troppo complicato?
P.S. Di siti in italiano che riportano esempi di codice con il PIC ce ne 
sono a decine, solo che la pappa fatta e' piu' buona.
Detto cio' ..... plonk


Saluti.
K effettivamente mi sono scaldato un pň... purtroppo sono anni che
devo sopportare i due prof e ultimamente mi hanno fatto veramente
girare le scatole. Dopo un bel pň a cercare su internet e a cercare
aiuto un pň ovunque ho postato qua sperando in un disperato aiuto e mi
sono alterato un pň leggendo una risposta inutile (perchč inutile era)
ed ironica... ironia che perň a me non fa affatto ridere visto che
prenderň (prenderemo tutti meno 1) 2, forse 3 ad elettronica, con
consequente abbassamento della media finale (e siamo all'ultim'anno).
Mi scuso se ho risposto male ma anche Giuseppe non č totalmente
innocente neppure lui.
Comunque non voglio scatenare ulteriori flames....

naviga di meno"
Quello sicuramente.... ma non credo che sia tu a dovermelo dire
(soprattutto nell'ambito dell'elettronica, visto che la studio
assiduamente.... e visto che non mi conosci ;-P)
Bye

Detto cio' ..... plonk
Fai tu... se proprio ti piace tanto... non credo comunque di
meritarmelo (ma probabilmente non mi leggerai mai)

Pictor ha scritto:
<cut>
Dopo la parentesi "non e' colpa mia ma della societa'" passiamo a 
parlare di elettronica.
Quando si programma, bisogna prima di tutto semplificare al massimo il 
problema. Anche se attualmente non sembra essere piu' in voga, io adoro 
il metodo top-down e metalinguaggio.
In pratica cosa deve fare il programma: Contare le variazioni da 0 a 1 
di un ingresso per un tot di tempo, e visualizzare il risultato.
Da qui si puo' dedurre che fondamentalmente tutto si puo' fare con due 
contatori incapsulati: Il primo piu' esterno deve creare una finestra 
temporale e il secondo all'interno contare quante volte l'ingresso e' 
passato da 0 a 1.
I dati che devi sapere a priori sono la frequenza del quarzo e la 
frequenza di ingresso.
Da quello che ho letto, la frequenza massima in ingresso e' di 15Hz (4 
led di visualizzazione e un secondo di finestra)
Supponiamo inoltre che l'ingresso sia pulito e non abbia rimbalzi o glitch.
Non ho capito inoltre se programmi in C o in assembler.
Soluzione 1 (Metodo so poco ma l'importante e' arrivare alla sufficenza):
CNT_TEMPO=0
CNT_IMPULSI=0
STATO_INPUT_PRECEDENTE=0
Loop infinito
{
  CNT_TEMPO = CNT_TEMPO + 1
  Se contatore CNT_TEMPO < costante sperimentale per creare 1 secondo
  {
   Se STATO_INPUT_PRECEDENTE = 0 e INPUT=1
    {
     STATO_INPUT_PRECEDENTE = 1
     Se CNT_IMPULSI < 15
       CNT_IMPULSI = CNT_IMPULSI + 1
    }
   Altrimenti
    {
     STATO_INPUT_PRECEDENTE = 0
    }
  Altrimenti
  {
   Copia valore CNT_IMPULSI in VAL_FREQUENZA (o copia i 4 bit bassi 
sulle uscite dei led)
   Azzera CNT_IMPULSI
   Azzera CNT_TEMPO
  }
}
Lo stato precedente dell'ingresso serve a capire se c'e' stato un fronte 
di salita nell'ingresso di conteggio, per evitare di incrementare 
continuamente il contatore impulsi nel caso il pulsante venga tenuto 
premuto.
La costante per creare 1 secondo puo' essere calcolata partendo dalla 
frequenza del quarzo e contando i cicli di clock delle istruzioni 
eseguite, ma la maniera piu' veloce e' mettere un valore a caso (penso 
sia sicuramente un numero di circa 16 bit o maggiore), all'interno della 
parte di codice dove vengono azzerati i contatori e visualizzata 
l'uscita inverti lo stato di un'uscita di un led e con un cronometro 
vedi di avvicinarti il piu' possibile al tempo di 1 secondo con led 
spento e 1 secondo con led acceso, avendo un'oscilloscopio tutto sarebbe 
piu' semplice.
Soluzione 2 (Metodo sono quasi un professionista):
Devi calcolarti quanto deve contare il timer0 per avere un interrupt 
ogni 100mS (ad esempio)
Il programma diventa quindi:
Routine chiamata dall'interrupt:
{
   Se CNT_TEMPO > 0
    {
     CNT_TEMPO = CNT_TEMPO - 1
    }
   Resetta flag di interrupt
}
Programma principale:
Inizializza TMR0 e tutto il resto del chip
CNT_IMPULSI=0
STATO_INPUT_PRECEDENTE=0
CNT_TEMPO = 10;
Loop infinito
{
  Se contatore CNT_TEMPO != 0
  {
   Se STATO_INPUT_PRECEDENTE = 0 e INPUT=1
    {
     STATO_INPUT_PRECEDENTE = 1
     Se CNT_IMPULSI < 15
       CNT_IMPULSI = CNT_IMPULSI + 1
    }
   Altrimenti
    {
     STATO_INPUT_PRECEDENTE = 0
    }
  Altrimenti
  {
   Copia valore CNT_IMPULSI in VAL_FREQUENZA (o copia i 4 bit bassi 
sulle uscite dei led)
   Azzera CNT_IMPULSI
   CNT_TEMPO=10			/* Aspetta 10 volte i 100mS */
                                 /* dell'interrupt */
  }
}
Devi stare attento che CNT_TEMPO venga caricata da una singola 
istruzione (se il micro lavora a 8 bit deve essere una variabile ad 8 
bit), altrimenti puo' succedere che si intruffoli l'interrupt tra i due 
caricamenti con risultati imprevedibili ma sicuramente poco simpatici.
Una soluzione nel caso dovesse essere necessario caricare la variabile 
in due colpi e' disabilitare l'interrupt prima di iniziare il 
caricamento e riabilitarlo subito dopo.
Sul sito:
http://web.tiscali.it/vcoletti/pic/dice/dado.html
c'e' un programmino che simula un dado elettronico con il programma in 
assembler commentato in maniera esemplare che utilizza il timer0
Sul sito della Microchip c'e' il documento 31011a.pdf che spiega in 
dettaglio l'utilizzo del timer 0 con esempi di codice.
Oltre a questi due esempi, scritti di getto e ad ore antelucane, il 
problema puo' essere risolto in altri mille modi piu' o meno complicati.
Per concludere ti dico due cose:
1) In elettronica la lingua franca e' l'inglese. Volenti o dolenti 
questa e' la sola ed unica lingua che ti permette di accedere a tutto lo 
scibile.
2) La scuola deve darti il metodo di studio, non nozioni in quanto tutto 
quello che stai studiando ora e studierai in futuro e' gia' superato nel 
momento in cui hai finito di leggere il manuale (se non prima). Quindi 
devi essere preparato ad imparare continuamente anche quando il 
professore non ci sara' piu'. La scuola e' solo un trampolino verso la 
vita reale e, nella vita reale te la devi sbrigare da solo.
Per aspera ad astra


Per aspera ad astra
Grazie mille mi sei sei stato moooolto di aiuto :D
Esauriente e preciso.
Vedrò che cosa riesco ad ottenere! Sperando di riuscire a districarmi
nei meandri dell'assembler e della programmazione di PIC...
...e grazie per i consigli ;)