Appendice A : Codice completo del firmware

(1)

Appendice A : Codice completo del firmware

File programmazione.h

// //

// Questo file gestisce la scrittura in EEPROM in caso // di prima istallazione del sistema o di cambio // di un dispositivo comandato

// //

#ifndef PROGRAMMAZIONE_H #define PROGRAMMAZIONE_H

unsigned char progr (unsigned char *radio); #endif

(2)

File programmazione.c

// //

// Questo file gestisce la scrittura in eeprom in caso // di prima istallazione del sistema o di cambio // di un dispositivo comandato // // #include <avr/eeprom.h> #include "invia.h" #include "programmazione.h"

#define EEPROM __attribute__((section(".eeprom"))) //questa variabile indica al gateway in quale stanza è posto

unsigned char stanza EEPROM;

remote LUCE1 EEPROM, LUCE2 EEPROM, TV1 EEPROM, TV2 EEPROM, VCR EEPROM, DVD EEPROM;

remote HIFI EEPROM, RISC EEPROM, FINESTRA1 EEPROM; remote FINESTRA2 EEPROM, PTA1 EEPROM, PTA2 EEPROM; unsigned char progr (unsigned char *radio)

{

unsigned char ncamp, unb; remote *rem;

int i,dueb,j,k; unsigned long quattrob; unb = *radio;

if (unb == 1) unb = *(radio+1); else return 'E';

(3)

switch (unb) {

case '0': rem = &LUCE1; break; case '1': rem = &LUCE2; break; case '2': rem = &TV1; break; case '3': rem = &TV2; break; case '4': rem = &VCR; break; case '5': rem = &DVD; break; case '6': rem = &HIFI; break; case '7': rem = &RISC; break; case '8': rem = &FINESTRA1; break; case '9': rem = &FINESTRA2; break; case 'a': rem = &PTA1; break; case 'b': rem = &PTA2; break; default: return 'E'; break; }

// inizio ad acquisire e scrivere i vari campi i=0; do { ncamp = *(radio+i); switch (ncamp) { case 1: //nome { unb = *(radio+1+i);

eeprom_write_byte (&(rem->nome), unb); i+=2;

} break;

case 2: //bits {

dueb = (*(radio+1+i)<<8) | (*(radio+2+i)); eeprom_write_word (&rem->bits, dueb); i+=3;

(4)

case 3: //flags {

dueb = (*(radio+1+i)<<8) | (*(radio+2+i)); eeprom_write_word (&rem->flags, dueb); i+=3;

} break;

case 4: //pheader {

dueb = (*(radio+1+i)<<8) | (*(radio+2+i)); eeprom_write_word (&rem->pheader, dueb); i+=3;

} break;

case 5: //sheader {

dueb = (*(radio+1+i)<<8) | (*(radio+2+i)); eeprom_write_word (&rem->sheader, dueb); i+=3;

} break;

case 6: //pone {

dueb = (*(radio+1+i)<<8) | (*(radio+2+i)); eeprom_write_word (&rem->pone, dueb); i+=3;

} break;

case 7: //sone {

dueb = (*(radio+1+i)<<8) | (*(radio+2+i)); eeprom_write_word (&rem->sone, dueb); i+=3;

} break;

case 8: //pzero {

dueb = (*(radio+1+i)<<8) | (*(radio+2+i)); eeprom_write_word (&rem->pzero, dueb); i+=3;

} break;

(5)

{

dueb = (*(radio+1+i)<<8) | (*(radio+2+i)); eeprom_write_word (&rem->szero, dueb); i+=3;

} break;

case 10: //plead {

dueb = (*(radio+1+i)<<8) | (*(radio+2+i)); eeprom_write_word (&rem->plead, dueb); i+=3;

} break;

case 11: //ptrail {

dueb = (*(radio+1+i)<<8) | (*(radio+2+i)); eeprom_write_word (&rem->ptrail, dueb); i+=3;

} break;

case 12: //pfoot {

dueb = (*(radio+1+i)<<8) | (*(radio+2+i)); eeprom_write_word (&rem->pfoot, dueb); i+=3;

} break;

case 13: //sfoot {

dueb = (*(radio+1+i)<<8) | (*(radio+2+i)); eeprom_write_word (&rem->sfoot, dueb); i+=3;

} break;

case 14: //pre_data_bits {

dueb = (*(radio+1+i)<<8) | (*(radio+2+i));

