ElectroYou - la comunità dei professionisti del mondo elettrico

da **matteosr** » 20 lug 2009, 20:49

Ciao a tutti.

Sto cercando di realizzare un circuito con un PIC16f84, che mi chiuda il tetto apribile dell'auto quando gli arrivi un determinato segnale.

Praticamente l'auto ha una funzione (funzione comfort), quando tengo premuto a lungo il tasto del telecomando, il computer di bordo manda un determinato segnale ai motorini degli alzavetri, i quali capiscono che devono alzarsi o abbassarsi.

La mia idea è di intercettare questi segnali, e tramite un pic16f84a opportunamente programmato, azionare dei relè collegati al tasto di apertura e chiusura del tetto.

I segnali sono riuscito a leggerli è sono questi tre:
Apre

Chiude

E Stop Apre e Chiude

Mentre lo schema del circuito è questo:

Con il mio circuito i segnali vengono invertiti, quindi quando in ingresso ci sono 12 V al pin RA2 c'è 0, quando in ingresso c'è 0 sul pin ci sono 5V; in questo modo i tre segnali sono:

Apre: in standby c'è sempre 0, arriva un impusto a 5V per 135-136 ms, poi 0 per 90 ms, 5V per 90 ms, e torna in standby a 0

Chiude: in standby 0, arriva un impulso a 5v per 135-136 ms e torna in standby a 0

Stop: in standby 0, arriva un impulso a 5V per 60-61 ms e torna in standby a 0

Per semplificare le cose non farò casò alle temporizzazioni dei segnali che mi arrivano.
In definitiva, in condizioni di riposo possono arrivare solo due tipi di segnale, apre o chiude, che tradotti in bit sono 101 o 1;
mentre durante l'esecuzione delle funzioni, può arrivare solo il segnale di stop, che sarebbe 1.

Quindi o pensato di fare così:
Il PIC è in attesa di ricevere qualcosa, finquando sul pin RA2 c'è sempre 0 ricomincia;
succede qualcosa, sul pin RA2 arriva 1, attende che torna a 0;
Adesso, per capire se è un impulso apre o chiude, devo continuare a verificare il pin RA2 per altri 90 ms (meglio 100);
se arriva un altro impulso a 1, vuol dire che è "apre", quindi attende che torni a 0 e va a svolgere una funzione;
se non arriva niente, vuol dire che è "chiude", quindi va a svolgere un'altra funzione.

Nelle due funzioni da svolgere, devo continuare a monitorare il pin RA2 in attesa del segnale di stop, in questo caso 1,
quando l'ho ricevuto fermo tutto e torno al punto di partenza.

Questo è il codice che ho scritto fino adesso.

Codice: Seleziona tutto: list p=16f84a, f=inhx8m port_A equ 5 port_B equ 6 cont1 equ 0ch cont2 equ 0dh org 0 movlw 11h tris port_A ;Porta A tutti ingressi movlw 20h tris port_B ;Porta B 0 1 2 3 4 6 7 uscite 5 ingresso movlw 00h movwf port_B ;Azzera Porta B inizio: btfss port_A,2 ;Controlla RA2 salta se 1 goto inizio ;Torna all'inizio se 0 goto attendi ;Attendi che ritorni a 0 attendi: btfss port_A,2 ;Controlla RA2 salta se 1 goto riconosci ;Vai alla funzione per riconoscere apre chiude goto attendi ;c'è ancora 1 continua ad attendere che torni a 0 riconosci: movlw 100 movwf cont2 ;metti 100 cont2 loop1: movlw 200 movwf cont1 ;metti 200 cont1 loop2: decfsz cont1,1 ;decrementa cont1 salta se 0 goto verifica1 ;se 0 vai a verifica1 decfsz cont2,1 ;decrementa cont2 salta se 0 goto verifica2 ;se 0 vai a verifica2 goto chiude ;vai alla funzione chiude verifica1: btfss port_A,2 ;Controlla RA2 salta se 1 goto loop2 ;ritorna a loop2 goto attendi2 ;attendi che torna a 0, funzione apri verifica2: btfss port_A,2 ;Controlla RA2 salta se 1 goto loop1 ;ritorna a loop1 goto attendi2 ;attendi che torna a 0, funzione apri attendi2: btfss port_A,2 ;Controlla RA2 salta se 1 goto apre ;Vai alla funzione apre goto attendi2 ;c'è ancora 1 continua ad attendere che torni a 0 apre: ..... goto inizio chiude: ..... goto inizio end

Si può migliorare?
Purtroppo sono un po' arrugginito, la parte che riguarda il loop, dai conti che ho fatto dovrebbe ripetersi per 120800us con un quarzo da 4Mhz, giusto?
Praticamente sono 6 cicli di clock per il loop2 ripeturi 200 volte, ripetuti in un altro loop1 di 8 cicli per 100 volte;
(6x200=1200)x100=120000 cicli + (8x100)= 120800 cicli di clock = 120800us = 120,8 ms

Credo di aver scritto tutto correttamente finora, potete confermarlo?

Se quello che ho scritto va bene, posso continuare a scrivere le funzioni apre e chiude.
Vi ringrazio immensamente

ciao, matteosr

da **Paolino** » 22 lug 2009, 13:34

Ciao Matteo.
Non ho ancora avuto modo di approfondire a causa di problemi vari. Per il calcolo, ti consiglio di usare MPSIM che è contenuto in MPLAB: puoi misurare il tempo e verificare se coincide con i tuoi us stimati.

Ciao.

Paolo.

da **matteosr** » 23 lug 2009, 20:32

Mamma mia che lavoraccio, credevo fosse più semplice; per ogni passo che faccio in avanti, mi tocca farne due indietro.

Comunque per adesso credo di aver finito, l'unica cosa che vorrei modificare è il modo in cui legge il segnale apre e chiude,
per evitare che parta in automatico a causa di interferenze, o per qualsiasi problema, invece di accettare semplicemente un 1 indipendentemente dal tempo come inizio, dovrei temporizzarlo; cioè, dato che il primo segnale dura 135 ms, il PIC deve riconoscere un segnale che persista per almeno 130 ms, prima di decidere se aprire o chiudere. (Scusate se sono poco chiaro, ma sono veramente fuso)

