Macchina Contapezzi Chiave elettronica PROGETTI Macchina pilotata dal

Macchina Contapezzi Chiave elettronica PROGETTI

Macchina pilotata dal bluetooth Struttura dell’auto: Due ruote motrici Due motori Scheda stm 32 nucleo fe 401 re Modulo bluetooth hc 06 Ponte H

Macchina pilotata dal bluetooth I motori prendono alimentazione direttamente dalla scheda tramite il ponte H che consente l’inversione delle ruote Ogni motore è collegato tramite due cavi, positivo e negativo, al ponte H Dal ponte partono le coppie di cavi relativi a ciascun motore. Ogni cavo è collegato ad un pin differente della scheda stm 32 Affinchè una ruota giri in un verso, un pin di collegamento deve essere a livello logico alto e l’altro a livello logico basso. Perché l’auto si muova, i motori devono girare nello stesso verso. Per far ruotare la macchina, un solo pin deve essere a livello logico alto

Ponte H

Ponte H

Struttura HC 06 e software di base La comunicazione tra HC 06 ed stm 32 avviene tramite seriale; il pin TX di HC 06 va sul pin RX della stm 32 e, il pin RX di HC 06, va sul pin TX della stm 32. Tramite programma si può cambiare questa disposizione. Il bluetooth ha bisogno della libreria Soft. Serial. h #include "Soft. Serial. h“ Una volta richiamata la libreria, si crea l’Istanza dell’oggetto Soft. Serial bt(D 2, D 3); Con questa istanza, sono stati cambiaati i pin tx ed rx della st e, risultano rispettivamente D 2 e D 3 I comandi da inviare da un sistema android con bluetooth alla scheda, sono dei caratteri che vanno dichiarati char receive; Prima di iniziare la comunicazione tra la scheda ed il bluetooth, bisogna accertarsi che il bluetooth sia disponibile: if (bt. readable()>0){ Il carattere dichiarato, deve essere poi quello ricevuto dal sistema android receive=bt. getc();

Struttura del programma per bluetooth #include "mbed. h" #include "Soft. Serial. h" Serial pc(USBTX, USBRX); Soft. Serial bt(D 2, D 3); //TX RX char receive; int main() { while(1) { if (bt. readable()>0) { receive=bt. getc();

Comandi per i motori I pin dei motori devono essere dichiarati come OUTPUT e, ad essi viene dato anche un nome Digital. Out aa(D 5); Digital. Out ab(D 6); Digital. Out ba(D 9); Digital. Out bb(D 10); In base al carattere ricevuto, si possono far girare i motori in un determinato verso

Struttura del programma per i comandi if(receive=='1'){ aa=0; ab=1; ba=0; bb=1; } if(receive=='2'){ aa=1; ab=0; ba=1; bb=0; } if(receive=='0'){ aa=0; ab=0; ba=0; bb=0; } if(receive=='3'){ aa=0; ab=0; ba=0; bb=1; } if(receive=='4'){ aa=0; ab=0; ba=1; bb=0; } if(receive=='5'){ aa=0; ab=1; ba=0; bb=0; } if(receive=='6'){ aa=1; ab=0; ba=0; bb=0; } }

Programma finale #include "Soft. Serial. h" if(receive=='0'){ Pwm. Out mypwm(D 6); aa=0; Pwm. Out mypwm 1(D 5); ab=0; Pwm. Out mypwm 2(D 9); ba=0; Pwm. Out mypwm 3(D 10); bb=0; Serial pc(USBTX, USBRX); } Digital. Out myled(LED 1); if(receive=='3'){ Digital. Out aa(D 5); Digital. Out ab(D 6); aa=0; Digital. Out ba(D 9); ab=0; Digital. Out bb(D 10); ba=0; Soft. Serial bt(D 2, D 3); //TX RX bb=1; char receive; } float vel; if(receive=='4'){ int main() { aa=0; while(1) ab=0; { ba=1; if (bt. readable()>0) bb=0; { } receive=bt. getc(); if(receive=='5'){ //invio=bt. putc(); //if(receive=='1')myled=!myled; //toggle aa=0; vel=receive-48; ab=1; vel/=10; ba=0; pc. printf("%c %fnr", receive, vel); bb=0; if(receive=='1'){ } bt. printf("ciao"); aa=0; if(receive=='6'){

Contapezzi Struttura: Modulo bluetooth Due fotocellule RTC DS 3231 Modulo per leggere o scrivere sulla scheda sd