eeprom_write_word (&rem->pre_data_bits, dueb); i+=3;

} break;

case 15: //pre_data {

(6)

k=24; for(j=0;j<4;j++) { quattrob |= (*(radio+1+i+j)<< k); k-=8; }

eeprom_write_block (&quattrob, &rem->pre_data, 4);

i+=5;

} break;

case 16: //post_data_bits {

eeprom_write_word (&rem->post_data_bits, dueb); i+=3; } break; case 17: //post_data { k=24; for(j=0;j<4;j++) { quattrob |= (*(radio+1+i+j)<< k); k-=8; }

eeprom_write_block (&quattrob, &rem->post_data, 4);

i+=5;

} break;

case 18: //toggle_bits {

eeprom_write_word (&rem->toggle_bits, dueb); i+=3;

} break;

case 19: //freq {

(7)

eeprom_write_word (&rem->freq, dueb); i+=3; } break; case 20: //nome_cmd1 { unb = *(radio+1+i);

eeprom_write_byte (&rem->nome_cmd1, unb); i+=2; } break; case 21: //cmd1 { k=24; for(j=0;j<4;j++) { quattrob |= (*(radio+1+i+j)<< k); k-=8; }

eeprom_write_block (&quattrob, &rem->cmd1, 4); i+=5;

} break;

case 22: //nome_cmd2 {

unb = *(radio+1+i);

(8)

unb = *(radio+1+i);

} break;

unb = *(radio+1+i);

} break;

(9)

} break;

unb = *(radio+1+i);

} break;

case 'F': break; //la struttura é finita, esci default: return 'E'; break; }

}

while ( (ncamp !='F') && (i < 76) ); return 'O';

(10)

}

File invia.h

// //

// Questo file contiene le funzioni per inviare

// i vari codici indipendentemente dal tipo di protocollo // utilizzato.

// Si suppone di avere in e2prom la struttura REMOTE con // tutti i suoi campi.

// //

#ifndef INVIA_H #define INVIA_H

#define RC5 0x0001 /* IR data follows RC5 protocol */ #define SHIFT_ENC RC5 /* IR data is shift encoded */

#define REVERSE 0x0010

#define SPACE_FIRST 0x2000 /* bits are encoded as space+pulse */ #define SPACE_ENC 0x0008 /* PWM */

// Definisco la struttura REMOTE (che poi andrà sul main) typedef struct { char nome; int bits; int flags; int pheader,sheader; int pone,sone;

int pzero, szero; int plead;

(11)

int ptrail; int pfoot, sfoot;

int pre_data_bits; unsigned long pre_data; int post_data_bits; unsigned long post_data; int toggle_bits;

unsigned int freq;

// inserisco i campi relativi alla codifica dei comandi char nome_cmd1; unsigned long cmd1; char nome_cmd2; unsigned long cmd2; char nome_cmd3; unsigned long cmd3; char nome_cmd4; unsigned long cmd4; char nome_cmd5; unsigned long cmd5; char nome_cmd6; unsigned long cmd6; struct remote *prossimo;

} remote;

// Essendo la struttura piuttosto ampia, devo aumentare le dimensioni // Del buffer di ricezione in uart

// Funzioni:

// Funzione per l'invio di un uno logico void uno (void);

// Funzione per l'invio di un uno logico spedendo prima lo spazio e poi l'impulso void unos (void);

// Funzione per l'invio di un uno logico con codifica bifase void unob (void);

(12)

// Funzione per l'invio di uno zero logico void zero(void);

// Funzione per l'invio di uno zero logico spedendo prima lo spazio e poi l'impulso void zeros (void);

// Funzione per l'invio del messaggio

unsigned char invia (remote *rem, unsigned char comando); #endif

File invia.c

// //

// Questo file contiene le funzioni per inviare

// i vari codici indipendentemente dal tipo di protocollo // utilizzato.

// Si suppone di avere in e2prom la struttura REMOTE con // tutti i suoi campi.

// // #include "global.h" #include <avr/signal.h> #include <avr/eeprom.h> #include <avr/delay.h> #include <inttypes.h> #include "avrlibdefs.h" #include "invia.h" #include "programmazione.h"

(13)

#ifndef TIMER_INTERRUPT_HANDLER

#define TIMER_INTERRUPT_HANDLER SIGNAL #endif

unsigned char finito;

unsigned int UNOP, UNOS, ZEROP, ZEROS, FREQUE;