Il circuito adesso funziona così:
Il PIC è in attesa di ricevere qualcosa, finquando sul pin RA2 c'è sempre 0 ricomincia;
succede qualcosa, sul pin RA2 arriva 1, attende che torna a 0;
Adesso, per capire se è un impulso apre o chiude, devo continuare a verificare il pin RA2 per altri 100 ms circa;
se arriva un altro impulso a 1, vuol dire che è "apre", quindi attende che torni a 0 e va a svolgere una funzione;
se non arriva niente, vuol dire che è "chiude", quindi va a svolgere un'altra funzione.

La funzione apre, è abbastanza complessa; dato che può essere eseguita più volte, ho deciso di memorizzare in un registro se gli specchietti sono già stati aperti, e far eseguire due diverse funzioni in base allo stato del registro.

Per far partire gli specchietti, bisogna alimentarli per circa 2,5s (per tutto il tempo devono ignorare lo stop, altrimenti potrebbero bloccarli a metà corsa), e mandare l'impulso di apertura (circa 1s).
Per il tetto invece, dato che ha due step di apertura, bisogna mandare prima un impulso di 1s circa, per farlo mettere in posizione spoiler, poi si deve attendere per circa 1s, e poi si può mandare H fisso per farlo aprire.
In tutto questo si deve comunque attendere il segnale di stop su RA2 per arrestare tutto.
Per sicurezza se non arriva un segnale di stop entro 8s circa, il PIC ferma tutto e per 10s non fa niente.

La funzione chiude è simile ad apre, solo che il tetto non fa due steep, ma si chiude direttamente.

Questo è il frutto di 4 giorni di lavoro (12 ore in totale, e due pacchetti di sigarette)

