Volem enviar informació entre dos microcontroladors fent servir ones de ràdio. El mètode que exposarem també podria servir per a comunicacions per cable.
En el cas de la ràdio, hi ha molts sistemes per fer-ho, uns més robustos (i cars) que altres. Per fer proves i exemples senzills hem triat un dels més econòmics.
Les normatives de telecomunicacions són molt estrictes i només es poden fer servir algunes freqüències i encara amb restriccions de potència i temps d'us. Nosaltres treballarem a 433,92 MHz (±0,5 MHz) i farem servir uns circuits prefabricats com a emissor i receptor. Com a emissor hem triat el WRL-10534 i com a receptor el WRL-10532. Per a la majoria d'aplicacions, aquests elements només necessiten alimentar-se i connectar la pota de comunicació a una entrada (receptor) o sortida (emissor) del microcontrolador. Si la distància és una mica gran, pot ser necessària una antena, que no és més que un cable de 13 cm connectat a la pota corresponent.
Per poder enviar un senyal per radiofreqüència, cal modular-lo sobre la freqüència desitjada (en el nostre cas 433,92 MHz). Hi ha diversos sistemes però el més senzill és ASK (amplitude shift keying) en el que la informació es transmet variant el nivell del senyal:
Un cas particular de l'ASK és la modulació OOK (On/Off Keying) en el que en els zeros no es transmet el senyal; aquest és el que farem servir ja que així podem gestionar-ho directament des de la sortida del microcontrolador.
En sistemes digitals, només enviem zeros i uns. Quan es fan servir cables tenim dues possibilitats: síncrona i asíncrona.
La comunicació síncrona, que és la més fiable, requereix tres fils (quatre si volem que sigui bidireccional): referència d'alimentació (terra), dades i sincronisme. Pel fil de sincronisme s'envien uns polsos en els que se'ns indica quan cal llegir cada bit.
A la comunicació asíncrona (la que es fa servir normalment en ràdiotransmissió) no podem tenir els polsos de sincronisme i, per tant, costa més saber quan s'acaba un bit i en comença un altre. Si enviem diversos zeros (o diversos uns) seguits ens podem trobar que sigui difícil determinar-ne el número exacte. Per evitar aquest problema, normalment es codifiquen les dades de manera que no s'envien estrictament zeros i uns sinó que el senyal transmès codifica aquests zeros i uns d'una forma que permeti reconstruir fàcilment els bits rebuts. Un sistema de codificació relativament senzill però força fiable és el Manchester.
En la codificació Manchester, nosaltres enviem el senyal en forma periòdica. Si, per exemple, enviem 1000 bits per segon, el període del senyal serà d'1 ms. En el centre de cada període sempre hi ha una transició que serà de 1 a 0 si transmetem un zero i de 0 a 1 si transmetem un 1:
Al final de cada període hi pot haver o no transició segons si el següent bit és igual o diferent:
Aquest sistema de codificació ens permet detectar errors i discriminar freqüències de polsos diferents. Atès que en el mateix canal hi pot haver molt aparells transmetent, és important poder discriminar els que envien la informació a una freqüència diferent. Si, per exemple, al començament de les nostres dades enviem diversos uns seguits, podrem veure clarament si el temps entre transicions és el que correspon a la nostra freqüència de treball. Atès que cada bit implica, com a mínim, una transició, no és possible que confonguem diversos zeros seguits com un de sol.
Normalment en les transmissions de dades, especialment si són asíncrones, no s'envia només la informació sinó que s'hi afegeixen alguns elements per tal d'assegurar que es rep el missatge que cal i sense errades. Una transmissió sol tenir dues parts: la capçalera i el missatge.
La capçalera és un conjunt de bits que s'envien seguint un patró determinat que és el mateix per a cada transmissió en particular. Les capçaleres solen tenir molts bits iguals seguits ja que això permet discriminar fàcilment si la els bits per segon que rebem corresponen amb els esperats i així discriminar altres emissors. En el nostre cas enviarem 15 bits a 1 i un a 0.
Pel que fa al missatge, sol tenir tres parts. En una primera part s'envien un o més bytes que codifiquen una adreça. Això és útil per discriminar entre diversos emissors que comparteixen el mateix sistema de transmissió. En el nostre cas enviarem un únic byte.
El cos del missatge conté la informació que volem transmetre, en el nostre cas només un byte.
La darrera part del missatge és un byte de control (checksum) per poder comprovar que no hi ha hagut errors de transmissió. En el nostre cas enviarem un valor que sumat amb els altres dos bytes del missatge doni un resultat de zero (no mirarem les que en portem). Si un cop rebut el misstge la suma de tots els bytes és zero podem suposar (no és del tot segur) que el missatge s'ha rebut correctament.
Per enviar els bytes, no s'envien normalment els vuit bits i prou. Si ho fem així, es fa molt difícil detectar si s'han perdut bits. Normalment al final de cada byte s'envien un o més bits predeterminats (anomenats bits d'aturada o stop) que n'indiquen el final. Una de les maneres més típiques (que és la que farem servir) és enviar un 1 i un 0.
El següent diagrama mostra un esquema de tot plegat on els bits d'aturada estan assenyalats amb el fons de color:
En aquelles aplicacions en les que la correcta recepció del missatge pot ser crítica, sol afegir-se una tècnica més en la que els missatges es repeteixen diverses vegades i se'n fa cas si es rep un mínim de cops. La forma més habitual és la n/2n en la que l'emissor envia 2n missatges iguals seguits (amb una pausa entre ells) i el receptor els considera vàlids si en rep n. Per exemple si n és tres, s'envien vuit missatges i cal que se'n rebin tres.
A continuació, posarem una funció per enviar missatges i una per rebre'ls. Comparativament, la recepció és molt més complicada. A l'emissor només cal enviar els bits amb la seqüència correcta i la cadència adequada mentre que al receptor cal descodificar els polsos que rebem i comprovar que tot és correcte.
Suposarem que l'emissor està connectat a RB4 i el receptor a RB6. Fem servir potes diferents perquè en cas de voler implementar un enllaç bidireccional tindríem emissor i receptor en el mateix microcontrolador.
Si optem per fer la transmissió per cable, només cal unir la pota RB4 de l'emissor amb la pota RB6 del receptor així com unir entre sí els borns VSS dels dos microcontroladors. Si alimentem els dos microcontroladors mitjançant els programadors i aquests estan connectats al mateix ordinador, no serà necessari aquest segon fil i serà suficient amb unir RB4 de l'un amb RB6 de l'altre.
La funció següent envia un byte d'informació fent servir la codificació Manchester. En realitat s'envien tres bytes, el primer serveig d'identificació per discriminar altres emissors, el segon és la informació pròpiament dita i el tercer és per controlar que la transmissió ha estat correcta.
#include <p16F690.inc> __config (_INTRC_OSC_NOCLKOUT&_WDT_OFF&_PWRTE_OFF&_MCLRE_OFF&_CP_OFF&_BOR_OFF&_IESO_OFF&_FCMEN_OFF)
cblock 0x20 Port ; Variable per al contingut del port B ; que permet modificar els bits individualment Comp_bits ; Variable per comptar bits Comp_bytes ; Variable per comptar bytes Control ; Variable per calcular el byte de control Retard ; Comptador per al retard Byte ; Variable de treball per enviar un byte Bytes ; Número de bytes que voldrem enviar ; Un paquet tindrà aquests i el byte de control Vector ; Lloc on es guardaran els bytes a enviar ; Després d'aquesta ja no es poden declarar més variables ; ja que el vector tindrà tantes posicions com hi digui a Bytes ; més una per al byte de control endc
org 0 Inici movlw 0 ; Inicialment totes les sortides desactivades movwf Port ; Ho guardem a Port movwf PORTB ; I ho copiem al port B movlw .2 ; Número de bytes que volem enviar movwf Bytes ; Ho guardem a Bytes ...
; ; Funció per enviar un paquet ; Comencem calculant el byte de control ; Hem de sumar (sense portar-ne) tots els bytes ; Envia clrf Control ; El posem a zero movf Bytes,w ; Llegim el número de bytes que volem enviar movwf Comp_bytes ; Ho guardem al comptador de bytes movlw Vector ; Llegim l'adreça de Vector movwf FSR ; Ho posem al punter d'adreçament indirecte movlw 0 ; L'acumulador contindrà la suma, comencem a 0 addwf INDF,w ; Hi sumem un dels bytes incf FSR,f ; Desplaça el punter decfsz Comp_bytes,f ; Byte següent goto $-3 ; Si no és el darrer, seguim ; Ja tenim la suma, ara ho restem (sense portar-ne) de Control (= 0) subwf Control,w ; W = Control - suma movwf INDF ; Ho guarda al final del Vector ; Comencem a enviar ; Primer cal enviar la capçalera movlw .15 ; Primer 15 bits a 1 movwf Comp_bits ; Ho guarda al comptador de bits call Envia_1 ; Envia un 1 decfsz Comp_bits,f ; Decrementa els bits pendents goto $-2 ; Repeteix fins que s'acabi call Envia_0 ; Finalment un bit a 0 ; Després cal enviar els bytes movf Bytes,w ; Llegim el número de bytes que volem enviar movwf Comp_bytes ; Ho guardem al comptador de bytes incf Comp_bytes,f ; Incrementa el comptador de bytes per afegir el byte de control movlw Vector ; Llegim l'adreça de Vector movwf FSR ; Ho posem al punter d'adreçament indirecte TI movf INDF,w ; Agafa un dels bytes movwf Byte ; Ho guarda a la variable de treball movlw .8 ; Un byte són 8 bits movwf Comp_bits ; Ho guarda al comptador de bits TR rlf Byte,f ; El bit de més a l'esquerra passa a C btfss STATUS,C ; Mira sí és 0 goto T0 ; Sí, envia un 0 call Envia_1 ; No, envia un 1 goto TF T0 call Envia_0 ; Envia un 0 TF decfsz Comp_bits,f ; Següent bit goto TR ; Al final de cada byte s'envia un 1 i un 0 call Envia_1 ; Envia un 1 call Envia_0 ; Envia un 0 incf FSR,f ; Desplaça el punter decfsz Comp_bytes,f ; Byte següent goto TI bcf Port,4 ; Desactiva l'emissor movf Port,w ; Ho canviem a Port movwf PORTB ; I ho copiem al port B return Envia_0 ; Funció per enviar un 0 bsf Port,4 ; Un bit 0 comença amb 1 movf Port,w ; Ho canviem a Port movwf PORTB ; I ho copiem al port B movlw .166 ; Cada dec són 1 us i cada goto són 2 us movwf Retard ; 165 * 3 (a la darrera no hi ha goto) dona 495 decfsz Retard,f ; que amb els 4 dels mov i 1 del dec goto $-1 ; fem 500 us bcf Port,4 ; I canvia a 0 a mig bit movf Port,w ; Ho canviem a Port movwf PORTB ; I ho copiem al port B movlw .166 ; Cada dec són 1 us i cada goto són 2 us movwf Retard ; 165 * 3 (a la darrera no hi ha goto) dona 495 decfsz Retard,f ; que amb els 4 dels mov i 1 del dec goto $-1 ; fem 500 us return ; 0 enviat Envia_1 ; Funció per enviar un 1 bcf Port,4 ; Un bit 1 comença amb 0 movf Port,w ; Ho canviem a Port movwf PORTB ; I ho copiem al port B movlw .166 ; Cada dec són 1 us i cada goto són 2 us movwf Retard ; 165 * 3 (a la darrera no hi ha goto) dona 495 decfsz Retard,f ; que amb els 4 dels mov i 1 del dec goto $-1 ; fem 500 us bsf Port,4 ; I canvia a 1 a mig bit movf Port,w ; Ho canviem a Port movwf PORTB ; I ho copiem al port B movlw .166 ; Cada dec són 1 us i cada goto són 2 us movwf Retard ; 165 * 3 (a la darrera no hi ha goto) dona 495 decfsz Retard,f ; que amb els 4 dels mov i 1 del dec goto $-1 ; fem 500 us return ; 1 enviat end
La funció de recepció té més complexitat que la d'emissió ja que d'entrada no sabem què ens arribarà. La durada d'un pols rebuts pot correspondre a un semiperíode (dos bits iguals seguits), a un període (dos bits diferents) o ser incorrecta (no correspon a la nostra freqüència o a la nostra codificació. Hem definit uns màxims i mínims de durada que pot tenir un pols segons si és curt o llarg:
També hem definit uns bits d'estat per saber en quin moment estem. Un dels bits memoritza si el darrer bit rebut és un 0 o un 1, un altre si estem rebent la capçalera o ja estem rebent dades i un tercer que memoritza si estem rebent la primera meitat o la segona d'un període. A la primera meitat d'un període, el pols sempre ha de ser curt mentre que a la segona meitat pot ser llarg (si no hi ha transició al final del període).
Finalment, hem creat uns codis d'error. Quan la funció retorna, l'acumulador contindrà un valor que serà zero si el missatge s'ha rebut correctament i altres valors si no ha estat així. Cada tipus d'error té un bit que el caracteritza entre els sis bits de més pes del valor i per cada un dels possibles errors de cada tipus hi ha una combinació dels dos bits de menys pes.
La funció de recepció comença esperant un 1 i quan l'ha rebut entra en el bucle de recepció pròpiament dit. Aquest primer tros de programa es podia haver incorporat al bucle però sembla més oportú no fer-ho. Per un costat perquè fins que no arriba la primera transició de 0 a 1 no es pot considerar que comenci la recepció i si estigués integrat estríem generant continuament missatges d'error fins que arribés el primer bit. D'altra banda, tractar a part la durada del primer bit permet discriminar ja d'entrada els emissors que treballin amb períodes diferents i generar un codi d'error específic per aquests casos.
Els bits d'estat i els codis d'error es llisten a les taules següents:
| Estats | Valor de retorn | |||||||
| Nom | Bit | Significat | Decimal | Binari | Significat | |||
| Rebut | Estat,7 | 1 | El darrer valor de l'entrada és un 1 | 0 | 0000 0000 | Recepció correcta | ||
| 0 | El darrer valor de l'entrada és un 0 | 129 | 1000 0001 | Bit d'inici massa llarg | ||||
| Pre | Estat,6 | 1 | Estem rebent la primera meitat d'un període | 130 | 1000 0010 | Bit d'inici massa curt | ||
| 0 | Estem rebent la segona meitat d'un període | 66 | 0100 0010 | Massa 1 a la capçalera | ||||
| Cap | Estat,5 | 1 | Estem rebent capçalera | 65 | 0100 0001 | Pocs 1 a la capçalera | ||
| 0 | La capçalera ja ha acabat | 33 | 0010 0001 | No hi ha 1 als bits d'aturada | ||||
| 34 | 0010 0010 | No hi ha 0 als bits d'aturada | ||||||
| 18 | 0001 0010 | Semiperíode massa curt | ||||||
| 17 | 0001 0001 | Període massa llarg | ||||||
| 19 | 0001 0011 | Semiperíode massa llarg o període massa curt | ||||||
| 9 | 0000 1001 | No hi ha canvi a mig període | ||||||
| 5 | 0000 0101 | La suma de control no dona 0 | ||||||
El següent gràfic mostra el funcionament de la funció de recepció. El símbol ++ vol dir incrementar la variable, el símbol -- decrementarla i el símbol ~ significa invertir el bit. Els textos en color blanc són las accions i les comprovacions, en groc tenim les bifurcacions i les condicions que ens hi porten, en verd uns comentaris que ens indiquen què estem fent a cada moment i en rosa aquelles condicions que donen lloc a un error. L'entrada de la funció i el camí a la part final (on es fa la suma de control) estan en taronja. Hem indicat en blau els noms de les etiquetes de programa que corresponen a cada punt. La variable E representa l'entrada (RB6) i la variable T0 fa referència al valor actual del Timer 0 (TMR0).
La funció és la següent:
#include <p16F690.inc> __config (_INTRC_OSC_NOCLKOUT&_WDT_OFF&_PWRTE_OFF&_MCLRE_OFF&_CP_OFF&_BOR_OFF&_IESO_OFF&_FCMEN_OFF)
cblock 0x20 Estat ; Variable per memoritzar estats Comp_bits ; Variable per comptar bits Comp_bytes ; Variable per comptar bytes Byte ; Variable temporal per construir un byte Bytes ; Número de bytes que rebrem Temps ; Variable per comptar el temps minS ; Valor mínim per a la durada d'un semiperíode maxS ; Valor màxim per a la durada d'un semiperíode minP ; Valor mínim per a la durada d'un període maxP ; Valor màxim per a la durada d'un període Vector ; Lloc on es guardaran els bytes rebuts ; Després d'aquesta ja no es poden declarar més variables ; ja que el vector tindrà tantes posicions com hi digui a Bytes ; més una per al byte de control endc
org 0 Inici ; Comencem amb la inicialització ; Inicialització del Timer 0 bsf STATUS,RP0 ; Tria el banc 1 movlw b'01000000' ; RB6 és entrada, la resta del port B és sortida movwf TRISB movlw b'10000010' ; Configuració de Timer0 ; Com a temporitzador basat en rellotge ; 010 - Factor d'escala de 8 ; TMR0 s'incrementarà cada 8 us ; I resistències de pull-up desactivades (valor per defecte) movwf OPTION_REG ; Ho guarda al registre de configuració del Timer0 ... bcf STATUS,RP0 ; Tria el banc 0 ; Inicialització de variables clrf Estat ; De moment, desactiva tots els bits d'estat movlw .3 ; Número de bytes que rebrem movwf Bytes ; Ho guardem a Bytes ; Semiperíode de 500 us ; Marge d'error: 30 % 500 * 0,3 = 150 movlw .43 ; (500 - 150)/8 movwf minS ; Valor mínim per a la durada d'un semiperíode movlw .82 ; (500 + 150)/8 movwf maxS ; Valor màxim per a la durada d'un semiperíode movlw .87 ; 2 * (500 - 150)/8 movwf minP ; Valor mínim per a la durada d'un període movlw .163 ; 2 * (500 + 150)/8 movwf maxP ; Valor màxim per a la durada d'un període ...
; ; Funció per rebre un paquet ; Rebre ; Comencem inicialitzant variables movlw Vector ; Carreguem l'adreça del lloc on es guardaran els bytes rebuts movwf FSR ; Punter per a l'adreçament indirecte clrf Comp_bits ; Posem a zero la variable que compta els bits rebuts movf Bytes,w ; Número de bytes que rebrem movwf Comp_bytes ; Variable de comptatge bsf Estat,5 ; Cap = 1 ; Ara esperem la primera activació (primer 1) btfss PORTB,6 ; S'ha activat l'entrada? goto $-1 ; No, doncs esperem clrf TMR0 ; Sí, comencem a comptar el temps Espera ; Esperem a que es desactivi l'entrada btfss PORTB,6 ; S'ha desactivat l'entrada? goto PrimerBit ; Sí, doncs el primer bit ja està movf TMR0,w ; No, agafa el valor actual del temps movwf Temps ; i el guarda movf maxS,w ; Mirem que no passem de maxS subwf Temps,w ; W = Temps - W btfss STATUS,C ; C = 1 si Temps >= maxS goto Espera ; És més petit, seguim esperant retlw .129 ; És més gran: Error 129 - Bit d'inici massa llarg PrimerBit ; El primer bit ja està movf TMR0,w ; Agafa el valor actual del temps movwf Temps ; i el guarda clrf TMR0 ; Comencem a comptar el temps movf minS,w ; Mirem que no sigui menor que minS subwf Temps,w ; W = Temps - W btfss STATUS,C ; C = 1 si Temps >= minS retlw .130 ; És més petit: Error 130 - Bit d'inici massa curt incf Comp_bits,f ; Ja tenim un bit bsf Estat,6 ; Pre = 1 bcf Estat,7 ; Rebut = 0 SegTran ; Esperem al següent canvi a l'entrada btfsc Estat,7 ; Quin és el darrer valor de l'entrada? goto Espera0 ; 1, doncs hem de rebre un 0 goto Espera1 ; 0, doncs hem de rebre un 1 Espera0 ; Esperem que es desactivi l'entrada btfss PORTB,6 ; S'ha desactivat l'entrada? goto Canvi ; Sí movf TMR0,w ; No, agafa el valor actual del temps movwf Temps ; i el guarda movf maxP,w ; Mirem que no passem de maxP subwf Temps,w ; W = Temps - W btfss STATUS,C ; C = 1 si Temps >= maxP goto Espera0 ; És més petit, seguim esperant retlw .17 ; És més gran: Error 17 - Període massa llarg Espera1 ; Esperem que s'activi l'entrada btfsc PORTB,6 ; S'ha activat l'entrada? goto Canvi ; Sí movf TMR0,w ; No, agafa el valor actual del temps movwf Temps ; i el guarda movf maxP,w ; Mirem que no passem de maxP subwf Temps,w ; W = Temps - W btfss STATUS,C ; C = 1 si Temps >= maxP goto Espera1 ; És més petit, seguim esperant retlw .17 ; És més gran: Error 17 - Període massa llarg Canvi ; L'entrada ja ha canviat movf TMR0,w ; Agafa el valor actual del temps movwf Temps ; i el guarda clrf TMR0 ; Comencem a comptar el temps movf minS,w ; Mirem que no sigui menor que minS subwf Temps,w ; W = Temps - W btfss STATUS,C ; C = 1 si Temps >= minS retlw .18 ; És més petit: Error 18 - Semiperíode massa curt movlw b'10000000' ; Invertim bit 7 xorwf Estat,f ; o sigui, invertim Rebut movf maxS,w ; Mirem si és més gran que maxS subwf Temps,w ; W = Temps - W btfss STATUS,C ; C = 1 si Temps >= maxS goto Curt ; És més petit, és un pols curt movf minP,w ; També mirem si és més gran que minP subwf Temps,w ; W = Temps - W btfsc STATUS,C ; C = 1 si Temps >= minP goto Llarg ; És més gran, és un pols llarg retlw .19 ; Ni curt ni llarg ; Error 19 - Semiperíode massa llarg o període massa curt Llarg ; És un pols llarg btfsc Estat,6 ; Pre = 1? retlw .9 ; Sí: Error 9 - No hi ha canvi a mig període goto CanviFinal ; No, esperem canvi al final de període Curt ; És un pols curt movlw b'01000000' ; Invertim Pre ara xorwf Estat,f ; per no haver-ho de fer dos cops btfsc Estat,6 ; Pre = 1? goto SegTran ; No, esperem canvi a mig període CanviFinal ; Sí, esperem canvi al final de període btfss Estat,5 ; Cap = 1? goto NoCap ; No, ja no estem rebent capçalera btfss Estat,7 ; Rebut = 1? goto Cap0 ; No, hem rebut un zero a la capçalera incf Comp_bits,f ; Tenim un altre 1 de capçalera movlw .16 ; Hem arribat al final de la capçalera? xorwf Comp_bits,w ; Comp_bits = 16? btfsc STATUS,Z ; Z = 1 si Comp_bits = 16 retlw .66 ; Sí: Error 66 - Massa 1 a la capçalera goto SegTran ; No, esperem el següent Cap0 ; Hem rebut un zero a la capçalera movlw .15 ; Hem arribat al final de la capçalera? xorwf Comp_bits,w ; Comp_bits = 15? btfss STATUS,Z ; Z = 1 si Comp_bits = 15 retlw .65 ; Sí: Error 65 - Pocs 1 a la capçalera bcf Estat,5 ; Cap = 0 - Capçalera ja acabada, ara rebrem el missatge movlw .10 ; Cada byte són 10 bits movwf Comp_bits ; 8 de dades i dos d'aturada clrf Byte ; De moment, no hem rebut cap bit de Byte goto SegTran ; Anem a esperar el primer bit NoCap ; Ja no estem rebent capçalera decfsz Comp_bits,f ; Decrementem, és 0? goto NoEs0 ; No, cal saber si és 1 o més gran btfsc Estat,7 ; Sí, darrer bit d'aturada - Rebut = 1? retlw .34 ; Sí: Error 34 - No hi ha 0 als bits d'aturada movf Byte,w ; Agafa el byte rebut movwf INDF ; I el guarda a Vector incf FSR,f ; Incrementa el punter decfsz Comp_bytes,f ; Decrementem, és 0? goto NoFi ; No, cal rebre un altre byte ; Ja hem acabat, anem a fer la suma de control movlw Vector ; Carreguem l'adreça del lloc on es guardaran els bytes rebuts movwf FSR ; Punter per a l'adreçament indirecte movf Bytes,w ; Número de bytes que hem rebut movwf Comp_bytes ; Variable de comptatge movlw 0 ; Comencem amb zero per anar sumant SumaControl ; i anem a fer el bucle de suma addwf INDF,w ; Suma el valor de Vector incf FSR,f ; Incrementa el punter decfsz Comp_bytes,f ; Decrementa, és 0? goto SumaControl ; No, sumem un altre andlw 0xFF ; Sí, anem a veure si surt zero btfss STATUS,Z ; Si és zero, and donarà zero retlw .5 ; No és zero: Error 5 - La suma de control no dona 0 retlw 0 ; Sí és zero: Error 0 - Recepció correcta NoFi ; Cal rebre un altre byte movlw .10 ; Cada byte són 10 bits movwf Comp_bits ; 8 de dades i dos d'aturada clrf Byte ; De moment, no hem rebut cap bit de Byte goto SegTran ; Anem a esperar el primer bit NoEs0 ; Cal saber si és 1 o més gran decfsz Comp_bits,w ; Decrementem provisionalment, és 0? goto Dades ; No, doncs encara és un bit de dades btfss Estat,7 ; Sí, és un bit d'aturada - Rebut = 1? retlw .33 ; No: Error 33 - No hi ha 1 als bits d'aturada goto SegTran ; Sí, esperem el següent bit d'aturada Dades ; És un bit de dades rlf Estat,w ; Passa Rebut a C rlf Byte,f ; I el col·loca a la dreta de Byte desplaçant els que ja hi són goto SegTran ; Esperem el següent bit end
En el cas de fer la comunicació amb cable, la verificació dels temps pot ser molt més estricta. Podem canviar el tros marcat en groc al programa anterior pel que apareix a continuació:
... ; Semiperíode de 500 us ; Marge d'error: 5 % 500 * 0,05 = 25 movlw .59 ; (500 - 25)/8 movwf minS ; Valor mínim per a la durada d'un semiperíode movlw .66 ; (500 + 25)/8 movwf maxS ; Valor màxim per a la durada d'un semiperíode movlw .119 ; 2 * (500 - 25)/8 movwf minP ; Valor mínim per a la durada d'un període movlw .131 ; 2 * (500 + 25)/8 movwf maxP ; Valor màxim per a la durada d'un període ...
Aquesta obra d'Oriol Boix està llicenciada sota una llicència no importada Reconeixement-NoComercial-SenseObraDerivada 3.0.