unsigned int HEADERP, HEADERS, LEADP, TRAILP, FOOTP, FOOTS; float diviso,campo;

remote questo; void uno (void) { TCNT2 = 0; TCCR2 = 25; _delay_loop_2(UNOP); TCCR2 = 0; PORTD = (0<<PD7); _delay_loop_2(UNOS); }

void unos (void) { TCCR2 = 0; PORTD = (0<<PD7); _delay_loop_2(UNOS); TCNT2 = 0; TCCR2 = 25; _delay_loop_2(UNOP); }

void unob (void) {

TCCR2 = 0;

(14)

_delay_loop_2(UNOS); TCNT2 = 0; TCCR2 = 25; _delay_loop_2(UNOP); } void zero () { TCNT2 = 0; outb (TCCR2, 25); _delay_loop_2(ZEROP); TCCR2=0; PORTD =(0<<PD7); _delay_loop_2(ZEROS); } void zeros () { TCCR2 = 0; PORTD = (0<<PD7); _delay_loop_2(ZEROS); TCNT2 = 0; TCCR2 = 25; _delay_loop_2(ZEROP); }

unsigned char invia (remote *rem, unsigned char comando) {

short int send[50], send_inv[50]; int i,k,j=0,o;

unsigned long com, pot ; remote *block=&questo; static char *a;

(15)

// Copio la struttura in ram

questo.nome = eeprom_read_byte ( &rem->nome); questo.bits = eeprom_read_word (&rem->bits); questo.flags = eeprom_read_word (&rem->flags); questo.pheader = eeprom_read_word (&rem->pheader); questo.sheader = eeprom_read_word (&rem->sheader); questo.pone = eeprom_read_word (&rem->pone);

questo.sone = eeprom_read_word (&rem->sone); questo.pzero = eeprom_read_word (&rem->pzero); questo.szero = eeprom_read_word (&rem->szero); questo.plead = eeprom_read_word (&rem->plead); questo.ptrail = eeprom_read_word (&rem->ptrail); questo.pfoot = eeprom_read_word (&rem->pfoot); questo.sfoot = eeprom_read_word (&rem->sfoot);

questo.pre_data_bits = eeprom_read_word (&rem->pre_data_bits); eeprom_read_block (&block->pre_data, &rem->pre_data, 4);

questo.post_data_bits = eeprom_read_word (&rem->post_data_bits); eeprom_read_block (&block->post_data, &rem->post_data, 4);

questo.toggle_bits = eeprom_read_word (&rem->toggle_bits); questo.freq = eeprom_read_word (&rem->freq);

questo.nome_cmd1 = eeprom_read_byte(&rem->nome_cmd1); eeprom_read_block (&block->cmd1, &rem->cmd1, 4); questo.nome_cmd2 = eeprom_read_byte(&rem->nome_cmd2); eeprom_read_block (&block->cmd2, &rem->cmd2, 4); questo.nome_cmd3 = eeprom_read_byte(&rem->nome_cmd3); eeprom_read_block (&block->cmd3, &rem->cmd3, 4); questo.nome_cmd4 = eeprom_read_byte(&rem->nome_cmd4); eeprom_read_block (&block->cmd4, &rem->cmd4, 4); questo.nome_cmd5 = eeprom_read_byte(&rem->nome_cmd5); eeprom_read_block (&block->cmd5, &rem->cmd5, 4); questo.nome_cmd6 = eeprom_read_byte(&rem->nome_cmd6); eeprom_read_block (&block->cmd6, &rem->cmd6, 4); //

// Mi creo la stringa di bit da mandare che metto in SEND //

(16)

// se ho un pre_data lo metto in send if (questo.pre_data_bits !=0) {

pot=1;

for (i=0; i<(questo.pre_data_bits - 1); i++) pot*=2; for (i=0; i<(questo.pre_data_bits); i++)

{

send[i]= ((questo.pre_data) / pot); (questo.pre_data) %= pot;

pot/=2; }

j=questo.pre_data_bits; }

// guardo quale comando e richiesto a=&questo.nome_cmd1;

for (i=0; i<21; i+=5) {

if (comando == *(a+i)) {

com = *(unsigned int*)(a+i+1); o=1;

} }

if (o!=1) return 'E'; // metto il cod in send pot=1;

for (i=0; i<(questo.bits - 1); i++) pot *=2; for (i=0; i<(questo.bits); i++)