DS 3231 Il modulo DS 3231 è digitale e comunica tramite I 2 C con la scheda stm 32 Permette il conteggio della data e dell’ora perché è munito di un oscillatore. Per questo motivo va sempre alimentato con una batteria anche quando la scheda st non è in funzione altrimenti, sia la data che l’ora devono essere sempre settati con un opportuno programma Per un funzionamento quasi semplice, c’è bisogno di due librerie #include "ds 3231. h" #include "Soft. Serial. h" le istanze opportune sono: int main(void) { Ds 3231 rtc(D 14, D 15); time_t epoch_time; ds 3231_time_t rtc_time; ds 3231_calendar_t rtc_calendar; for(; ; ) { epoch_time = rtc. get_epoch(); //una volta settato da un altro programma, mantiene l'ora printf("n. Time as seconds since January 1, 1970 = %dn", epoch_time); printf("n. Time as a basic string = %s", ctime(&epoch_time));

Modulo bluetooth Il modulo bluetooth va dichiarato e collegato come nel caso precedente. Questa volta, i dati non devono essere ricevuti dalla scheda st tramite bluetooth, ma devono essere inviati. I dati da inviare sono il numero di conteggi, la data e l’ora. Per scrivere il numero di conteggi su un modulo bluetooth: bt. printf("n n=%d ", n); Per scrivere la data e l’ora: bt. printf("n. Time as a basic string = %s", ctime(&epoch_time)); bt. printf("n. Time as a custom formatted string = %s", buffer); Si noti che la data e l’ora sono delle stringhe

Fotocellule Sono state utilizzate due fotocellule: la prima rileva che c’è la presenza del pezzo e la seconda che il pezzo è effettivamente transitato I due pin delle fotocellule sono stati dichiarati INPUT Digital. In lettore 1(D 8); Digital. In lettore(D 10); lo stato delle fotocellule è 0 oppure 1: 0 se c’è l’oggetto, 1 se l’oggetto non è presente. Sono state necessarie due variabili intere: n che conteggia e si aggiorna ogni volta che l’oggetto transita per la seconda fotocellula; k invece si incrementa sempre alla seconda fotocellula ma, permette l’incremento di n solo se essa vale 1 e viene azzerata quando il pezzo successivo passa nella prima fotocellula.

