Volem enviar informació entre dos microcontroladors fent servir llum infraroja.
Al mercat hi ha molts LED infrarojos i molts fotodíodes o fototransistors però convé triar-los emparellats per assegurar-nos que el receptor té una alta sensibilitat a la freqüencia lluminosa emesa per l'emissor. Com a emissor hem triat el LTE-302 i com a receptor el LTR-301 que podem comprar conjuntament. Els dos elements són molt similars d'aspecte, com es mostra a la fotografia següent. Per poder-los distingir, l'emissor porta una taca de pintura de color groc a la part superior. En el cas del receptor, la taca és vermella.
Tant l'emissor com el receptor porten una lent, que és una part circular que sobressurt a la part frontal. Cal, doncs, encarar les dues lents entre sí. El connexionat a tots dos casos és molt senzill.
El corrent nominal de l'emissor és de 50 mA, molt més del que pot donar una pota del microcontrolador. En la connexió de la figura anterior, l'emissor farà poca llum i, per tant, només permetrà enviar el missatge a distàncies curtes. Per treure el màxim rendiment de l'emissor convindrà fer servir un transistor (com el 2N3904 o similar) tal com es mostra a la figura següent.
Cal tenir present que el circuit receptor inverteix la polaritat. Quan la pota RB4 de l'emissor es posi a 1 farà llum i aquesta arribarà al receptor. La llum al receptor activarà el fototransistor que posarà a 0 l'entrada RB6. En canvi quan l'emissor enviï un 0 la pota del receptor veurà un 1. Això ho haurem de tenir present en el programa del receptor.
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 farem servir amb infrarojos) 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 podem rebre senyals de més d'un aparell, é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.
Quan ho anem a provar, ens trobarem amb un inconvenient ja que la llum infraroja no és visible i, per tant, no podem veure si s'està emetent. Per sort la majoria de les càmeres dels mòbils i tauletes sí poden veure la llum infraroja que ens apareixerà a la pantalla del dispositiu amb algun color visible que depèn de com s'interpreti l'infraroig en l'aparell.
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 ; Envia ; Comencem calculant el byte de control ; Hem de sumar (sense portar-ne) tots els bytes 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 T0 fa referència al valor actual del Timer 0 (TMR0) i la variable E representa la llum rebuda que és l'invers del que arribarà al microcontrolador (RB6). Aquesta inversió (que ja hem comentat abans) l'hem de tenir en consideració quan mirem l'estat de RB6.
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) btfsc PORTB,6 ; S'ha activat el LED? O sigui, s'ha desactivat l'entrada? goto $-1 ; No, doncs esperem clrf TMR0 ; Sí, comencem a comptar el temps Espera ; Esperem a que es desactivi l'entrada btfsc PORTB,6 ; S'ha desactivat el LED? O sigui, s'ha activat 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 btfsc PORTB,6 ; S'ha desactivat el LED? O sigui, 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 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 btfss PORTB,6 ; S'ha activat el LED? O sigui, 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 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
Aquesta obra d'Oriol Boix està llicenciada sota una llicència no importada Reconeixement-NoComercial-SenseObraDerivada 3.0.