{

k=j+i; // mi metto al punto giusto di send send[k]= (com / pot);

com %= pot; pot/=2;

(17)

}

j+=questo.bits;

// guardo se c'e un post data e lo metto in send if (questo.post_data_bits !=0) {

pot=1;

for (i=0; i<((questo.post_data_bits) - 1); i++) pot*=2; for (i=0; i<(questo.post_data_bits); i++)

{

k=j+i; // mi metto al punto giusto di send send[k]= (questo.post_data / pot); questo.post_data %= pot; pot/=2;

}

j+=questo.post_data_bits; }

//se il campo flag contiene reverse inverto la stringa send if (questo.flags & REVERSE)

{

for (i=0; i<j; i++) send_inv[i] = send[j-i]; for (i=0; i<=j; i++) send[i]=send_inv[i]; }

// infine calcolo la durata di pulse e space di uno e zero x questo dispositivo campo = (questo.pone );

diviso = (F_CPU/1000000);

UNOP = ((campo * diviso) /4 ) ; campo = (questo.sone );

UNOS = ( (campo * diviso)/4 ) ; campo = (questo.pzero );

ZEROP = ( (campo * diviso)/4 ) ; campo = (questo.szero);

ZEROS = ( (campo * diviso)/4 ) ; campo = (questo.pheader );

(18)

campo = (questo.sheader );

HEADERS = ( (campo * diviso)/4 ); campo = (questo.plead );

LEADP = ( (campo * diviso)/4 ); campo = (questo.ptrail );

TRAILP = ( (campo * diviso)/4 ) ; campo = (questo.pfoot);

FOOTP = ( (campo * diviso)/4 ); campo = (questo.sfoot );

FOOTS = ( (campo * diviso)/4 ); //

// passo ora all'invio vero e proprio //

sbi (SFIOR, PUD); // disabilito tutti i pull-up sbi (DDRD, DDD7); // setto il pin PD7 come out

if ( (questo.freq ==0) || (questo.freq == 0xFF) ) {

FREQUE = 104; // creo la portante default a 38kHz }

else {

// creo la portante alla freq che serve

FREQUE = ( (F_CPU/questo.freq)/(2) ); }

// disabilito l'interrupt di timer2 cbi (TIMSK,TOIE2); cbi (TIMSK,OCIE2);

/*

Con il TIMER2 genero la portante. Setto il valore di TCCR2 a 25 per funzionare da CTC e con OC2 toggle

*/

// carico il valore relativo alla freq della portante OCR2 = FREQUE;

(19)

// se c'e l'header lo mando

if ( (questo.pheader !=0) && (questo.pheader != 0xFF) ) { TCCR2 = 25; _delay_loop_2(HEADERP); TCCR2 = 0; PORTD = (0<<PD7); _delay_loop_2(HEADERS); }

// se c'e il plead lo mando if (questo.plead !=0) {

TCCR2 = 25;

_delay_loop_2(LEADP); }

// invio la stringa di bit

if (questo.flags & SPACE_FIRST) {

finito = 0;

for (i=0; i<=j; i++) {

if (send[i] == 0) zeros(); else unos();

} }

else if ( (questo.flags & RC5) || (questo.flags & SHIFT_ENC) )

{

for (i=0; i<j; i++) {

if (send[i] == 0) zero(); else unob();

(20)

}

else if ( questo.flags & SPACE_ENC ) {

for (i=0; i<=j; i++) {

if (send[i] == 0) zero(); else uno();

} }

else return 'E'; // se c'e il ptrail lo mando if (questo.ptrail !=0) { TCNT2 = 0; TCCR2 = 25; _delay_loop_2(TRAILP); }

// se c'e il pfoot lo mando if (questo.pfoot !=0) { TCNT2 = 0; TCCR2 = 25; _delay_loop_2(FOOTP); TCCR2 = 0; PORTD = (1<<PD7); _delay_loop_2(FOOTS); }

// ho finito di mandare il codice // fermo i contatori e azzero le porte TCCR2=0;

PORTD=0; return 'O';

(21)

}

File main.c

//Funzione principale del progetto #include "global.h" #include <avr/io.h> #include <avr/interrupt.h> #include <avr/signal.h> #include <string.h> #include <avr/eeprom.h> #include <stdio.h> #include "buffer.h" #include "uart.h" #include "invia.h" #include "programmazione.h"

#define EEPROM __attribute__((section(".eeprom"))) extern cBuffer uartRxBuffer;