n, k if(lettore==0 ){ k=0; if(lettore 1==0 && lettore==1){ if(k==0){n=n+1; k=k+1; } }

Scheda sd La scheda sd permette la registrazione dei dati in un file La comunicazione tra la scheda sd e la scheda stm 32 è permessa tramite un modulo SPI C’è bisogno della libreria #include "SDFile. System. h“ L’istanza dell’oggetto SDFile. System sd(D 11, D 12, D 13, D 4, "sd"); // MOSI, MISO, SCK, CS Il file dove scrivere i dati: FILE *fd = fopen("/sd/mbed. csv", "w"); Il file ha estensione csv che viene aperto con excel La scrittura dei dati e la chiusura del file fprintf(fd, "%d", n); fprintf(fd, "n. Time as a basic string = %s", ctime(&epoch_time)); fprintf(fd, "n. Time as a custom formatted string = %s", buffer); fclose(fd);

Programma completo #include "ds 3231. h" void get_user_input(char* message, uint 8_t min, uint 8_t max, uint 32_t* member) #include "Soft. Serial. h" { #include "SDFile. System. h" uint 32_t temp; SDFile. System sd(D 11, D 12, D 13, D 4, "sd"); // MOSI, MISO, SCK, CS do #define ESC 0 x 1 B { Digital. In lettore 1(D 8); Digital. In lettore(D 10); printf("n%s", message); scanf("%d", &temp); Soft. Serial bt(D 2, D 3); //TX RX *member = temp; void get_user_input(char* message, uint 8_t min, uint 8_t max, uint 32_t* member); if((*(member)< min) || (*(member) > max)) void get_user_input(char* message, uint 8_t min, uint 8_t max, bool* member); { I 2 C i 2 c_lcd(PB_9, PB_8); // SDA, SCL printf("n. ERROR-RTI"); int n=0; } int m=0; } int k=0; while((*(member) < min) || (*(member) > max)); int main(void) } { void get_user_input(char* message, uint 8_t min, uint 8_t max, bool* member) Ds 3231 rtc(D 14, D 15); { FILE *fd = fopen("/sd/mbed. csv", "w"); uint 32_t temp; time_t epoch_time; do ds 3231_cntl_stat_t rtc_control_status = {0, 0}; { ds 3231_time_t rtc_time; printf("n%s", message); ds 3231_calendar_t rtc_calendar; scanf("%d", &temp); char buffer[32]; *member = temp; for(; ; ) if((*(member)< min) || (*(member) > max)) { printf("%c[2 J", ESC); //clear screen { printf("%c[H", ESC); //move cursor to Home printf("n. ERROR-RTI"); epoch_time = rtc. get_epoch(); //una volta settato da un altro programma, mantiene l'ora } //new epoch time fx } printf("n. Time as seconds since January 1, 1970 = %dn", epoch_time); while((*(member) < min) || (*(member) > max));

Chiave elettronica tramite RFID: Radio Frequency IDentification Dispositivi basati sulla emissione di onde elettromagnetiche nel vuoto per identificare oggetti o persone o animali anche in movimento Esistono diversi tipi di RFID passivi: RFID passivo LF (125 -135 KHz): utilizzabile worldwide con distanza di lettura limitata ed applicata per antifurti, chiavi, etc. RFID passivo HF (13, 56 MHz), normalizzata dagli standard ISO 14443 e ISO 15693; è utilizzata worldwide, con distanza di lettura ridotta fino a 1, 20 mt. ed applicata per libri, pallet, controllo accessi, abbigliamento etc. RFID passivo UHF (868 -915 MHz): incontra limiti locali definiti dalle autorità dei singoli paesi, applicata per pallet, container, etc. VHF (2, 4 o 5, 8 GHz): utilizzata globalmente per transponder attivi, applicata per controllo accessi, veicoli, etc. Gli RFID attivi sono dotati di alimentazione propria fornita da una batteria a lunga durata; quando interrogati dal sistema di lettura, detti tag emettono una propria energia in radio-frequenza in grado di propagarsi su distanze più consistenti; utilizzando l’avanzata tecnologia di trasmissione radio nella banda UHF, gli apparati RFID Attivi trasmettono e ricevono dati a distanze fino a 100 metri (Tag i-B 2) o fino a 500 metri con tag della famiglia i-Q 350.

Principio di funzionamento tag / transponder RFID sono sostanzialmente delle memorie dotate di un apparato radio ricetrasmittente, spesso inserito nel medesimo chip di silicio: eccitato da un apparato esterno (fisso o portatile) con il quale stabilisce un dialogo via radio, il tag restituisce poi il suo codice identificativo e/o le altre eventuali informazioni contenute. I tag RFID possono assumere svariate forme a secondo del tipo di applicazione considerata: ad esempio i tag utilizzati per l’identificazione degli animali sono di piccolissime dimensioni, in quanto devono essere inseriti sotto la pelle (ci sono progetti pilota anche su esseri umani in ambito sanitario), mentre per applicazioni di controllo accessi assumono le sembianze di una carta di credito o del più classico badge.

Le antenne RFID, gestite dal controller, generano un campo magnetico che “risveglia” il tag, avviando così la comunicazione via radio; le antenne, talvolta incorporate nel controller, possono essere a polarizzazione lineare oppure circolare, in base alle condizioni di lettura, all’orientamento dei tag ed all’ambiente in cui opera l’RFID. Il controller RFID, detto anche lettore o reader, è la componente di un sistema RFID dedicata allalettura/identificazione e scrittura dei tag RFID e della comunicazione dei loro codici ai sistemi di alto livello (Middleware o ERP) tramite le antenne, l’altro elemento del sistema che irradia il segnale RF. La potenza del controller, unitamente al tipo di antenna ad esso collegata, ne determina una delle performance più importanti, ossia la distanza di lettura (del tag), che può essere qualificata in 4 tipologie: Proximity: letture da 10 cm fino max 20 -25 cm Vicinity: letture su alcune decine di cm e max i m. Mid Range: distanza di ca. 1 m Long Range: alcuni metri

RFID RC 522

Struttura del programma Il protocollo utilizzato dal modulo RFID è SPI Collegamenti SPI_MISO=PA_6=D 12 RFID MOSI=pin 3 -> Nucle SPI_MOSI=PA_7=D 11 RFID SCK=pin 2 -> Nucleo SPI_SCK =PA_5=D 13 RFID SDA=pin 1 -> Nucleo SPI_CS =PB_6=D 10 RFID RST=pin 7 -> Nucleo =PA_9=D 8 3. 3 V and Gnd to the respective pins

Struttura del programma Libreria #include "MFRC 522. h“ Istanza dell’oggetto: MFRC 522 Rf. Chip (SPI_MOSI, SPI_MISO, SPI_SCK, SPI_CS, MF_RESET); Dichiarazione del codice della card da riconoscere: uint 8_t card 1=0 x 20; uint 8_t card 2=0 x 82; uint 8_t card 3=0 x. BF; uint 8_t card 4=0 x 4 F; Il codice è di 4 byte in esadecimale Inizializzazione scheda: Rf. Chip. PCD_Init();

Lettura card I fase: viene letta la card e i dati sono posti in un array e visualizzati sul monitor del pc for (uint 8_t i = 0; i < Rf. Chip. uid. size; i++) {pc. printf("%d%", i); pc. printf(" %X 02", Rf. Chip. uid. Byte[i]); } Si procede il riconoscimento del codice if((Rf. Chip. uid. Byte[0]==card 1)&&(Rf. Chip. uid. Byte[1]==card 2)&&(Rf Chip. uid. Byte[2]==card 3)&&(Rf. Chip. uid. Byte[3]==card 4)){ Se tutto va a buon fine, si accende un led verde o un servo motore ruota per aprire una porta o si attivano altri dispositivi; se invece la chiave non è riconosciuta, si accende un led rosso o si attiva un buzzer per allarme myservo=90; wait_ms(1000); myservo=-90;

Programma completo //-------------------- if ( ! Rf. Chip. PICC_Read. Card. Serial()) //RFID IRQ=pin 5 -> Not used. Leave open { //RFID MISO=pin 4 -> Nucleo SPI_MISO=PA_6=D 12 wait_ms(500); //RFID MOSI=pin 3 -> Nucleo SPI_MOSI=PA_7=D 11 continue; //RFID SCK=pin 2 -> Nucleo SPI_SCK =PA_5=D 13 } //RFID SDA=pin 1 -> Nucleo SPI_CS =PB_6=D 10 // Print Card UID //RFID RST=pin 7 -> Nucleo pc. printf("Card UID: "); =PA_9=D 8 #include "mbed. h" for (uint 8_t i = 0; i < Rf. Chip. uid. size; i++) #include "MFRC 522. h" {pc. printf("%d%", i); #include "Servo. h" pc. printf(" %X 02", Rf. Chip. uid. Byte[i]); // Nucleo Pin for MFRC 522 reset (pick another D pin if you need D 8) } #define MF_RESET D 8 pc. printf("nr"); #define PWMA PC_8 Serial pc(SERIAL_TX, SERIAL_RX); Digital. Out green(D 7); Digital. Out red(D 6); MFRC 522 Rf. Chip (SPI_MOSI, SPI_MISO, SPI_SCK, SPI_CS, MF_RESET); uint 8_t card 1=0 x 20; uint 8_t card 2=0 x 82; uint 8_t card 3=0 x. BF; uint 8_t card 4=0 x 4 F; Pwm. Out mypwm(PWMA); int main(void) {red=0; volatile float speed_value = 0. 5; Servo myservo(D 2); if((Rf. Chip. uid. Byte[0]==card 1)&&(Rf. Chip. uid. Byte[1]==card 2)&&(Rf. Chip. uid. Byte[2]==card 3) &&(Rf. Chip. uid. Byte[3]==card 4)) {pc. printf("nhello"); mypwm. pulsewidth(90); green=1; myservo=90; wait_ms(3000); myservo=-90; green=0; red=0; }else {mypwm. pulsewidth(-90); green=0; red=1; } // Print Card type pc. printf("starting. . . n"); uint 8_t picc. Type = Rf. Chip. PICC_Get. Type(Rf. Chip. uid. sak); // Init. RC 522 Chip pc. printf("PICC Type: %s nr", Rf. Chip. PICC_Get. Type. Name(picc. Type)); Rf. Chip. PCD_Init(); while (true) { wait_ms(1000); }

Servo motore Nella robotica per gli azionamenti, sono molto utilizzati i servomotori. Di solito questi si presentano come piccoli contenitori di materiale plastico da cui fuoriesce un perno in grado di ruotare in un angolo compreso tra 0 e 180° mantenendo stabilmente la posizione raggiunta. Per ottenere la rotazione del perno è utilizzato un motore a corrente continua e un meccanismo di demoltiplica che consente di aumentare la coppia in fase di rotazione. La rotazione del motore è effettuata tramite un circuito di controllo interno in grado di rilevare l'angolo di rotazione raggiunto dal perno tramite un potenziometro resistivo e bloccare il motore sul punto desiderato.

Servo motore con st Per utilizzare il servo motore con st c’è bisogno della libreria #include "Servo. h“ Viene creata l’istanza con l’indicazione del pin. Servo myservo(D 2); Per la rotazione: myservo=90;