Newsgroup: it.hobby.elettronica.digitale
Titolo: Codice per Pic 16f84a

Salve a tutti i frequentatori di questo newsgroup , spero che qui qualcuno
mi possa dare qualche suggerimento..
Sono alle prime armi per quanto riguarda la programmazione dei pic...Spero
davvero che mi diate una mano..
Vorrei realizzare tramite il pic 16f84a , un lampeggio "indipendente" e
"intelligente" di 4 led
comandati tramite i rispettivi 4 pulsanti.
Ogni qualvolta si verifica l'evento della pressione di uno dei 4 pulsanti ,
il pic dovrebbe iniziare
un lampeggio (sul corrispettivo led)  della durata complessiva di 15 secondi
.
La sopracitata "routine" dovrebbe essere applicata a tutti e 4 i pulsanti
connessi al pic.
I pulsanti sono collegati al pic cosi:         SW1=RA0 , SW2=RA1 , SW3=RA2 ,
SW4=RA3
mentre i led sono collegati al pic cosi:     LED1=RB0 , LED2=RB1 , LED3=RB2
,LED4=RB3.
Per " lampeggio indipendente" intendo dire che se viene premuto il pulsante
SW1 ,
e dopo 10 secondi viene premuto il pulsante SW2 ,  il  LED2 deve finire di
lampeggiare
10 secondi dopo che si è spento il LED1.
Come ho gia detto il tempo complessivo di lampeggio di un solo led
dovrebbe essere di 15 secondi. E cosi vale anche per gli altri led.
Per " lampeggio sensibile " intendo dire che se per esempio il pulsante
SW1 viene premuto una volta e trascorsi 10 secondi viene ripremuto,
il tempo di lampeggio dovrebbe ripartire da capo, e quindi rifare i 15
secondi di lampeggio.

 mi possa dare qualche suggerimento..
Che tipo di problema hai? Non sai proprio da dove cominciare, oppure ti
sei bloccato da qualche parte?
Oppure vorresti il programma già scritto e funzionante?

Nello wrote:

che linguaggio usi???
io come ambiente uso
picbasic pro
microcode studio
icprog
funzionano alla grande!!!
per il tuo programma dovrai usare gli interrupt, a meno che non vuoi 
che, mantenendo le tue caratteristiche, i led lampeggino insieme, ovvero 
non sincronizzati sul periodo di lampeggio ma sui "battiti"
per intenderci premi un pulsante, inizia il lampeggio, ne premi un alro 
mentre il led sta lampeggiando e inizia a lampeggiare un altro led che 
sta acceso quando sta acceso quello di prima... questo lo puoi fare 
senza interrupt...
un abbozzo:
4 variabili inizializzate a 0
loop infinito
se premuto 1 metti variabile 1 a 15
se premuto 2 metti variabile 2 a 15
se premuto 3 metti variabile 3 a 15
se premuto 4 metti variabile 4 a 15
se variabile 1 diversa da 0 accendi led 1
se variabile 2 diversa da 0 accendi led 2
se variabile 3 diversa da 0 accendi led 3
se variabile 4 diversa da 0 accendi led 4
pausa di 0.5 secondi
se variabile 1 diversa da 0 spegni led 1
se variabile 2 diversa da 0 spegni led 2
se variabile 3 diversa da 0 spegni led 3
se variabile 4 diversa da 0 spegni led 4
pausa di 0.5 secondi
se variabile 1 diversa da 0 decrementala di 1
se variabile 2 diversa da 0 decrementala di 1
se variabile 3 diversa da 0 decrementala di 1
se variabile 4 diversa da 0 decrementala di 1
loop
non sarà il max dell'eleganza ma dovrebbe funzionare
ciao
da

 ha scritto nel messaggio
news:DAQkd.157598$b5.77...@news3.tin.it...


Credo che tu sia suff. armato e che
il problema sia nella tua conoscenza
dei PIC e della programmazione firmware...
Non puoi usare i delay cosě perchč ogni delay
influenza gli altri e i cicli non risultano uniformi.
Se ti puň tranquillizare il tuo non č un problema
banale.
Potrsti fare cosě:
- programma un timer @ 1ms.
- Sotto l'intrpt di questo timer gestisci l'incremento
    dei 4 timer per il lampeggio dei LED.