extern cBuffer uartTxBuffer; unsigned char RadioString[90]; unsigned char fine;

int count;

//questa variabile indica al gateway in quale stanza e` posto extern unsigned char stanza EEPROM;

unsigned char room;

extern remote LUCE1 EEPROM, LUCE2 EEPROM, TV1 EEPROM, TV2 EEPROM, VCR EEPROM, DVD EEPROM;

(22)

extern remote FINESTRA2 EEPROM, PTA1 EEPROM, PTA2 EEPROM; int i;

// Funzione che prende il dato da uartrxbuffer e lo mette in un array per l'analisi void prendidato(void) { i=0; while (i < count) { RadioString[i]=uartGetByte(); i++; } }

// Funzione che invia la risposta alla UI:

// - in caso di messaggio ricevuto corretam spedisce il char 'O' // - in caso di errore di ricezione spedisce il char 'E'

void rispondi (unsigned char a) { uartAddToTxBuffer(a); uartSendTxBuffer(); } int main(void) {

void iniz_debug (void); int prendi(void);

int numcar;

// indirizzo della stanza messo per dire al prototipo a quale stanza appartiene eeprom_write_byte (&stanza, 0x70);

// ogni dispositivo ha all'indirizzo 0x00 dell'eeprom la variabile // identificativa della stanza in cui si trova

unsigned char oe; // Variabile trasmessa all'UI x indicare errori unsigned char name;

(23)

DDRA = ((1<<PA0) || (1<< PA7)); //debug

// attraverso la variabile stanza, indico al dispositivo in quale stanza e` posto // il dato e' posto in eeprom

room = eeprom_read_byte ( &stanza );

// chiamo questa funzione per inizializzare la stanza x il debug iniz_debug ();

//inizializzo la porta uart0 //creo il buffer della porta uart0 //abilito l'interrupt in tx/rx //setto il baudrate //sei

uartInit(); // aziono la modalita IDLE

MCUCR = ((0<<SM2)|(0<<SM1)|(0<<SM0)); // Abilito lo sleep

aspetta: MCUCR|= (1<<SE); //faccio un ciclo in attesa del dato do { asm volatile ( "SLEEP\n\t" "LDS R24, 0x02E3\n\t" ); } while(fine !='F'); // Disabilito lo sleep mode MCUCR = (0<<SE);

(24)

//il messaggio e completo e lo trasferisco nel buffer RadioString[] prendidato();

//ANALIZZO IL MESSAGGIO

// Per prima cosa analizzo se il messaggio e' per la stanza in cui mi trovo if (RadioString[1] != room) { count=0; fine = 0; goto aspetta; }

// Una volta stabilito il messaggio e' riferito alla mia stanza, // guardo quale tipo di messaggio e' arrivato.

if (RadioString[0]=='P') {

oe = progr (&RadioString[2]); }

else if (RadioString[0]=='I') //siamo in modalità di comando {

// Disabilito l'interrupt da uart cbi (UCSRB,RXCIE);

// Controllo che il campo comando sia valido switch (RadioString[3]) { case 'A': case 'B': case 'C': case 'D': case 'E': case 'G': case 'H': case 'I':

(25)

case 'L': case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R': break;

default: oe= 'E'; break; }

if (oe == 'E') goto risp; //passo alla funzione di ricerca codici

//chiamando la funzione relativa all'oggetto da comandare //e passandogli i due bit di RadioString relativi alla

//stanza e all'oggetto piu il comando