Codice: Seleziona tutto: LIST P=16F84A, F=INHX8M port_A EQU 5 port_B EQU 6 cont1 EQU 0Ch cont2 EQU 0Dh cont3 EQU 0Eh memory EQU 0Fh test EQU 10H MOVLW 0FFh TRIS port_A ;Porta A tutti ingressi MOVLW 20h TRIS port_B ;Porta B 0 1 2 3 4 6 7 uscite 5 ingresso MOVLW 00h MOVWF port_B ;Azzera Porta B MOVLW 00h MOVWF memory ;Azzera memory MOVLW 00h MOVWF test ;Azzera test inizio: BTFSS port_A,2 ;Controlla RA2 salta se 1 GOTO inizio ;Torna all'inizio se 0 attendi: BTFSC port_A,2 ;Attendi che ritorni a 0, Controlla RA2 salta se 0 GOTO attendi ;c'è ancora 1 continua ad attendere che torni a 0 riconosci: MOVLW 64h MOVWF cont2 ;metti 100 cont2 loop1: MOVLW 0C8h MOVWF cont1 ;metti 200 cont1 loop2: DECFSZ cont1,1 ;decrementa cont1 salta se 0 GOTO verifica1 ;se 0 vai a verifica1 DECFSZ cont2,1 ;decrementa cont2 salta se 0 GOTO verifica2 ;se 0 vai a verifica2 GOTO chiude ;vai alla funzione chiude verifica1: BTFSS port_A,2 ;Controlla RA2 salta se 1 GOTO loop2 ;ritorna a loop2 GOTO attendi2 ;attendi che torna a 0, funzione apri verifica2: BTFSS port_A,2 ;Controlla RA2 salta se 1 GOTO loop1 ;ritorna a loop1 GOTO attendi2 ;attendi che torna a 0, funzione apri attendi2: BTFSS port_A,2 ;Controlla RA2 salta se 1 GOTO apre ;Vai alla funzione apre GOTO attendi2 ;c'è ancora 1 continua ad attendere che torni a 0 ; Funzione Apre ; Bisogna verificare se sono già stati aperti gli specchietti in presenza di un impulso ; di apertura precedente, se vero non aprirli ; Per circa 2,5 s devono essere alimentati indipendentemente dal segnale di stop apre: MOVLW 00h MOVWF test ;Azzera test BTFSC memory,0 ;Controlla se sono stati già aperti gli specchi, salta se 0 GOTO nospec MOVLW 0FFh MOVWF memory ;Memorizza l'apertura degli specchi BSF port_B,0 ;Metti 1 RB0 apre tetto BSF port_B,2 ;Metti 1 RB2 alimenta specchietti BSF port_B,3 ;Metti 1 RB3 impulso apertura specchietto BSF port_B,6 ;Metti 1 RB6 accende led verde ; Impulso per far posizionare il tetto in modo spoiler, e per far partire gli specchietti ; per circa 800 ms ci sara 1 su RB0 ed RB4 CALL ritloop ; Bisogna togliere l'impulso di apertura degli specchietti ; e fare una pausa in posizione di spoiler per il tetto BCF port_B,0 ;Metti 0 RB0 ferma tetto BCF port_B,3 ;Metti 0 RB3 toglie impulso apertura specchietto CALL ritloop ; Continua a mantenere alimentati gli specchietti per 800 ms, e nel caso apre il tetto BTFSS test,0 ;controlla se in memoria è già arrivato uno stop, salta se 1 BSF port_B,0 ;Metti 1 RB0 apre tetto CALL ritloop BCF port_B,2 ;Metti 0 RB2 togli alimentazione agli specchietti BTFSC test,0 ;controlla se in memoria è già arrivato uno stop, salta se 0 GOTO basta ; se non è arrivato ancora lo stop continua ad attenderlo per altri 6s circa, dopodichè per sicurezza ; blocca tutto MOVLW 0Eh MOVWF cont3 ;metti 6 cont3 bloop1: MOVLW 0FFh MOVWF cont2 ;metti 255 cont2 bloop2: MOVLW 0FFh MOVWF cont1 ;metti 255 cont1 bloop3: DECFSZ cont1,1 ;decrementa cont1 salta se 0 GOTO stop1 ;se 0 vai a stop1 DECFSZ cont2,1 ;decrementa cont2 salta se 0 GOTO stop2 ;se 0 vai a stop2 DECFSZ cont3,1 ;decrementa cont3 salta se 0 GOTO stop3 ;se 0 vai a stop3 GOTO ole stop1: BTFSC port_A,2 ;Controlla RA2 salta se 0 GOTO zloop ;arrivato stop GOTO bloop3 ;ritorna a bloop3 stop2: BTFSC port_A,2 ;Controlla RA2 salta se 0 GOTO zloop ;arrivato stop GOTO bloop2 ;ritorna a bloop2 stop3: BTFSC port_A,2 ;Controlla RA2 salta se 0 GOTO zloop ;arrivato stop GOTO bloop1 ;ritorna a bloop1 zloop: BTFSC port_A,2 ;Attendi che ritorni a 0, Controlla RA2 salta se 0 GOTO zloop BCF port_B,0 ;Metti 0 RB0 ferma tetto BCF port_B,6 ;Metti 0 RB6 spegne led verde GOTO inizio ole: BCF port_B,0 ;Metti 0 RB0 ferma tetto BCF port_B,6 ;Metti 0 RB6 spegne led verde CALL ritardo GOTO inizio basta: BCF port_B,0 ;Metti 0 RB0 ferma tetto BCF port_B,6 ;Metti 0 RB6 spegne led verde GOTO inizio ; Funzione che apre il tetto senza aprire gli specchietti nospec: BSF port_B,0 ;Metti 1 RB0 apre tetto BSF port_B,6 ;Metti 1 RB6 accende led verde CALL ritloop ;ritardo di 800 ms BCF port_B,0 ;Metti 0 RB0 ferma tetto CALL ritloop ;ritardo di 800 ms BTFSC test,0 ;controlla se in memoria è già arrivato uno stop, salta se 0 GOTO basta BSF port_B,0 ;Metti 1 RB0 apre tetto MOVLW 12h MOVWF cont3 ;metti 15 cont3 loopnn1: MOVLW 0FFh MOVWF cont2 ;metti 255 cont2 loopnn2: MOVLW 0FFh MOVWF cont1 ;metti 255 cont1 loopnn3: DECFSZ cont1,1 ;decrementa cont1 salta se 0 GOTO verstopn1 ;se 0 vai a verstopn1 DECFSZ cont2,1 ;decrementa cont2 salta se 0 GOTO verstopn2 ;se 0 vai a verstopn2 DECFSZ cont3,1 ;decrementa cont3 salta se 0 GOTO verstopn3 ;se 0 vai a verstopn3 GOTO ole ;scaduto il tempo per sicurezza vai alla funzione fine2 verstopn1: BTFSS port_A,2 ;Controlla RA2 salta se 1 GOTO loopnn3 ;ritorna a loopnn3 GOTO zloop ;arrivato stop vai funzione zloop verstopn2: BTFSS port_A,2 ;Controlla RA2 salta se 1 GOTO loopnn2 ;ritorna a loopnn2 GOTO zloop ;arrivato stop vai funzione zloop verstopn3: BTFSS port_A,2 ;Controlla RA2 salta se 1 GOTO loopnn1 ;ritorna a loopnn1 GOTO zloop ;arrivato stop vai funzione zloop ; Funzione Chiude ; Gli specchietti funzionano come la funzione apre chiude: MOVLW 00h MOVWF test ;Azzera test BTFSS memory,0 ;Controlla se sono stati già chiusi gli specchi GOTO cnospec MOVLW 00h MOVWF memory ;Memorizza la chiusura degli specchi BSF port_B,1 ;Metti 1 RB1 chiude tetto BSF port_B,2 ;Metti 1 RB2 alimenta specchietti BSF port_B,4 ;Metti 1 RB4 impulso chiusura specchiette BSF port_B,7 ;Metti 1 RB7 accende led rosso ; Impulso per far partire gli specchietti per circa 800 CALL ritloop ; Bisogna togliere l'impulso di chiusura degli specchietti BCF port_B,4 ;Metti 0 RB4 toglie impulso chiusura specchietto ; Continua a mantenere alimentati gli specchietti per 1600 ms, e nel caso chiude il tetto BTFSC test,0 ;controlla se in memoria è già arrivato uno stop, salta se 0 BCF port_B,1 ;Metti 0 RB1, blocca il tetto CALL ritloop BCF port_B,2 ;Metti 0 RB2 togli alimentazione agli specchietti BTFSC test,0 ;controlla se in memoria è già arrivato uno stop, salta se 0 GOTO hbasta ; se non è arrivato ancora lo stop continua ad attenderlo per altri 6s circa, dopodichè per sicurezza ; blocca tutto MOVLW 0Eh MOVWF cont3 ;metti 6 cont3 cbloop1: MOVLW 0FFh MOVWF cont2 ;metti 255 cont2 cbloop2: MOVLW 0FFh MOVWF cont1 ;metti 255 cont1 cbloop3: DECFSZ cont1,1 ;decrementa cont1 salta se 0 GOTO hstop1 ;se 0 vai a hstop1 DECFSZ cont2,1 ;decrementa cont2 salta se 0 GOTO hstop2 ;se 0 vai a hstop2 DECFSZ cont3,1 ;decrementa cont3 salta se 0 GOTO hstop3 ;se 0 vai a hstop3 GOTO tole hstop1: BTFSC port_A,2 ;Controlla RA2 salta se 0 GOTO tzloop ;arrivato stop GOTO cbloop3 ;ritorna a cbloop3 hstop2: BTFSC port_A,2 ;Controlla RA2 salta se 0 GOTO tzloop ;arrivato stop GOTO cbloop2 ;ritorna a cbloop2 hstop3: BTFSC port_A,2 ;Controlla RA2 salta se 0 GOTO tzloop ;arrivato stop GOTO cbloop1 ;ritorna a cbloop1 tzloop: BTFSC port_A,2 ;Attendi che ritorni a 0, Controlla RA2 salta se 0 GOTO tzloop BCF port_B,1 ;Metti 0 RB1 ferma tetto BCF port_B,7 ;Metti 0 RB7 spegne led rosso GOTO inizio tole: BCF port_B,1 ;Metti 0 RB1 ferma tetto BCF port_B,7 ;Metti 0 RB7 spegne led rosso CALL ritardo GOTO inizio hbasta: BCF port_B,1 ;Metti 0 RB1 ferma tetto BCF port_B,7 ;Metti 0 RB7 spegne led rosso GOTO inizio ; Funzione che chiude il tetto senza chiudere gli specchietti cnospec: BSF port_B,1 ;Metti 1 RB1 chiude tetto BSF port_B,7 ;Metti 1 RB7 accende led rosso MOVLW 013h MOVWF cont3 ;metti 15 cont3 cloopnn1: MOVLW 0FFh MOVWF cont2 ;metti 255 cont2 cloopnn2: MOVLW 0FFh MOVWF cont1 ;metti 255 cont1 cloopnn3: DECFSZ cont1,1 ;decrementa cont1 salta se 0 GOTO cverstopn1 ;se 0 vai a cverstopn1 DECFSZ cont2,1 ;decrementa cont2 salta se 0 GOTO cverstopn2 ;se 0 vai a cverstopn2 DECFSZ cont3,1 ;decrementa cont3 salta se 0 GOTO cverstopn3 ;se 0 vai a cverstopn3 GOTO tole ;scaduto il tempo per sicurezza vai alla funzione cfine2 cverstopn1: BTFSS port_A,2 ;Controlla RA2 salta se 1 GOTO cloopnn3 ;ritorna a cloopnn3 GOTO tzloop ;arrivato stop vai funzione cfine cverstopn2: BTFSS port_A,2 ;Controlla RA2 salta se 1 GOTO cloopnn2 ;ritorna a cloopnn2 GOTO tzloop ;arrivato stop vai funzione cfine cverstopn3: BTFSS port_A,2 ;Controlla RA2 salta se 1 GOTO cloopnn1 ;ritorna a cloopnn1 GOTO tzloop ;arrivato stop vai funzione cfine ; Routine di ritardo loop, circa 900 ms ritloop: MOVLW 02h MOVWF cont3 ;metti 6 cont3 preloop1: MOVLW 0FFh MOVWF cont2 ;metti 255 cont2 preloop2: MOVLW 0FFh MOVWF cont1 ;metti 255 cont1 preloop3: DECFSZ cont1,1 ;decrementa cont1 salta se 0 GOTO prestop1 ;se 0 vai a prestop1 DECFSZ cont2,1 ;decrementa cont2 salta se 0 GOTO prestop2 ;se 0 vai a prestop2 DECFSZ cont3,1 ;decrementa cont3 salta se 0 GOTO prestop3 ;se 0 vai a prestop3 RETURN prestop1: BTFSC port_A,2 ;Controlla RA2 salta se 0 CALL testoff ;routine memoria di stop GOTO preloop3 ;ritorna a preloop3 prestop2: BTFSC port_A,2 ;Controlla RA2 salta se 0 CALL testoff ;routine memoria di stop GOTO preloop2 ;ritorna a preloop2 prestop3: BTFSC port_A,2 ;Controlla RA2 salta se 0 CALL testoff ;routine memoria di stop GOTO preloop1 ;ritorna a preloop1 ; Routine per memorizzare lo stop per i loop testoff: BTFSS test,0 ;controlla se in memoria è già arrivato uno stop, salta se 1 BSF test,0 ;altrimenti memorizza RETURN ; Routine di ritardo, circa 10s ritardo: MOVLW 014h MOVWF cont3 ;metti 20 cont3 stopnn1: MOVLW 0FFh MOVWF cont2 ;metti 255 cont2 stopnn2: MOVLW 0FFh MOVWF cont1 ;metti 255 cont1 stopnn3: NOP NOP NOP NOP NOP NOP DECFSZ cont1,1 ;decrementa cont1 salta se 0 GOTO stopnn3 ;se 0 vai a verstopn1 DECFSZ cont2,1 ;decrementa cont2 salta se 0 GOTO stopnn2 ;se 0 vai a verstopn2 DECFSZ cont3,1 ;decrementa cont3 salta se 0 GOTO stopnn1 ;se 0 vai a verstopn3 RETURN END