- Ogni 100 INTRPT (0,1 secondi quindi) decrementi
    i timeout per i lampeggi dei LED.
- Il tuo idle loop testa lo stato dei timer per il lampeggio
    dei LED e accende / spegne i LED.
- Sempre il tuo idle loop testa lo stato dei pulsanti e
    ricarica i timeout.
In questo modo ogni LED puň lampeggiare con
una frequenza indipendente.
-- 
***** The Ovekill !!! *****
In un mare calmo ogni uomo č pilota...

 della libreria " Delay ()" messa a disposizione sul sito.
Come ha detto Overkill questo e' un caso in cui usare l'istruzione delay non
va bene. Andrebbe bene per un solo led (un singolo processo di
elaborazione), ma il tuo progetto richiede 4 processi indipendenti tra loro
portati avanti in parallelo, e un delay su uno rallenterebbe anche gli
altri. Diventa altresi' impossibile pensare ad un codice che sia in grado di
leggere i pulsanti / calcolare i tempi / comandare i led in ogni possibile
condizione in cui ci si puo' venire a trovare (e i delay bloccano
l'esecuzione di tutto finche' durano).
Il software deve in qualche modo realizzare un funzionamento multitasking,
che fortunatamente e' meno difficile di quanto si possa pensare, pero'
occorre passare dall'idea del programma "istruzione dopo istruzione" a
quello del programma formato da tante piccole macchine a stati (semplici
subroutines o, in C, istruzioni switch) da richiamare continuamente ogni
pochi millisecondi.
Ogni macchina e' un processo indipendente, deve avere una variabile di stato
che indica la sua condizione attuale, va richiamata ciclicamente, e ad ogni
chiamata controlla il verificarsi di un certo evento (ed eventualmente
cambia di stato e compie qualche veloce operazione), poi ricede subito (nel
piu'breve tempo possibile) il controllo al ciclo principale che chiama le
altre macchine. In questo modo e' possibile avere N processi paralleli
indipendenti (o anche cooperanti... per esempio se si volessero i lampeggi
sincronizzati la modifica sarebbe banale) in esecuzione.
La cosa fondamentale e' quindi la presenza di un "ciclo principale" che
continua a richiamare i processi, non e' necessario usare gli interrupt,
basta che il ciclo sia in qualche modo "agganciato" ad una frequenza precisa
(base tempi), questa potrebbe arrivare dall'esterno su un pin, oppure essere
generata dal timer interno.
Una curiosita' e' il fatto che mentre usando le istruzioni delay il micro e'
occupato per la maggior parte del tempo a creare questi ritardi software (e
non puo'occuparsi di altro), usando questo tipo di multitasking invece il
micro passa la maggior parte del tempo a non fare nulla (se non ad aspettare
che scada il tempo della base tempi), e l'elaborazione vera e propria
impegna poche centinaia di uS (o meno) ad ogni ciclo.
Un'altra cosa e' che la scrittura a processi aiuta a suddividere
atomicamente il software in modulini estremamente semplici da maneggiare /
scrivere / comprendere, molto simili al funzionamento di singoli blocchetti
hardware. Per esempio potrebbero esserci 4 microprocessi che si incaricano
esclusivamente di leggere il relativo pulsante applicando una funzionalita'
antirimbalzo, e il risultato puo' essere messo in una variabile che indica
pulsante on/off. Quattro altri piccoli processi possono poi funzionare da
semplici temporizzatori (nel tuo caso retriggerabili), leggono le variabili
precedenti e danno in uscita un 1 o 0. Infine 4 processi di lampeggio
leggono questi 1 e 0 in arrivo dai temporizzatori, e semplicemente
lampeggiano quando gli arriva un 1.... non serve piu' scrivere decine di if
then nidificati per tenere conto di tutte le combinazioni possibili ;)
ciao
Claudio F