switch (RadioString[2]) {

case '0':

name = eeprom_read_byte ( &LUCE1.nome ); if ( name == '0') oe = invia(&LUCE1, RadioString[3]);

else oe = 'E'; break;

case '1':

name = eeprom_read_byte ( &LUCE2.nome ); if ( name == '1') oe = invia(&LUCE2, RadioString[3]);

case '2':

name = eeprom_read_byte ( &TV1.nome ); if ( name == '2') oe = invia(&TV1, RadioString[3]);

(26)

break;

case '3':

name = eeprom_read_byte ( &TV2.nome ); if ( name == '3') oe = invia(&TV2, RadioString[3]);

case '4':

name = eeprom_read_byte ( &VCR.nome ); if ( name == '4') oe = invia(&VCR, RadioString[3]);

case '5':

name = eeprom_read_byte ( &DVD.nome ); if ( name == '5') oe = invia(&DVD, RadioString[3]);

case '6':

name = eeprom_read_byte ( &HIFI.nome ); if ( name == '6') oe = invia(&HIFI, RadioString[3]);

case '7':

name = eeprom_read_byte ( &RISC.nome ); if ( name == '7') oe = invia(&RISC, RadioString[3]);

case '8':

name = eeprom_read_byte ( &FINESTRA1.nome ); if ( name == '8') oe = invia(&FINESTRA1, RadioString[3]);

(27)

case '9':

name = eeprom_read_byte ( &FINESTRA2.nome ); if ( name == '9') oe = invia(&FINESTRA2, RadioString[3]);

case 'a':

name = eeprom_read_byte ( &PTA1.nome ); if ( name == 'a') oe = invia(&PTA1, RadioString[3]);

case 'b':

name = eeprom_read_byte ( &PTA2.nome ); if ( name == 'b') oe = invia(&PTA2, RadioString[3]); else oe = 'E'; break; default: oe='E'; } } else {

// Messaggio di errore: il dato ricevuto non e corretto oe='E';

}

eeprom_write_byte (0x80, oe); // Mando all'UI il messaggio "tutto ok" o "errore" risp: rispondi(oe);

// Riabilito la ricezione da UART sbi (UCSRB,RXCIE);

(28)

count = 0; fine = 0; i=0; oe = 0; goto aspetta; return 0; }

// Inserisco questa funzione per far imparare al prototipo i codici relativi ad // alcuni dispositivi