Che ne dite?

da **c1b8** » 23 lug 2009, 21:51

In pratica devi realizzare una macchina a stati, ogni passo successivo dipende dall'attuale e dall'evento occorso durante l'esecuzione dello stato in corso.
Secondo me vista in questo modo il programma che hai scritto è ottimizzabile.
Dammi qualche ora e proverò a indicarti quali interventi farei io.

da **matteosr** » 25 lug 2009, 1:43

Sono in trepidante attesa, sai, pei i cicli di loop ho preso spunto da una tua replica in un post precedente riguardante un contatore.

Sto provando al banco il circuito con qualche piccola modifica al codice, invece di avere in ingresso i segnali apre o chiude, ho collegato due pulsanti, ma rimbalza di continuo.

Nonostante abbia creato un loop che attenda fin quando venga rilasciato il pulsante, non faccio in tempo a premerlo che subito va in stop. Per provare se tutto funziona, devo sbattere velocemente il pulsante sul tavolo, e una volta su dieci riesco a farlo andare normalmente.

Non riesco a capire perché.

Questa è la modifica

Codice: Seleziona tutto: LIST P=16F84A, F=INHX8M port_A EQU 5 port_B EQU 6 cont1 EQU 0Ch cont2 EQU 0Dh cont3 EQU 0Eh memory EQU 0Fh test EQU 10H MOVLW 0FFh TRIS port_A ;Porta A tutti ingressi MOVLW 20h TRIS port_B ;Porta B 0 1 2 3 4 6 7 uscite 5 ingresso MOVLW 00h MOVWF port_B ;Azzera Porta B MOVLW 00h MOVWF memory ;Azzera memory MOVLW 00h MOVWF test ;Azzera test inizio: BTFSC port_A,2 ;Controlla RA2 salta se 0 GOTO attendi BTFSS port_B,5 ;Controlla RB5 salta se 1 GOTO attendi2 ;c'è ancora 0 continua ad attendere che torni a 1 GOTO inizio attendi: BTFSC port_A,2 ;Controlla RA2 salta se 0 GOTO attendi GOTO apre attendi2: BTFSS port_B,5 ;Controlla RB5 salta se 1 GOTO attendi2 GOTO chiude

