Le potenzialità messe a disposizione dal chip MCF52233 di Freescale (ora NXP) offrono al programmatore la possibilità di creare in pochi passi un server web personalizzabile con cui realizzare il controllo remoto di apparecchiature elettroniche. L’MCF52233 lanciato molti anni fa è basato su core 68K/ColdFire a 32bit con interfaccia Ethernet. Esso integra un FEC 10/100Mbps (Fast Ethernet Controller) e un EPHY (Ethernet Physical Layer), garantendo eccezionali prestazioni in applicazioni orientate alle reti.
Il chip MCF52233 e la DEMO Board
L’MCF52233 è basato su core 68K/ColdFire a 32bit offrendo ottime prestazioni in ambito delle reti. Per testare i propri progetti sono previsti i due kit di sviluppo: M52233EVB e M52235EVB. Per “muovere” i primi passi con questo controllore è preferibile far uso della prima delle due che offre un buon rapporto prestazioni/prezzo. In Figura 1 è mostrata un’immagine di tale scheda e l’indicazione di ogni suo componente.
Figura 1. Immagine della scheda di sviluppo M52233EVB
Oltre al controllo ETH, che è la caratteristica principale, il chip include anche tre porte seriali, una interfaccia I2C ed una QSPI per la comunicazione con le altre periferiche. A tal proposito, sull’EVK è montato anche un accelerometro che consente di stimare il movimento nelle tre dimensioni e di cui sarà mostrato l’utilizzo nel corso dell’articolo.
Tabella 1. Caratteristiche del chip MCF52233
Per la programmazione del chip bisogna impiegare l’ambiente di sviluppo CodeWarrior. Inoltre, sulla scheda di sviluppo è presente un debugger BDM, interfacciabile con il PC tramite porta USB. Nel seguito, si descriveranno i passi principali da eseguire per configurare l’ambiente con la scheda in esame. Su di essa è già precaricato un firmware di prova che implementa un server web e mostra alcune delle possibilità di impiego. Successivamente, si passerà ad analizzare alcuni esempi di programmazione, sulla base dei quali si possono sviluppare progetti più complessi.
Preparazione dell’ambiente di sviluppo
Per configurare l’ambiente di sviluppo, installare il software in dotazione CodeWarrior Development Studio. Successivamente, collegare la scheda al PC tramite il cavo USB in dotazione. Il sistema operativo rileverà la nuova periferica, procedendo all’installazione dei driver. Dopo che l’installazione dei driver è terminata, collegare la scheda alla porta seriale del PC. Aprire una sessione di HyperTerminal con una configurazione 115200baud, 8bit e nessuna parità. Accendendo la scheda mediante lo switch ON/OFF, dovrebbe comparire nella schermata di HyperTerminal il testo riportato in Figura 2.
Figura 2. Testo visualizzato nella schermata di Hyperterminal alla prima accensione della EVB
In particolare si nota che è stato impostato un MAC address ed un indirizzo IP per il chip. Di default l’indirizzo IP è 192.168.1.4, mentre il gateway e la subnet mask sono rispettivamente 192.168.1.1 e 255.255.255.0. Ovviamente, per fare in modo che la M52233 comunichi con il PC (attraverso una connessione ethernet) bisogna impostare quest’ultimo con un indirizzo della stessa sottorete. Ad esempio, utilizzare i seguenti parametri per il PC con cui ci si connette:
Indirizzo IP: 192.168.1.X (con X ≠ 4 e compreso tra 1 e 254)
Subnet Mask: 255.255.255.0
Gateway: 192.168.1.1
Per accertarsi che tutto stia funzionando correttamente è possibile utilizzare il commando Ping (del protocollo ICMP) dalla shell di DOS. Quindi selezionare Start->Esegui e digitare cmd. A questo punto si apre la shell di DOS, da cui si può impartire il seguente comando:
ping 192.168.1.4
In questo modo si invia alla scheda (tramite cavo Ethernet) un pacchetto di dati di test per verificare la corretta comunicazione. A questo punto è possibile testare il programma demo che è precaricato sulla board. Poiché si tratta di un server web (si veda il riquadro relativo per maggiori dettagli) è necessario utilizzare un browser come Internet Explorer o Mozilla/Firefox. È necessario digitare il seguente indirizzo per collegarsi alla scheda tramite protocollo HTTP: http//192.168.1.4/demo.htm. La schermata che si presenta è riportata in Figura 3 (N.B. Per il corretto funzionamento della demo è indispensabile avere installato il plug-in Java per il browser utilizzato).
Figura 3. Schermata del browser relativa al server web implementato come applicazione demo nella board
L’applicazione più interessante è quella relativa all’uso dell’accelerometro. La pagina web visualizzata, riporta tre progress bar indicate con x-axis, y-axis e z-axis; al centro di esse è presente una punto viola. Provando a muovere la scheda, spostandola lungo le tre coordinate spaziali si vedono le progress bar avanzare o diminuire ed il punto spostarsi secondo il movimento effettuato. I pulsati indicati con 1g, 2g, 4g, 6g impostano il range e quindi la sensibilità dell’accelerometro. La progress bar indicata con POT rappresenta, invece, il valore analogico acquisito tramite il potenziometro e convertito in digitale dall’ingresso AN0. Ruotando tale potenziometro è possibile osservare le relative variazioni della progress bar.
Le altre applicazioni realizzate in questa pagina sono l’interattività dei due pulsati SW1 e SW2, un RTC (Real Time Clock) ed una finestra in cui sono visualizzati vari messaggi sullo stato del chip. Si tratta di un esempio molto semplice, che comunque permette di comprendere le potenzialità di questa scheda. La realizzazione di un server web su sistema embedded consente il telecontrollo di apparecchiature anche su grandi distanze, l’importante è che tra il punto di controllo e la postazione controllata ci sia una connessione Internet. Si può, per esempio, pensare ad applicazioni di domotica per la gestione a distanza di illuminazione, elettrodomestici ed altro. Oppure a sensori per la raccolta e trasmissione dei dati, che saranno poi archiviati in appositi data base. Di seguito sarà spiegato come realizzare un semplice esempio di codice e poi si vedrà quali sono i passi da seguire per implementare un server web, modificare le pagine e gestire l’input e l’output con la scheda tramite protocollo HTTP. Infine, per dimostrare ulteriormente le svariate possibilità di impiego di questo chip, si implementerà lo storico gioco Space Inveders, giusto per divertirsi un po’!
/*
* File: main.c
* Descrizione: funzionamento seriale e delay
*/
#include <stdio.h>
int main()
{
long i;
printf(“\nHello World\n\r”);
for (i=10;i>0;i—){
printf(“-%i\n\r”,i);
fflush(stdout);
cpu_pause(500000);
}
printf(“...by EOS !\n\r”);
while(1); // Idle
return 0;
}
| Listato 1 |
Esempi pratici
Per non sottrarsi alla consuetudine del programma “Hello World” o del classico lampeggio di un LED, proprio di chi inizia a scrivere codice per una nuova applicazione, si partirà proprio da questo.
Programma “Hello World” e debug del codice
La M52233EVB è dotata di una connettore per utilizzare una delle tre porte seriali di cui il chip è dotato. Normalmente tale interfaccia può essere sfruttata per operazioni di debug della scheda oppure per la visualizzazione della configurazione del micro, come si è mostrato in Figura 2. Sulla board sono presenti, oltre all’integrato per la traslazione dei livelli RS-232, anche dei jumper (indicati con CTS, RTS) che servono per l’abilitazione del controllo del flusso. Per questo primo esempio saranno decritti in dettaglio i passi da seguire per creare un progetto, per effettuare il download ed il debug del firmware. Nel seguito tali informazioni saranno date per scontato. Dopo aver aperto l’IDE CodeWarrior, selezionare File->New, quindi ColdFire Stationery; immettere il nome del progetto e la relativa locazione. Cliccando OK viene aperta una finestra in cui si richiede di selezionare la scheda utilizzata: scegliere CF_M52235EVB e poi C. Cliccando OK, un nuovo progetto viene creato, usando come linguaggio di programmazione il C. Aprendo il file main.c nella cartella Source sarà visualizzato il relativo codice; modificarlo secondo quanto riportato nel Listato 1. Esso visualizza la stringa “Hello World”, poi avvia un conto alla rovescia da 10 a 0 ed infine invia la stringa “…by EOS”. Come si nota il file è molto semplice, presenta solo il comando printf che invia una stringa verso lo stream di uscita, ossia la seriale. Il comando fflush ha lo scopo di svuotare il buffer di trasmissione e quindi inviare effettivamente la stringa. La funzione cpu_pause permette di impostare un ritardo, espresso in microsecondi. Infine, il programma termina con un ciclo infinito, che mette in stallo il sistema. È interessante dare uno sguardo alla finestra del Project manager, in cui è possibile notare, oltre al già citato main, anche gli altri file inclusi nel progetto. La cartella linker contiene tutti i files utilizzati per quello specifico controllore, Runtime, FP, C and UART lib ingloba tutti i files di libreria e Support Files contiene vari file utili al progetto. Per compilare selezionare dal project manager Build All, poi scegliere Project->Make. Successivamente, impostare M52235EVB UART Debug nel project manager. Questo consente di utilizzare la porta seriale come consolle. Andare nel menu Edit->M52235EVB UART Debug Settings (ALT+F7), selezionare Debugger -> Remote Debugging. Modificare le impostazioni di connessione su PEMICRO_USB. Cliccare Apply e poi OK. Collegare la scheda al PC tramite il cavo USB. Accendere la scheda e selezionare Project->Debug (F5). Poiché è stata impostata la porta seriale come debug, sarà necessario aprire una sessione di HyperTerminal con impostazione 115200baud, 8bit e nessun controllo di parità. Per eseguire il debug è possibile sia una avanzamento step-by-step (F10) che in tempo reale (CTRL+F5). La Figura 4 mostra il risultato prodotto dal codice descritto.
Figura 4. Risultato dell’esecuzione del codice al Listato 1
È importante notare che in questo esempio non è stato effettuato il download del codice sulla ROM del chip. Infatti, se si termina il debug e si chiude il CodeWarrior, ci si accorge che sul chip è ancora presente il firmware dimostrativo.
Gestione dei LED e programmazione del chip
In questo esempio, oltre alla gestione dei led presenti sulla scheda, si esaminerà la procedura per la programmazione della ROM del chip. Aprire un nuovo progetto (tramite la procedura guidata, descritta in precedenza) e scrivere nel main il programma riportato nel Listato 2.
/*
* File: main.c
* Descrizione: Utilizzo dei LED della scheda
*/
#include “common.h”
void init_led_GPIO(void);
void init_led_eth(void);
int main(){
printf(“\n\rProgramma di test con i LED \n\r”);
// Visualizza un numero sui 4 LED
init_led_GPIO();
init_led_eth();
board_led_display(4);
return 0;
}
void init_led_GPIO(void){
/* Abilita i segnali come GPIO */
MCF_GPIO_PTCPAR = 0
| MCF_GPIO_PTCPAR_TIN3_GPIO
| MCF_GPIO_PTCPAR_TIN2_GPIO
| MCF_GPIO_PTCPAR_TIN1_GPIO
| MCF_GPIO_PTCPAR_TIN0_GPIO;
/* Imposta le linee come uscita */
MCF_GPIO_DDRTC = 0
| MCF_GPIO_DDRTC_DDRTC3
| MCF_GPIO_DDRTC_DDRTC2
| MCF_GPIO_DDRTC_DDRTC1
| MCF_GPIO_DDRTC_DDRTC0;
MCF_GPIO_PORTTC = 0x03;
}
void init_led_eth(void){
// Ethernet status LEDs - This is only for rev0 Si.
if ((MCF_CIM_CIR & 0x003F)==0){
MCF_GPIO_PLDPAR = (0
| MCF_GPIO_PORTLD_PORTLD1 // LNKLED
| MCF_GPIO_PORTLD_PORTLD2 // SPDLED
| MCF_GPIO_PORTLD_PORTLD3 // DUPLED
| MCF_GPIO_PORTLD_PORTLD4 // COLLED);
MCF_GPIO_DDRLD =( MCF_GPIO_DDRLD_DDRLD0 // ACTLED
| MCF_GPIO_DDRLD_DDRLD5 // RXLED
| MCF_GPIO_DDRLD_DDRLD6 // TXLED);
}
}
| Listato 2 |
Selezionare Build Target M5223EVB Internal ROM, anzichè M52235EVB UART Debug come nell’esempio precedente. Premere F7 per compilare l’intero progetto. Selezionare Tools→Flash Programmer. Cliccare su Load Settings e scegliere il file M52235EVB_25MHz.xml. In questo modo saranno caricate le informazioni utili per programmare la scheda in esame (registri, variabili e memoria programma). Selezionare Erase/Blank Check e poi premere Erase. La scritta Erase Command Succeeded informa che il processo di cancellazione della ROM è stato effettuato con successo. Accertarsi che la scheda sia accesa. Selezionare, poi, Program/Verify, quindi Program. Eventualmente, dal pannello Checksum è possibile impostare una controllo dei dati scritti in memoria. Chiudere l’utility Flash Programmer. Per effettuare il debug del codice appena inviato alla ROM del processore bisogna utilizzare la procedura di seguito riportata:
- Selezionare Edit→M52235EVB Internal ROM Settings (ALT+F7).
- Selezionare CF Debugger Settings e assicurarsi che tutte le checkbox in Initial launch e Successive Runs siano deselezionate. Chiudere la finestra del debugger.
- Selezionare Tools→Hardware Diagnostics→Configuration
- Selezionare Load Settings e scegliere il file: M52235_HWDiagConfig.xml.
Il Listato 2 esegue tre funzioni nel main:
- init_led_GPIO();
- init_led_eth();
- board_led_display(4);
La prima di esse accende i led 1 e 2 della scheda e spegne i led 3 e 4. La seconda funzione, invece, gestisce i led relativi all’Ethernet. Infine, la funzione board_led_display(4), permette di scrivere un numero, da 0 a 15 in notazione binaria utilizzando i led GPIO della scheda.
Server Web
L’obiettivo di questa serie di esempi è quello di usare CodeWarrior per compilare e caricare lo stack TCP/IP su MCF52233 e visualizzare delle pagine web interattive in grado di inviare degli input al chip e visualizzare il suo stato. Sarà mostrato, inoltre, come modificare l’indirizzo IP dell’host. Il grande vantaggio offerto da Freescale (ora NXP) è il fatto che tale protocollo risulta già sviluppato ed è necessario solo adattarlo alle proprie esigenze.
Esempio introduttivo
Il file del progetto è scaricabile all’indirizzo: http://www.freescale.com/files/32bit/software/app_software/FWLABSDIR.zip. Aprire CodeWarrior e caricare il progetto presente nella directory $systemCode$\ColdFire_Lite\build\mwerks\m522 3evb (con $systemCode$ si intende il percorso in cui è stato copiato il progetto del TCP/IP). Seguire il procedimento di programmazione della ROM descritto nel paragrafo precedente. L’indirizzo IP che viene assegnato di default alla scheda è 192.168.1.99. Se si apre il browser e si tenta di accedere al chip tramite protocollo HTTP (ossia, si digita http://192.168.1.99) il risultato ottenuto è quello mostrato in Figura 5.
Figura 5. Pagina web mostrata dal chip quando si carica lo stack TCP/IP
Si tratta di una pagina web inviata dal server (in questo caso dall’MCF52233) al client (il browser). Tale pagina, insieme alle figure visualizzate, è stata caricata sulla ROM del chip. Per fare questo è stato necessario implementare una File Allocation Table (FAT) per la gestione dei files. Per verificare questo è possibile aprire una sessione di HyperTerminal con le solite impostazioni (115200baud, 8bit, no parity). Se si preme invio si nota il prompt INET>. Digitando il comando dir si ottiene il risultato mostrato in Figura 6.
Figura 6. Sessione di HyperTerminal in cui è mostrato il sistema operativo implementato sul chip, per la gestione dei file da visualizzare tramite protocollo HTTP
Sono presenti 3 files:
- readme.htm, il file visualizzato di default.
- CFCORESEMBLEM.gif, il banner mostrato nella pagina web.
- vardump.htm, se si prova a visualizzare questo file (http://192.168.1.99/vardump.htm) vengono mostrate informazioni utili sullo stato della scheda e del chip.
Per ciascun file è mostrato, inoltre, la dimensione (espressa in byte) e il puntatore in memoria. L’esempio presentato è utile solo a livello didattico per comprendere il funzionamento del server web, ma non ha alcuna utilità pratica poiché non presenta interattività tra scheda e utente. Si analizzeranno, quindi, altri esempi per interagire con il chip.
Web server e controllo periferiche
Il sistema per includere pagine web fornito da Freescale è composto di due elementi fondamentali. Uno di essi è già stato mostrato: il firmware precaricato sul chip. Il secondo elemento fondamentale è l’utility di compressione che “gira” su PC. Essa riceve come input la lista dei files da “flashare” sul chip e li comprime in un singolo file C. Esso sarà poi inviato nella ROM del chip. La comodità di questo metodo è che è possibile effettuare il download senza ricompilare ogni volta l’intero progetto (quindi in real-time). Insieme al protocollo TCP/IP, Freescale fornisce anche molti esempi di pagine web che è possibile trovare nella cartella $systemCode$\runtime_loaded_web_page_exam ple. Selezionare l’esempio LAB4_dynamic_html_demo. Il procedimento di download è semplicissimo: fare click sul file make.bat e premere invio quando richiesto. Terminata la procedura batch è possibile controllare il risultato digitando il solito link (http://192.168.1.99). Questa volta la pagina web è dinamica, nel senso che vengono mostrati i valori degli ingressi analogici, tra cui le tre coordinate dell’accelerometro, lo stato del potenziometro ed un RTC (Real Time Clock). Muovendo fisicamente la scheda si vedono variare i valori delle coordinate x, y, z. Analogamente per il potenziometro. La Figura 7 mostra quanto sopra descritto.
Figura 7. Risultato ottenuto caricando la pagina web LAB4_dynamic_html_demo
Per comprendere come funziona il procedimento che sta dietro il server web è consigliabile osservare come è realizzato il file variable_dump.htm (Listato 3) presente nella stessa cartella.
<html><head> <meta http-equiv=”refresh” content=”1”> <title>All Variables</title></head><body> <TABLE> <tbody> <tr><td>Variable</td><td>HEX</td><td>DECIMAL</td></tr> <tr><td>00</td><td>~00H ;</td><td>~00D ;</td> <td>Not Used</td></tr> <tr><td>01</td><td>~01H ;</td><td>~01D ;</td> <td>On Board Switch Status</td></tr> <tr><td>02</td><td>~02H ;</td><td>~02D ;</td> <td>Web Page Hit Counter</td></tr> <tr><td>03</td><td>~03H ;</td><td>~03D ;</td> <td></td></tr> <tr><td>04</td><td>~04H ;</td><td>~04D ;</td> <td>Analog Channel 1 (lite)</td></tr> <tr><td>05</td><td>~05H ;</td><td>~05D ;</td> <td>Analog Channel 2 (NU)</td></tr> <tr><td>06</td><td>~06H ;</td><td>~06D ;</td> <td>Analog Channel 3 (NU)</td></tr> <tr><td>07</td><td>~07H ;</td><td>~07D ;</td> <td>Analog Channel 4 (acc-x)</td></tr> <tr><td>08</td><td>~08H ;</td><td>~08D ;</td> <td>Analog Channel 5 (acc-y)</td></tr> <tr><td>09</td><td>~09H ;</td><td>~09D ;</td> <td>Analog Channel 6 (acc-z)</td></tr> <tr><td>10</td><td>~10H ;</td><td>~10D ;</td> <td>Analog Channel 7 (NU)</td></tr> <tr><td>11</td><td>~11H ;</td><td>~11D ;</td> <td>RTC - Hour</td></tr> <tr><td>12</td><td>~12H ;</td><td>~12D ;</td> <td>RTC - Min </td></tr> <tr><td>13</td><td>~13H ;</td><td>~13D ;</td> <td>RTC - Sec </td></tr> </tbody> </TABLE> </body></html>
| Listato 3 |
Si tratta di una normale pagina web, contenente tra i tags <td> e </td> il simbolo ~ seguito da un numero (es. ~00H oppure ~02D). Questo indica al server web di sostituire tale valore con la variabile che corrisponde a quell’indirizzo fisico. La lettera che segue il numero indica la rappresentazione da utilizzare (‘H’ esadecimale o ‘D’ decimale). La seconda riga del Listato 3 serve per aggiornare la pagina ogni secondo. Per modificare il valore del refresh è sufficiente cambiare il valore del campo content. Questo consente di ottenere informazioni sullo stato del chip. Se si vogliono, invece, inviare comandi è possibile modificare il codice, secondo quanto riportato nel Listato 4.
<html><head> <meta http-equiv=”refresh” content=”5”> <title>All Variables</title></head><body> <TABLE> <tbody> <form action=”/index.htm”> <TABEL BORDER=0 CELLSPACING=0 CELLPADDING=0 width=300> <tr> <img src=”banner.jpg”> </tr> <tr> <td><input type=submit name=led value=LED1_OFF></td> <td><input type=submit name=led value=LED2_OFF></td> <td><input type=submit name=led value=LED3_OFF></td> <td><input type=submit name=led value=LED4_OFF></td> </tr> <tr> <td><input type=submit name=led value=LED1_ON></td> <td><input type=submit name=led value=LED2_ON></td> <td><input type=submit name=led value=LED3_ON></td> <td><input type=submit name=led value=LED4_ON></td> </tr> <tr><td>Variable</td><td>HEX</td><td>DECIMAL</td></tr> <tr><td>03</td><td>~03H ;</td><td>~03D ;</td> <td>Analog Channel 0 (pot)</td></tr> <tr><td>07</td><td>~07H ;</td><td>~07D ;</td> <td>Analog Channel 4 (acc-x)</td></tr> <tr><td>08</td><td>~08H ;</td><td>~08D ;</td> <td>Analog Channel 5 (acc-y)</td></tr> <tr><td>09</td><td>~09H ;</td><td>~09D ;</td> <td>Analog Channel 6 (acc-z)</td></tr> </tbody> </TABLE> </body></html>
| Listato 4 |
Figura 8. Aggiunta alla pagina web del comandi per l’accensione/spegnimento del LED e di un’immagine
Sono stati aggiunti i tag <input> che consentono, tramite dei pulsanti, di inviare il comando di accensione/spegnimento dei led D1-D4. Inoltre, è stata aggiunta un’immagine indicata col nome banner.jpg. Questo comporta la modifica del file filelist.txt, con l’aggiunta di una nuova riga che riporta appunto banner.jpg. Il risultato, dopo avere effettuato il download della pagina, è visibile in Figura 9.
Figura 9. Il file main.c in cui è possibile modificare l’indirizzo IP per il MAC del chip
Modifica dell’indirizzo IP e del MAC
L’indirizzo IP, che di default è impostato a 192.168.1.99, può ovviamente essere modificato per soddisfare le esigenze della rete in cui si trova a lavorare la scheda. Per fare ciò è sufficiente aprire il file main.c del progetto dello stack TCP/IP, evidenziato dalla freccia rossa di Figura 10.
Figura 10. Il gioco Space Invaders implementato su MCF52233
Alla riga 99 è presente l’istruzione: netstatic[0].n_ipaddr = (0xC0A80163), che assegna l’indirizzo in formato esadecimale (C016 = 19210, A816 = 16810, 0116 = 110, 6316 = 9910). Le righe 100 e 101 corrispondono, rispettivamente, al gateway predefinito ed alla subnet mask. Per la loro modifica vale lo stesso discorso dell’IP. La modifica, invece, del MAC viene realizzata tramite le righe 113-120. Trattandosi di un valore a 6byte, è utilizzato un array di 6 elementi, chiamato mac_addr_fec. Il Listato 5 riporta il codice per la modifica dell’IP e del MAC, con l’indicazione delle righe relative al progetto.
Linee di codice per la modifica dell’indirizzo IP: netstatic[0].n_ipaddr = (0xC0A80106); netstatic[0].n_defgw = (0xC0A80101); netstatic[0].snmask = (0xffffff00); Linee di codice per la modifica del MAC: tmp = 0x00badbad; mac_addr_fec[0] = (u_char)(tmp >> 24); mac_addr_fec[1] = (u_char)(tmp >> 16); mac_addr_fec[2] = (u_char)(tmp >> 8); mac_addr_fec[3] = (u_char)(tmp & 0xff); tmp = 0x01020304; mac_addr_fec[4] = (u_char)(tmp >> 24); mac_addr_fec[5] = (u_char)(tmp >> 16);
| Listato 5 |
Giochi con la M52233
La possibilità di unire le potenzialità di un sistema embedded con quelle di programmazione web consente di sviluppare applicazioni davvero interessanti e divertenti. Se, ad esempio, si carica il progetto contenuto nella cartella LAB6_mcf5223x_ajax_demo, si può constatare come sia davvero semplice implementare un gioco (nell’esempio Space Invaders).
Conclusioni
Gli esempi mostrati in questo articolo costituiscono solo una base e sono una dimostrazione di come muovere i primi passi con la M52233EVB. Iniziando a prendere confidenza con questo chip ci si rende conto che le applicazioni sviluppabili sono davvero tante, considerato anche il grande vantaggio di avere lo stack TCP/IP già sviluppato e gratuito.
La scheda e’ ancora molto utilizzata in vari ambiti, non sarebbe male fare un approccio costruttivo con altre schede simili attuali. L’articolo e’ un’ottima guida per la realizzazione di semplici progetti.