void iniz_debug (void) {

static unsigned long dato;

eeprom_write_byte (&TV1.nome, 0x32); eeprom_write_word (&TV1.bits, 6); eeprom_write_word (&TV1.flags, 1); eeprom_write_word (&TV1.pheader, 0); eeprom_write_word (&TV1.sheader, 0); eeprom_write_word (&TV1.pone, 948); eeprom_write_word (&TV1.sone, 829); eeprom_write_word (&TV1.pzero, 948); eeprom_write_word (&TV1.szero, 829); eeprom_write_word (&TV1.plead, 991); eeprom_write_word (&TV1.ptrail, 0); eeprom_write_word (&TV1.pfoot, 0); eeprom_write_word (&TV1.sfoot, 0); eeprom_write_word (&TV1.pre_data_bits, 7); dato = 0x40; eeprom_write_block (&dato,&TV1.pre_data, 4); eeprom_write_word (&TV1.freq, 0); eeprom_write_byte (&TV1.nome_cmd1, 0x44); dato = 0x0c; eeprom_write_block (&dato,&TV1.cmd1, 4); eeprom_write_byte (&TV1.nome_cmd2, 0x45);

(29)

dato = 0x01; eeprom_write_block (&dato,&TV1.cmd2, 4); eeprom_write_byte (&TV1.nome_cmd4, 0x48); dato = 0x10; eeprom_write_block (&dato,&TV1.cmd4, 4); eeprom_write_byte (&TV1.nome_cmd5, 0x49); dato = 0x11; eeprom_write_block (&dato,&TV1.cmd5, 4); eeprom_write_byte (&TV2.nome, 0x33); eeprom_write_word (&TV2.bits, 12); eeprom_write_word (&TV2.flags, 0x0018); eeprom_write_word (&TV2.pheader, 2400); eeprom_write_word (&TV2.sheader, 600); eeprom_write_word (&TV2.pone, 1200); eeprom_write_word (&TV2.sone, 600); eeprom_write_word (&TV2.pzero, 600); eeprom_write_word (&TV2.szero, 600); eeprom_write_word (&TV2.plead, 0); eeprom_write_word (&TV2.ptrail, 0); eeprom_write_word (&TV2.pfoot, 0); eeprom_write_word (&TV2.sfoot, 0); eeprom_write_word (&TV2.pre_data_bits, 0); dato = 0; eeprom_write_block (&dato,&TV2.pre_data, 4); eeprom_write_word (&TV2.freq, 40000); eeprom_write_byte (&TV2.nome_cmd1, 0x44); dato = 0x95; eeprom_write_block (&dato,&TV2.cmd1, 4); eeprom_write_byte (&TV2.nome_cmd2, 0x45); dato = 0x90; eeprom_write_block (&dato,&TV2.cmd2, 4); eeprom_write_byte (&VCR.nome, 0x34); eeprom_write_word (&VCR.bits, 24); eeprom_write_word (&VCR.flags, 0x0008); eeprom_write_word (&VCR.pheader, 4000);

(30)

eeprom_write_word (&VCR.sheader, 1600); eeprom_write_word (&VCR.pone, 400); eeprom_write_word (&VCR.sone, 1200); eeprom_write_word (&VCR.pzero, 400); eeprom_write_word (&VCR.szero, 400); eeprom_write_word (&VCR.plead, 0); eeprom_write_word (&VCR.ptrail, 400); eeprom_write_word (&VCR.pfoot, 0); eeprom_write_word (&VCR.sfoot, 0); eeprom_write_word (&VCR.pre_data_bits, 24); dato = 0x400409; eeprom_write_block (&dato,&VCR.pre_data, 4); eeprom_write_word (&VCR.freq, 36000); eeprom_write_byte (&VCR.nome_cmd1, 0x44); dato = 0xBCB5; eeprom_write_block (&dato,&VCR.cmd1, 4); eeprom_write_byte (&VCR.nome_cmd2, 0x4E); dato = 0x5059; eeprom_write_block (&dato,&VCR.cmd2, 4); eeprom_write_byte (&VCR.nome_cmd3, 0x4F); dato = 0x09; eeprom_write_block (&dato,&VCR.cmd3, 4); eeprom_write_byte (&DVD.nome, 0x35); eeprom_write_word (&DVD.bits, 16); eeprom_write_word (&DVD.flags, 0x0008); eeprom_write_word (&DVD.pheader, 9075); eeprom_write_word (&DVD.sheader, 4412); eeprom_write_word (&DVD.pone, 645); eeprom_write_word (&DVD.sone, 474); eeprom_write_word (&DVD.pzero, 645); eeprom_write_word (&DVD.szero, 1601); eeprom_write_word (&DVD.plead, 0); eeprom_write_word (&DVD.ptrail, 645); eeprom_write_word (&DVD.pfoot, 0); eeprom_write_word (&DVD.sfoot, 0); eeprom_write_word (&DVD.pre_data_bits, 0);

(31)

dato = 0x0; eeprom_write_block (&dato,&DVD.pre_data, 4); eeprom_write_word (&DVD.freq, 0); eeprom_write_byte (&DVD.nome_cmd1, 0x44); dato = 0x9768; eeprom_write_block (&dato,&DVD.cmd1, 4); eeprom_write_byte (&DVD.nome_cmd2, 0x4D); dato = 0x5059; eeprom_write_block (&dato,&DVD.cmd2, 4); eeprom_write_byte (&DVD.nome_cmd3, 0x4E); dato = 0x09; eeprom_write_block (&dato,&DVD.cmd3, 4); eeprom_write_byte (&HIFI.nome, 0x36); eeprom_write_word (&HIFI.bits, 16); eeprom_write_word (&HIFI.flags, 0x0008); eeprom_write_word (&HIFI.pheader, 8497); eeprom_write_word (&HIFI.sheader, 4302); eeprom_write_word (&HIFI.pone, 512); eeprom_write_word (&HIFI.sone, 1620); eeprom_write_word (&HIFI.pzero, 512); eeprom_write_word (&HIFI.szero, 554); eeprom_write_word (&HIFI.plead, 0); eeprom_write_word (&HIFI.ptrail, 513); eeprom_write_word (&HIFI.pfoot, 0); eeprom_write_word (&HIFI.sfoot, 0); eeprom_write_word (&HIFI.pre_data_bits, 16); dato = 0x45BA; eeprom_write_block (&dato,&HIFI.pre_data, 4); eeprom_write_word (&HIFI.freq, 0); eeprom_write_byte (&HIFI.nome_cmd1, 0x44); dato = 0x38C7; eeprom_write_block (&dato,&HIFI.cmd1, 4);

eeprom_write_byte (&HIFI.nome_cmd2, 0x4E); dato = 0xE817;

eeprom_write_block (&dato,&HIFI.cmd2, 4);

(32)

dato = 0x6897;

eeprom_write_block (&dato,&HIFI.cmd3, 4); }

//Funzione di interrupt per la ricezione da uart

UART_INTERRUPT_HANDLER(SIG_UART_RECV) {

u08 z;

//incremento il contatore di caratteri count++;

//acquisisco il byte ricevuto da uart0 z = inb(UDR);

// controllo l'arrivo del fine messaggio if (z == 'F') fine = 'F'; //metto il byte ricevuto nel buffer_uart_rx

bufferAddToEnd(&uartRxBuffer, z); }