Su RA2 c'è un pulsante n.c. collegato a +12 (che è invertito da un transistor, quindi che sempre 0)
Su RB5 c'è un pulsante n.a. collegato a massa.

Un'altra cosa che non capisco è, con un quarzo da 4Mhz ogni ciclo dovrebbe durare 1 us, quindi se mando il comando bcf su un pin, e poi lo mando su un altro pin, la cosa dovrebbe avvenire istantaniamente (ad 1 us di differenza), però a me non succede;
quando arriva lo stop, mando 0 su un pin dove è connesso un relè, e poi mando 0 su un pin dove è connesso un led, ebbene il relè si diseccita prima del led, tra i due c'è un tempo di circa mezzo secondo (al relè o connesso un led, e quindi lo vedo visivamente).
Comunque domani mattina collegherò l'oscilloscopio per capire che succede.

da **c1b8** » 25 lug 2009, 16:16

Ti chiedo scusa ma ho grossi problemi con il PC. Quindi non ho ancora guardato il tuo problema.
Potresti reinserire l'intero codice? con le modifiche che hai apportato?

Per evitare i rimbalzi dei pulsanti puoi operare in 2 maniere:
- Hardware: in parallelo al pulsante inserisci un condensatore di qualche micro-farad.
- Software: quando rilevi il cambiamento sul pin dove è connesso il pulsante attendi un momento (1, 2 millisecondi) quindi ri-verifichi il pin per vedere se la condizione di pulsante premuto è ancora vera.

La tempistica che dici di rilevare tra due istruzioni è in effetti anomala. Appena possibile verifico il codice.

Intanto ciao e scusa ancora per il ritardo.

da **matteosr** » 26 lug 2009, 11:12

Non mi devi chiedere scusa, casomai sono io che ti devo ringraziare per i consigli che mi stai dando e per il tempo che mi stai dedicando.

Per i rimbalzi mi è venuta la stessa idea (quella software), ho modificato il codice ed adesso funziona bene, i tempi sono tutti giusti.

questa è la modifica del file di prova con i pulsanti:

Codice: Seleziona tutto: LIST P=16F84, F=INHX8M port_A EQU 5 port_B EQU 6 cont1 EQU 0Ch cont2 EQU 0Dh cont3 EQU 0Eh memory EQU 0Fh test EQU 10H MOVLW 0FFh TRIS port_A ;Porta A tutti ingressi MOVLW 20h TRIS port_B ;Porta B 0 1 2 3 4 6 7 uscite 5 ingresso MOVLW 00h MOVWF port_B ;Azzera Porta B MOVLW 00h MOVWF memory ;Azzera memory MOVLW 00h MOVWF test ;Azzera test inizio: BTFSC port_A,2 ;Controlla RA2 salta se 0 GOTO attendi ;Torna all'inizio se 0 BTFSS port_B,5 ;Controlla RB5 salta se 1 GOTO attendi2 ;c'è ancora 0 continua ad attendere che torni a 1 GOTO inizio attendi: MOVLW 038h MOVWF cont2 ;metti 255 cont2 yreloop2: MOVLW 0FFh MOVWF cont1 ;metti 255 cont1 yreloop3: DECFSZ cont1,1 ;decrementa cont1 salta se 0 GOTO yrestop1 ;se 0 vai a prestop1 DECFSZ cont2,1 ;decrementa cont2 salta se 0 GOTO yrestop2 ;se 0 vai a prestop2 goto att yrestop1: BTFSS port_A,2 ;Controlla RA2 salta se 1 goto inizio ;routine memoria di stop GOTO yreloop3 ;ritorna a yreloop3 yrestop2: BTFSS port_A,2 ;Controlla RA2 salta se 1 goto inizio ;routine memoria di stop GOTO yreloop2 ;ritorna a yreloop2 att: BTFSC port_A,2 ;Controlla RA2 salta se 0 GOTO att call ritard1 ; ritardo di circa 100 ms GOTO apre attendi2: BTFSS port_B,5 ;Controlla RB5 salta se 1 GOTO attendi2 GOTO chiude

Praticamente il tasto deve essere premuto per almeto 100 ms, e dopo che è stato rilasciato c'è un ritardo di altri 100 ms prima di eseguire la funzione; questo vale anche nello stop.
Così funziona tutto regolarmente, non ci sono più rimbalzi e i tempi sono esatti.

Ho modificato anche il file originale, inserendo qualche piccola accortezza; anche qui, dato che i due segnali apri e chiudi iniziano con un'impulso della durata di 135 ms, ho creato un loop che mi verifichi se il primo segnale persista per più di 125 ms, altrimenti torna all'inizio.
Per evitare errori, ho anche aggiunto dei ritardi di 80 ms dopo l'acquisizione dei segnali.

Questo è il codice aggiornato:

Codice: Seleziona tutto: LIST P=16F84A, F=INHX8M port_A EQU 5 port_B EQU 6 cont1 EQU 0Ch cont2 EQU 0Dh cont3 EQU 0Eh memory EQU 0Fh test EQU 10H MOVLW 0FFh TRIS port_A ;Porta A tutti ingressi MOVLW 20h TRIS port_B ;Porta B 0 1 2 3 4 6 7 uscite 5 ingresso MOVLW 00h MOVWF port_B ;Azzera Porta B MOVLW 00h MOVWF memory ;Azzera memory MOVLW 00h MOVWF test ;Azzera test inizio: BTFSS port_A,2 ;Controlla RA2 salta se 1 GOTO inizio ;Torna all'inizio se 0 ; Verifica se il segnale persiste per più di 125 ms, altrimenti torna all'inizio attendi: MOVLW 046h MOVWF cont2 ;metti 70 cont2 yreloop2: MOVLW 0FFh MOVWF cont1 ;metti 255 cont1 yreloop3: DECFSZ cont1,1 ;decrementa cont1 salta se 0 GOTO yrestop1 ;se 0 vai a yrestop1 DECFSZ cont2,1 ;decrementa cont2 salta se 0 GOTO yrestop2 ;se 0 vai a yrestop2 goto pattendi yrestop1: BTFSS port_A,2 ;Controlla RA2 salta se 1 goto inizio ;routine memoria di stop GOTO yreloop3 ;ritorna a yreloop3 yrestop2: BTFSS port_A,2 ;Controlla RA2 salta se 1 goto inizio ;routine memoria di stop GOTO yreloop2 ;ritorna a yreloop2 pattendi: BTFSC port_A,2 ;Attendi che ritorni a 0, Controlla RA2 salta se 0 GOTO pattendi ;c'è ancora 1 continua ad attendere che torni a 0 ; Se nei prossimi 100 ms arriva un segnale allora è apre, altrimenti è chiude riconosci: MOVLW 53h MOVWF cont2 ;metti 100 cont2 loop1: MOVLW 0C8h MOVWF cont1 ;metti 200 cont1 loop2: DECFSZ cont1,1 ;decrementa cont1 salta se 0 GOTO verifica1 ;se 0 vai a verifica1 DECFSZ cont2,1 ;decrementa cont2 salta se 0 GOTO verifica2 ;se 0 vai a verifica2 CALL ritardo1 ;prima di eseguire chiude ritarda di 80ms GOTO chiude ;vai alla funzione chiude verifica1: BTFSS port_A,2 ;Controlla RA2 salta se 1 GOTO loop2 ;ritorna a loop2 GOTO attendi2 ;attendi che torna a 0, funzione apri verifica2: BTFSS port_A,2 ;Controlla RA2 salta se 1 GOTO loop1 ;ritorna a loop1 GOTO attendi2 ;attendi che torna a 0, funzione apri attendi2: BTFSC port_A,2 ;Controlla RA2 salta se 0 GOTO attendi2 ;c'è ancora 1 continua ad attendere che torni a 0 CALL ritardo1 ;prima di eseguire apre ritarda di 80ms GOTO apre ;Vai alla funzione apre ; Funzione Apre ; Bisogna verificare se sono già stati aperti gli specchietti in presenza di un impulso ; di apertura precedente, se vero non aprirli ; Per circa 2,5 s devono essere alimentati indipendentemente dal segnale di stop apre: MOVLW 00h MOVWF test ;Azzera test BTFSS memory,0 ;Controlla se sono stati già aperti gli specchi, salta se 1 GOTO nospec MOVLW 00h MOVWF memory ;Memorizza l'apertura degli specchi BSF port_B,0 ;Metti 1 RB0 apre tetto BSF port_B,2 ;Metti 1 RB2 alimenta specchietti BSF port_B,3 ;Metti 1 RB3 impulso apertura specchietto BSF port_B,6 ;Metti 1 RB6 accende led verde ; Impulso per far posizionare il tetto in modo spoiler, e per far partire gli specchietti ; per circa 800 ms ci sara 1 su RB0 ed RB4 CALL ritloop ; Bisogna togliere l'impulso di apertura degli specchietti ; e fare una pausa in posizione di spoiler per il tetto BCF port_B,0 ;Metti 0 RB0 ferma tetto BCF port_B,3 ;Metti 0 RB3 toglie impulso apertura specchietto CALL ritloop ; Continua a mantenere alimentati gli specchietti per 800 ms, e nel caso apre il tetto BTFSS test,0 ;controlla se in memoria è già arrivato uno stop, salta se 1 BSF port_B,0 ;Metti 1 RB0 apre tetto CALL ritloop BCF port_B,2 ;Metti 0 RB2 togli alimentazione agli specchietti BTFSC test,0 ;controlla se in memoria è già arrivato uno stop, salta se 0 GOTO basta ; se non è arrivato ancora lo stop continua ad attenderlo per altri 6s circa, dopodichè per sicurezza ; blocca tutto MOVLW 0Eh MOVWF cont3 ;metti 6 cont3 bloop1: MOVLW 0FFh MOVWF cont2 ;metti 255 cont2 bloop2: MOVLW 0FFh MOVWF cont1 ;metti 255 cont1 bloop3: DECFSZ cont1,1 ;decrementa cont1 salta se 0 GOTO stop1 ;se 0 vai a stop1 DECFSZ cont2,1 ;decrementa cont2 salta se 0 GOTO stop2 ;se 0 vai a stop2 DECFSZ cont3,1 ;decrementa cont3 salta se 0 GOTO stop3 ;se 0 vai a stop3 GOTO ole stop1: BTFSC port_A,2 ;Controlla RA2 salta se 0 GOTO zloop ;arrivato stop GOTO bloop3 ;ritorna a bloop3 stop2: BTFSC port_A,2 ;Controlla RA2 salta se 0 GOTO zloop ;arrivato stop GOTO bloop2 ;ritorna a bloop2 stop3: BTFSC port_A,2 ;Controlla RA2 salta se 0 GOTO zloop ;arrivato stop GOTO bloop1 ;ritorna a bloop1 zloop: BTFSC port_A,2 ;Attendi che ritorni a 0, Controlla RA2 salta se 0 GOTO zloop BCF port_B,0 ;Metti 0 RB0 ferma tetto BCF port_B,6 ;Metti 0 RB6 spegne led verde CALL ritardo1 GOTO inizio ole: BCF port_B,0 ;Metti 0 RB0 ferma tetto BCF port_B,6 ;Metti 0 RB6 spegne led verde CALL ritardo GOTO inizio basta: BCF port_B,0 ;Metti 0 RB0 ferma tetto BCF port_B,6 ;Metti 0 RB6 spegne led verde CALL ritardo1 GOTO inizio ; Funzione che apre il tetto senza aprire gli specchietti nospec: BSF port_B,0 ;Metti 1 RB0 apre tetto BSF port_B,6 ;Metti 1 RB6 accende led verde CALL ritloop ;ritardo di 800 ms BCF port_B,0 ;Metti 0 RB0 ferma tetto CALL ritloop ;ritardo di 800 ms BTFSC test,0 ;controlla se in memoria è già arrivato uno stop, salta se 0 GOTO basta BSF port_B,0 ;Metti 1 RB0 apre tetto MOVLW 12h MOVWF cont3 ;metti 15 cont3 loopnn1: MOVLW 0FFh MOVWF cont2 ;metti 255 cont2 loopnn2: MOVLW 0FFh MOVWF cont1 ;metti 255 cont1 loopnn3: DECFSZ cont1,1 ;decrementa cont1 salta se 0 GOTO verstopn1 ;se 0 vai a verstopn1 DECFSZ cont2,1 ;decrementa cont2 salta se 0 GOTO verstopn2 ;se 0 vai a verstopn2 DECFSZ cont3,1 ;decrementa cont3 salta se 0 GOTO verstopn3 ;se 0 vai a verstopn3 GOTO ole ;scaduto il tempo per sicurezza vai alla funzione fine2 verstopn1: BTFSS port_A,2 ;Controlla RA2 salta se 1 GOTO loopnn3 ;ritorna a loopnn3 GOTO zloop ;arrivato stop vai funzione zloop verstopn2: BTFSS port_A,2 ;Controlla RA2 salta se 1 GOTO loopnn2 ;ritorna a loopnn2 GOTO zloop ;arrivato stop vai funzione zloop verstopn3: BTFSS port_A,2 ;Controlla RA2 salta se 1 GOTO loopnn1 ;ritorna a loopnn1 GOTO zloop ;arrivato stop vai funzione zloop ; Funzione Chiude ; Gli specchietti funzionano come la funzione apre ; Il tetto non va nella posizione spoiler, ma si chiude direttamente. chiude: MOVLW 00h MOVWF test ;Azzera test BTFSC memory,0 ;Controlla se sono stati già chiusi gli specchi, salta se 0 GOTO cnospec MOVLW 0FFh MOVWF memory ;Memorizza la chiusura degli specchi BSF port_B,1 ;Metti 1 RB1 chiude tetto BSF port_B,2 ;Metti 1 RB2 alimenta specchietti BSF port_B,4 ;Metti 1 RB4 impulso chiusura specchiette BSF port_B,7 ;Metti 1 RB7 accende led rosso ; Impulso per far partire gli specchietti per circa 800 CALL ritloop ; Bisogna togliere l'impulso di chiusura degli specchietti BCF port_B,4 ;Metti 0 RB4 toglie impulso chiusura specchietto ; Continua a mantenere alimentati gli specchietti per 1600 ms, e nel caso chiude il tetto BTFSC test,0 ;controlla se in memoria è già arrivato uno stop, salta se 0 BCF port_B,1 ;Metti 0 RB1, blocca il tetto CALL ritloop CALL ritloop BCF port_B,2 ;Metti 0 RB2 togli alimentazione agli specchietti BTFSC test,0 ;controlla se in memoria è già arrivato uno stop, salta se 0 GOTO hbasta ; se non è arrivato ancora lo stop continua ad attenderlo per altri 6s circa, dopodichè per sicurezza ; blocca tutto MOVLW 0Eh MOVWF cont3 ;metti 6 cont3 cbloop1: MOVLW 0FFh MOVWF cont2 ;metti 255 cont2 cbloop2: MOVLW 0FFh MOVWF cont1 ;metti 255 cont1 cbloop3: DECFSZ cont1,1 ;decrementa cont1 salta se 0 GOTO hstop1 ;se 0 vai a hstop1 DECFSZ cont2,1 ;decrementa cont2 salta se 0 GOTO hstop2 ;se 0 vai a hstop2 DECFSZ cont3,1 ;decrementa cont3 salta se 0 GOTO hstop3 ;se 0 vai a hstop3 GOTO tole hstop1: BTFSC port_A,2 ;Controlla RA2 salta se 0 GOTO tzloop ;arrivato stop GOTO cbloop3 ;ritorna a cbloop3 hstop2: BTFSC port_A,2 ;Controlla RA2 salta se 0 GOTO tzloop ;arrivato stop GOTO cbloop2 ;ritorna a cbloop2 hstop3: BTFSC port_A,2 ;Controlla RA2 salta se 0 GOTO tzloop ;arrivato stop GOTO cbloop1 ;ritorna a cbloop1 tzloop: BTFSC port_A,2 ;Attendi che ritorni a 0, Controlla RA2 salta se 0 GOTO tzloop BCF port_B,1 ;Metti 0 RB1 ferma tetto BCF port_B,7 ;Metti 0 RB7 spegne led rosso CALL ritardo1 GOTO inizio tole: BCF port_B,1 ;Metti 0 RB1 ferma tetto BCF port_B,7 ;Metti 0 RB7 spegne led rosso CALL ritardo GOTO inizio hbasta: BCF port_B,1 ;Metti 0 RB1 ferma tetto BCF port_B,7 ;Metti 0 RB7 spegne led rosso CALL ritardo1 GOTO inizio ; Funzione che chiude il tetto senza chiudere gli specchietti cnospec: BSF port_B,1 ;Metti 1 RB1 chiude tetto BSF port_B,7 ;Metti 1 RB7 accende led rosso MOVLW 013h MOVWF cont3 ;metti 15 cont3 cloopnn1: MOVLW 0FFh MOVWF cont2 ;metti 255 cont2 cloopnn2: MOVLW 0FFh MOVWF cont1 ;metti 255 cont1 cloopnn3: DECFSZ cont1,1 ;decrementa cont1 salta se 0 GOTO cverstopn1 ;se 0 vai a cverstopn1 DECFSZ cont2,1 ;decrementa cont2 salta se 0 GOTO cverstopn2 ;se 0 vai a cverstopn2 DECFSZ cont3,1 ;decrementa cont3 salta se 0 GOTO cverstopn3 ;se 0 vai a cverstopn3 GOTO tole ;scaduto il tempo per sicurezza vai alla funzione cfine2 cverstopn1: BTFSS port_A,2 ;Controlla RA2 salta se 1 GOTO cloopnn3 ;ritorna a cloopnn3 GOTO tzloop ;arrivato stop vai funzione cfine cverstopn2: BTFSS port_A,2 ;Controlla RA2 salta se 1 GOTO cloopnn2 ;ritorna a cloopnn2 GOTO tzloop ;arrivato stop vai funzione cfine cverstopn3: BTFSS port_A,2 ;Controlla RA2 salta se 1 GOTO cloopnn1 ;ritorna a cloopnn1 GOTO tzloop ;arrivato stop vai funzione cfine ; Routine di ritardo loop più controllo, circa 900 ms ritloop: MOVLW 02h MOVWF cont3 ;metti 6 cont3 preloop1: MOVLW 0FFh MOVWF cont2 ;metti 255 cont2 preloop2: MOVLW 0FFh MOVWF cont1 ;metti 255 cont1 preloop3: DECFSZ cont1,1 ;decrementa cont1 salta se 0 GOTO prestop1 ;se 0 vai a prestop1 DECFSZ cont2,1 ;decrementa cont2 salta se 0 GOTO prestop2 ;se 0 vai a prestop2 DECFSZ cont3,1 ;decrementa cont3 salta se 0 GOTO prestop3 ;se 0 vai a prestop3 RETURN prestop1: BTFSC port_A,2 ;Controlla RA2 salta se 0 CALL testoff ;routine memoria di stop GOTO preloop3 ;ritorna a preloop3 prestop2: BTFSC port_A,2 ;Controlla RA2 salta se 0 CALL testoff ;routine memoria di stop GOTO preloop2 ;ritorna a preloop2 prestop3: BTFSC port_A,2 ;Controlla RA2 salta se 0 CALL testoff ;routine memoria di stop GOTO preloop1 ;ritorna a preloop1 ; Routine per memorizzare lo stop per i loop testoff: BTFSS test,0 ;controlla se in memoria è già arrivato uno stop, salta se 1 BSF test,0 ;altrimenti memorizza RETURN ; Routine di ritardo, circa 10s ritardo: MOVLW 014h MOVWF cont3 ;metti 20 cont3 stopnn1: MOVLW 0FFh MOVWF cont2 ;metti 255 cont2 stopnn2: MOVLW 0FFh MOVWF cont1 ;metti 255 cont1 stopnn3: NOP NOP NOP NOP NOP NOP DECFSZ cont1,1 ;decrementa cont1 salta se 0 GOTO stopnn3 ;se 0 vai a stopnn3 DECFSZ cont2,1 ;decrementa cont2 salta se 0 GOTO stopnn2 ;se 0 vai a stopnn2 DECFSZ cont3,1 ;decrementa cont3 salta se 0 GOTO stopnn1 ;se 0 vai a stopnn1 RETURN ; Routine di ritardo, circa 80ms ritardo1: MOVLW 06ch MOVWF cont2 ;metti 255 cont2 nstopnn2: MOVLW 0FFh MOVWF cont1 ;metti 255 cont1 nstopnn3: DECFSZ cont1,1 ;decrementa cont1 salta se 0 GOTO nstopnn3 ;se 0 vai a nstopnn3 DECFSZ cont2,1 ;decrementa cont2 salta se 0 GOTO nstopnn2 ;se 0 vai a nstopnn2 RETURN END

In teoria, dato che la versione di prova con i pulsanti funziona come dovrebbe, anche questa dovrebbe funzionare; resta solo da collegare alla macchina il circuito, ed al limite regolare i tempi di apertura e chiusura degli specchi e del tetto.

Dato che oggi è domenica, e la macchina mi serve, i miei esperimenti slitteranno a domani (se succedesse qualcosa, non vorrei andarmene in giro a piede).

Ecco una foto del circuito in prova. (non fate caso al groviglio di fili)

Se per voi va bene, una volta che ho testato il tutto, nel progetto vorrei inserire un file di credits dove cito il forum, e i vostri nick per avermi aiutato. Posso?

Vi ringrazio
ciao, matteosr

da **c1b8** » 26 lug 2009, 12:45

matteosr ha scritto:Se per voi va bene, una volta che ho testato il tutto, nel progetto vorrei inserire un file di credits dove cito il forum, e i vostri nick per avermi aiutato. Posso?

Secondo me potresti fare anche di più... scrivere un bel articolo e pubblicarlo qui su ElectroPortal.
Sempre che il progetto non sia per scopi diversi dalla libera divulgazione.

Attendo l'esito delle prove, appena mi sarà possibile verifico il codice per vedere se è ottimizzabile.

da **matteosr** » 27 lug 2009, 17:44

Ciao a tutti

Ho collegato provvisoriamente il circuito all'auto, ebbene, contro ogni mia più rosea previsione, funziona tutto alla perfezione, riconosce tutti è tre i segnali, e le temporizzazioni sono tutte giuste.

Adesso viene la parte rognosa, smontare mezza macchina e collegare tutto definitivamente al cablaggio.

Però che soddisfazione, dopo tante ore di lavoro vedere che tutto va come dovrebbe.

Se volete dare un'occhiata al progetto, lo potete scaricare da qui.

Ovviamente il progetto, come ho scritto nella licenza, è libero, purchè non venga usato per scopi commerciali.

c1b8 ha scritto:Secondo me potresti fare anche di più... scrivere un bel articolo e pubblicarlo qui su ElectroPortal.

Be, io non sono molto bravo a scrivere, però se credi che possa interessare a qualcuno, non appena avrò finito tutto, ed avrò un po di tempo libero, sicuramente lo farò.

Vi ringrazio tutti.
ciao, matteosr

da **c1b8** » 27 lug 2009, 17:50

Complimenti =D>

Sono certo che a qualcuno possa interessare, se non altro come esempio per capire come affrontare un progetto partendo da un'idea e rilevando sperimentalmente tutti i dati necessari al buon esito dello stesso.

Attendo di leggere la storia di questo progetto.

Ciao.

ElectroYou - la comunità dei professionisti del mondo elettrico

Funzione comfort Fiat

[1] Funzione comfort Fiat

[2] Re: Funzione comfort Fiat

[3] Re: Funzione comfort Fiat

[4] Re: Funzione comfort Fiat

[5] Re: Funzione comfort Fiat

[6] Re: Funzione comfort Fiat

[7] Re: Funzione comfort Fiat

[8] Re: Funzione comfort Fiat

[9] Re: Funzione comfort Fiat

[10] Re: Funzione comfort Fiat

Chi c’è in linea

Informazioni

Seguici

Pubblicità

Credits