|
Si parte
Finalmente si parte!!! Abbiamo i programmi pronti, i dati del PIC e lo schema del circuito in mano.
Direi che, per ora, dovremmo accontentarci di accendere uno dei 5 led presenti sul nostro semaforino. (non credo che riusciate a simulare perfettamente un semaforo al primo colpo).Una volta lanciato l'editor del Piclite, possiamo scrivere il nostro primo programmino ma, per quanto semplice possa essere, non siamo in grado di scrivere nulla. L'unico modo che abbiamo, per poter fare qualcosa, è andare a vedere i sorgenti degli altri e il manuale TRICKY C Non è che troviamo in giro il programma già scritto appositamente per il nostro circuito ma, troveremo numerosi esempi di circuiti "accendi-led".Guardando gli esempi che si possono trovare in rete, dovremo prestare particolare attenzione alla sintassi delle istruzioni scritte (sintassi = modo di scrivere una istruzione).Così facendo, noteremo un certo modo di scrivere le istruzioni, comune a tutti i sorgenti che troveremo. Qualche commento ci aiuterà nel compito di capire le frasi scritte nel codice.La prima cosa che si scrive è il TITOLO, serve a ricordare cosa fa il programma che segue. Con l'occasione, non sarebbe male mettere anche la data di inizio, o di fine programmazione. Guardando i vari esempi trovati in rete scriviamo subito la seguente frase:
/* accende un led, Roma il 11-11-02 */
La frase appena scritta deve sempre cominciare con /* e finire con */ . Da qui si evince che tra questi due segni possiamo scrivere quello che ci pare, comprese le parolacce e le imprecazioni, tanto il compilatore non li calcola.Visto che le cose stanno così, approfitto per dare maggior evidenza alla frase appena scritta, in modo che sia più facile individuarla:
/*******************************\
* accende un led, Roma il 11-11-02 *
\*******************************/
E' più carino così vero? A me piace, anzi… farò di più:
/******************************\
* Accende un led *
* (C) 2002 by Pinco Pallino *
* ROMA IL 11-11-2002 *
\******************************/
Adesso che ho scritto il titolo, passo subito alla riga successiva.Sempre dagli esempi trovati in rete, deduco che c'è una parte di codice, che non fa parte del programma vero e proprio, ma senza di essa non funziona niente, si tratta degli "include":
#include<pic1684.h>
Non ci avevo pensato…. come fa il compilatore, a capire su quale tipo di PIC quel programma dovrà girare?Ecco a che serve questo "include", gli altri include, per ora non ci interessano e passiamo direttamente al programma principale. Sempre guardando i numerosi esempi notiamo che il programma principale è costituito da una struttura come la seguente:
main(void)
{
Istruzioni del programma
}
In pratica il programma vero e proprio sta tra le parentesi graffe e, quel main(void) c'è sempre.A questo punto scrivendo tutto quello che abbiamo visto finora, ci viene una cosa del genere:
/******************************\
* Accende un led *
* (C) 2002 by Pinco Pallino *
* ROMA IL 11-11-2002 *
\******************************/
#include<pic1684.h>
main(void)
{
Programma da scrivere
}
A questo punto sappiamo che se volessimo scrivere qualsiasi programma per PIC 16F84, dovremo sempre scrivere, grosso modo, quanto scritto sopra.L'unico problema che abbiamo è: come facciamo a scrivere le parentesi graffe se sulla tastiera italiana non ci stanno?Per aprire una parentesi graffa dobbiamo premere sulla tastiera il tasto ALT e, mentre lo teniamo premuto, scriviamo il numero 123, quando rilasceremo il tasto ALT, vedremo comparire la parentesi graffa aperta.Per chiudere la parentesi graffa dovremo premere e tenere premuto il tasto ALT e scrivere 125 e poi rilasciare il tasto ALT.
Dobbiamo, ora, decidere quale dei 5 led del circuito accendere e, per fare questo, dovremo guardare lo schema elettrico della demoboard "SEMAFORO" che avremo preventivamente stampato su carta.
Dallo schema notiamo che tutti i led cono collegati elettricamente ai pin RB del PIC (sono le porte B) e, sempre dagli esempi che ci sono in giro, prima di fare operazioni con le porte dei pic, esse vanno settate come ingresso o come uscita.Nel nostro caso, dovremo settare le porte B del PIC come uscite e per fare questo dovremo scrivere (stando agli esempi)
TRISB = 0;
Con questa istruzione diciamo che le porte B del PIC devono essere settate come uscite, se avessimo scritto 1 al posto di 0 quelle porte sarebbero state settate come entrate (ci sarà utile quando metteremo dei pulsanti in un prossimo progetto).
Notate bene una cosa: la frase appena scritta finisce con un punto e virgola.Ricordatevelo sempre: ogni istruzione inserita nel codice deve finire con un punto e virgola, è molto importante.
Adesso dobbiamo decidere quale led accendere. Decidiamo per quello grande rosso (il fascino dei led grandi è irresistibile). Andiamo a vedere di nuovo lo schema elettrico e vediamo a quale pin, quel led, è collegato.
Dallo schema risulta che il led è collegato, tramite una resistenza, alla porta RB1 del PIC corrispondente al pin 7.Per attivare il pin 7, corrispondente alla porta RB1 del PIC, dovremo scrivere l'apposita istruzione assieme al numero della porta da attivare. L'istruzione da scrivere è PORTB, però non sappiamo ancora quale numero utilizzare per attivare il pin specifico. Per sapere qual è il numero, dovremo servirci di una tabella logica delle porte B del pic.
|
NUMERO PORTA
|
RB7
|
RB6
|
RB5
|
RB4
|
RB3
|
RB2
|
RB1
|
RB0
|
|
STATO LOGICO
|
0
|
0
|
0
|
0
|
0
|
0
|
1
|
0
|
In questa tabella ho inserito tutte le porte B del pic e, ad ogni porta ho associato il livello logico. Notate l'ordine inverso, è perché i numeri si leggono partendo da destra verso sinistra e così anche le porte.Alla porta RB1 ho associato il livello logico 1, mentre alle altre ho associato 0, ciò vuol dire che RB1 è attivo e le altre porte no. Ho ottenuto, così un numero formato binario da utilizzare come parametro insieme all'istruzione PORTB.Non ci resta che scrivete l'istruzione con il parametro ottenuto, specificando che il numero che scriveremo è in formato binario. Al numero binario 00000010 và anteposto il parametro 0b che serve ad indicare al compilatore che si tratta di un numero binario.
PORTB = 0b00000010;
Notate di nuovo il punto e virgola.
Questa è l'istruzione tanto agognata che serve ad accendere il led connesso alla porta RB1 (nel nostro caso).
Adesso metto tutto in ordine e viene fuori il seguente listato:
/******************************\
* Accende un led *
* (C) 2002 by Pinco Pallino *
* ROMA IL 11-11-2002 *
\******************************/
#include<pic1684.h>
main(void)
{
TRISB = 0;
PORTB = 0b00000010;
}
Ecco qua, adesso che abbiamo messo l'istruzione che serve per accendere il led, dovremo compilare il programma, programmare il pic e vedere se funziona.
Prima di procedere sarebbe meglio fare qualche precisazione.
Se il programma fosse stato molto più lungo, potremmo perderci in un mare di istruzioni scritte e non saremmo più in grado di gestire la programmazione. Che facciamo allora?
Intanto, come avete visto, le due istruzioni che ho scritto nel listato sono spostate a destra rispetto alle graffe del programma.
Poi sarà il caso di aggiungere dei commenti vicino alle istruzioni scritte, in modo da ricordarci cosa fa quella riga.
Ci sono due modi per poterlo fare, il primo è usare lo stesso metodo usato per il titolo: aprire con /* e chiudere con */
Il secondo metodo è utilizzare questi: //
Riporto qui sotto il listato completo di commenti, per chiarezza, utilizzando entrambi i metodi.
/******************************\
* Accende un led *
* (C) 2002 by Pinco Pallino *
* ROMA IL 11-11-2002 *
\******************************/
#include<pic1684.h>
main(void)
{
TRISB = 0; /* setta le porte B come uscite */
PORTB = 0b00000010; // attiva RB1 (pin 7 del 16F84)
}
A questo punto potremmo passare alla fase di compilazione e poi programmare il pic e fare qualche salto di gioia nel vedere il nostro led accendersi ma, devo ancora fare qualche precisazione per farvi lavorare più comodi.
Avete appena scritto il programmino direttamente nell'editor del PICLITE.
Si poteva fare la stessa cosa utilizzando un qualsiasi editor di testo come ad esempio il Notepad di Windows e poi salvarlo sul nostro hardisk. Potete prendere in seria considerazione la cosa, soprattutto quando farete programmi lunghi, l'importante è che poi salviate il sorgente con nomefile.c (notate il .c) , non superare gli 8 caratteri sul nome e salvarlo come solo testo.
Per maggiore comodità, ci possiamo creare una cartella, chiamata codici, sul nostro hardisk in modo che abbia il seguente percorso:
C:\codici
Andiamo avanti con la nostra lezione. Qui sotto potete vedere la situazione a cui dovremmo essere arrivati.
Una volta scritto il nostro programmino, dovremo salvare il lavoro dandogli un nome. Per fare questo, dovremo selezionare SAVE AS dal menu FILE, individuare la cartella C:\CODICI\ e dargli il nome acc_led.c (notate il suffisso .c).Salvato il lavoro, possiamo passare alla fase di compilazione vera e propria.La compilazione del sorgente è quel processo che serve a tradurre quello che abbiamo scritto noi nel linguaggio "C", in un codice che il PIC è in grado di capire ed eseguire. Non possiamo scrivere direttamente il sorgente nel pic perché esso non lo capirebbe.Dopo aver salvato il codice dobbiamo premere il tasto F3, vi apparirà la seguente finestra:
Qui dovrete scegliere per quale modello di PIC volete compilare. Nel nostro caso dovrete cercare il 16F84 (anche in versione A), selezionarlo e fare OK-- ENTER.Vi apparirà una seconda finestra come questa qui sotto:
Qui dovrete spuntare la modalità 24 bit perché nel nostro programma non abbiamo utilizzato numeri a 32 bit.Facciamo di nuovo OK--ENTER e ci apparirà una terza finestra come quella illustrata qui sotto:
Qui io scelgo sempre Full optimization e lascio a livello 1.
Di nuovo OK-ENTER e ci appare la quarta finestra:
Qui dovrete scegliere il formato intel HEX.
Qui a me, succede che il tasto OK--ENTER non è attivo (può darsi che a voi non succeda) e allora premo Cancel--Esc
E vado avanti con la quinta schermata dove lascio così come è
A questo punto parte la compilazione del programma e, se non abbiamo fatto errori nel codice, ci ritroveremo il file Hex nella cartella che abbiamo creato prima
Programmiamo il PIC
Per programmare il PIC, dovremo armarci del programmatore, collegarlo al PC, accenderlo e lanciare EpicWin.Avete diversi modi operativi per programmare il PIC. Se avete realizzato il FISER'S PROGRAMMER con il cavo ICP e la demoboard con il connettore ICP a cui collegarlo siete a posto altrimenti dovete operare in base a quello che avete in mano. Potete anche togliere il pic dalla demoboard e montarlo sul programmatore per poi rimetterlo dov'era dopo la programmazione.
Io suppongo che mi abbiate dato retta, e vado avanti con il mio metodo.
Lanciato il programma MeProg (con il programmatore acceso, collegato alla porta parallela del PC e con il cavo ICP collegato alla demoboard SEMAFORO), dovremo selezionare il Pic da programmare e caricare il codice acc_led.hex
A questo punto potrebbe partire la programmazione del PIC ma, dobbiamo ancora fare una precisazione importante.
Dovremo stare attenti a come il PIC dovrà lavorare nel circuito che lo ospiterà.
Dobbiamo sapere, cioè, se il pic è quarzato o utilizza una rete RC per le temporizzazioni. Inoltre, dobbiamo settare alcuni parametri che riguardano lo specifico Pic.
|
|
Dal menu View di MeProg, dovremo richiamare la voce Configuration, e ci apparirà una finestra uguale a questa.
Da qui dovremo configurare il PIC secondo dei parametri che ne determinano il funzionamento
.Nella zona Oscillator dovremo settare XT perché il PIC, nella demoboard semaforo, è collegato ad un quarzo.
Gli altri parametri LP, HS, RC li approfondiremo successivamente.
Nella zona Code Protect lasciamo Off.
Per ora non ci interessa proteggere dalla copia il nostro programma.
In pratica dovrete settare i parametri come nella figura a fianco.
|
Eccoci giunti alla fase finale, basterà selezionare Program da menu Program di Meprog e in pochi secondi vedremo il pic programmato e la demoboard con il led rosso grande ACCESO.
Abbiamo fatto il nostro primo programma in "C" funzionante e acceso il nostro primo led.
Possiamo anche andare a brindare perché la parte più difficile è fatta.
Si tratta ora di prendere un po' di confidenza e fare qualche piccolo approfondimento.
Adesso che siamo riusciti ad accendere il led rosso grande, potremo fare varie prove per capire meglio il linguaggio "C".
Potremmo provare ad accendere un altro led, accendere 2 o più led contemporaneamente ecc.
In pratica proporrei di fare qualche passo indietro e fare qualche approfondimento, torniamo al codice sorgente che abbiamo scritto prima della compilazione:
/******************************\
* Accende un led *
* (C) 2002 by Pinco Pallino *
* ROMA IL 11-11-2002 *
\******************************/
#include<pic1684.h>
main(void)
{
TRISB = 0; /* setta le porte B come uscite */
PORTB = 0b00000010; // attiva RB1 (pin 7 del 16F84)
}
Vedrete che ora le cose sono un po' più facili, facciamo il passo successivo, supponiamo di voler accendere il led giallo, invece di quello rosso grande.In questo caso, cambierebbe solo il numero binario che abbiamo passato a PORTB:
PORTB = 0b00000100; // attiva RB2 (pin 8 del 16F84)
Tutto il resto del programma rimane identico. Notate che ho cambiato anche il commento per non creare confusione.Non sarebbe male se ripeteste la compilazione e la programmazione del pic per constatare che si accende il led giallo.Per farlo dovrete lanciare di nuovo l'editor del piclite (htlpic), dove troverete il vecchio sorgente caricato automaticamente, cambiare il numero binario, il commento, salvare con SAVE e ricompilare premendo il tasto F3 e rieseguire la procedura di compilazione.
Potete rilanciare MeProg, caricare il nuovo codice compilato e programmare il pic. (ricordatevi di settare di nuovo la configurazione del pic).Funziona vero? E se volessimo accendere due led contemporaneamente?Semplice basta cambiare il numero in un altro che rappresenti la posizione dei pin (ricordate la tabella?). Mettete 1 dove volete che il relativo led si accenda e 0 dove volete che il relativo led sia spento.Per esempio:
PORTB = 0b00110100; // attiva RB2-4-5 (pin 8-10-11 del 16F84)
Questo numero accende tre led: il giallo grande, il verde piccolo ed il rosso piccolo. Mentre il rosso ed il verde grandi rimarranno spenti. (compilatelo e provate).Potremmo dire che i numeri binari ci sono utili in quanto, hanno una corrispondenza grafica con la numerazione dei pin ma, non siamo tenuti a scriverli sotto quella forma, con tutti gli zeri che stanno prima del primo 1. (non sono significativi)In pratica potremo anche scrivere:
PORTB = 0b110100; // attiva RB2-4-5 (pin 8-10-11 del 16F84)
Che è la stessa cosa. Però, ci conviene sempre scrivere tutte e 8 le cifre, per non perdere la rispondenza grafica e per facilitare l'incolonnamento. Possiamo anche usare i numeri decimali ed esadecimali, al posto dei numeri binari, vediamo come. ( provate di nuovo a compilare e programmare il pic per controllare)Se lanciamo la calcolatrice di windows: dovremo spuntare il formato binario, scrivere il numero binario e poi spuntare il formato decimale o esadecimale. Qualche esempio è riportato qui sotto:
|
BINARIO
|
DECIMALE
|
ESADECIMALE
|
|
00000010
|
2
|
2
|
|
00000100
|
4
|
4
|
|
00110100
|
52
|
34
|
|
00111110
|
62
|
3E
|
Il lampeggio del led
Ora che abbiamo imparato ad accendere un led, possiamo pensare di poter fare un programma in grado di farlo lampeggiare.
Per fare questo dovremo ragionare un po' e dare un'occhiata ai soliti sorgenti degli altri in rete.In sostanza si tratterebbe di fare una sequenza di accensioni e spegnimenti, intercalati da delle pause più o meno lunge.Il problema è che se volessimo far lampeggiare all'infinito un led, dovremmo scrivere una sequenza infinita di istruzioni, e la cosa non mi alletta affatto.
Si dovrebbe scrivere un solo ciclo completo di accensione e spegnimento, con una pausa intercalata, e fare in modo che il pic lo ripeta all'infinito.
Questa mi sembra una buona regola da seguire, si tratta di cercare nel manuale trick C e negli esempi disponibili in rete, l'istruzione da mettere nel codice, che permetta di ottenere la ripetizione infinita del programma o almeno di una parte di esso.
Sul manuale TRICK C trovo l'istruzione while e, su internet trovo degli ottimi esempi di come si usa:
while(1)
{
Parte di programma da ripetere
}
In pratica while(condizione) ripete quello che sta tra le parentesi graffe fino a che si verifica la condizione che sta tra le parentesi tonde.
Scrivere while(1) vuol dire che il codice contenuto nelle graffe, verrà ripetuto all'infinito.
Adesso rimane il problema delle pause da mettere nel ciclo di accensione e spegnimento, in modo che il pic non esegua troppo velocemente il programma, non facendoci vedere il lampeggiamento.
Per questo useremo un programma esterno chiamato Delay.c che inseriremo come #include nel programma.
Per poterlo usare, occorre andare nella cartella include del picclite e verificare che esso sia presente, insieme a delay.h.
Non è detto che ci siano e, se non ci sono, prelevateli qui: Delay.zip , li scompattate e li mettete nella cartella include.
Stendiamo ora il programma che fa lampeggiare il led commentandolo, riga per riga, in modo che non facciate confusione con le graffe e le punteggiature:
/******************************\
* Lampeggia un led *
* (C) 2002 by Pinco Pallino *
* ROMA IL 11-11-2002 *
\******************************/
#include<pic1684.h> //Richiama la compilazione delle specifiche del 16F84
#include<delay.c> //Richiama la compilazione della routine di ritarto
main(void) //Inizio programma principale
{ //graffa aperta del programma principale
TRISB = 0; // setta le porte B come uscite
while(1) //Istruzione del ciclo senza fine (qui non c'è il punto e virgola)
{ //Graffa aperta del ciclo da ripetere
PORTB = 0b00000010; // attiva RB1 (pin 7 del 16F84)
DelayMs(250); //Ritardo di 250 ms (parametro per include delay.c)
PORTB = 0b00000000; //disattiva RB1
DelayMs(250); //Ritardo con led spento
} //Graffa chiusa del ciclo da ripetere
} //Graffa chiusa del programma principale
Adesso, che avete scritto il programma, salvatelo nella cartella codici, compilatelo e programmate il pic. Vedrete il led rosso grande lampeggiare.
Contenti? Avete appena imparato l'uso di while() e di DelayMS().
Se volete che lampeggi un altro o più led contemporaneamente, potete cambiare il numero passato al primo PORTB, provate anche a cambiare il numero passato ai Delay e vedrete che cambieranno i tempi delle pause.Però, vi accorgerete di non poter andare oltre il 255 come parametro del Delay, altrimenti la compilazione darà errore.Vedremo dopo come affrontare il problema.
Supponiamo, ora, che io abbia programmato una sequenza lunga di lampeggiamenti, di uno o più led, scrivendo PORTB con il numero di porta e il Delay () per ogni fase di accensione e spegnimento. E supponiamo che, ad un certo punto, io debba modificare il tempo di pausa o di accensione di tutti i led.
Non vorrete mica correggere tutte le righe di programma che contengono il Delay?!?
Una maniera elegante, per evitare tutto quel lavoro, è mettere una costante al posto del valore passato a Delay e passare al compilatore il valore della costante. Per fare questo, dovremo aggiungere una direttiva che assegni il valore della costante, (direttiva = comando del preprocessore ) e sostituire il numero di Delay con la costante.
#define Aspetta 250
Questa riga equivale a dire: assegno alla costante Aspetta il valore 250. Notate che la costante l'ho chiamata "Aspetta" e non x o y, così mi ricordo a cosa si riferisce.Visto che ho nominato la direttiva e la preprocessione, sarà il caso di fare qualche approfondimento.
Le direttive le abbiamo già usate nei precedenti esercizi, sono quei comandi che cominciano con #.
Ad esempio abbiamo usato #include <pic1684.h> e #include<delay.c>.Questi comandi non fanno parte del programma, tanto è vero che stanno fuori dal corpo principale main. Però servono a passare delle informazioni al compilatore in modo che ne esca fuori un eseguibile adatto alle nostre esigenze.
La preprocessione è la fase in cui il compilatore prende le informazioni date con le direttive (#include, #define) e le memorizza in modo da usarle durante la compilazione vera e propria.
A questo punto dovreste sapere dove mettere la direttiva #define e saprete che al posto di 250 passato al Delay dovrete mettere la costante Aspetta.
Andiamo ad affrontare il problema di come ottenere dei tempi più lunghi dal Delay che non ci da più di 255.Una possibile soluzione potrebbe essere di scrivere tante volte l'istruzione, quante volte vorremmo che duri la pausa, io cercherei un'altra soluzione, altrimenti mi ritrovo a dover scrivere 100 volte la stessa cosa (neanche per castigo, a scuola).
Io scriverei l'istruzione in un ciclo, in modo che il programma lo ripeta quante volte voglio. A tale scopo mi metto a cercare, in rete e nel manuale, l'istruzione di ciclo for, sicuro di trovarlo perché esiste praticamente in tutti i linguaggi.
In particolare mi interessa sapere come và scritto nel linguaggio "C" (sintassi) e come si usa nel programma. Trovo questo:
for (expression1; expression2; expression3) statement; { or block of statements}
Nel linguaggio "C" il ciclo for è talmente potente da sostituire l'istruzione while, è addirittura parametrizzabile con tre espressioni, oltre allo statement che può essere anche un blocco di istruzioni.Nel nostro caso ci basterà mettere il Delay nello statement e definire le espressioni del ciclo.
Nella prima espressione assegno ad una variavile un valore x=0
Nella seconda definisco il valore massimo di x.
Nella terza definisco l'incremento di x.Ottengo:
for(x=0;x<=1;x++)DelayMs(Aspetta);
Forse, messo in questa forma è più chiaro, all'interno delle parentesi spiego cosa faccio: assegno il valore 0 a x, definisco che x deve essere minore o uguale a 1,incremento x di una unità, esegue il delay con il valore Aspetta(già assegnato prima).In pratica il ciclo for, esegue il delay tante volte fino a che x assume il valore di 1, se x assume il valore 1, termina il ciclo.
Nel mettere questo ciclo nel programma, dovremo ricordarci di assegnare x.
Nella pagina seguente riporto il listato completo, con tutti i commenti in modo da essere chiari.
/******************************\
* SEMAFORO *
* (C) 2002 by Sergio Fiocco *
* ROMA IL 09-11-2002 *
\******************************/
#include<pic.h> //direttiva per il pic
#include"delay.c" //aggiunge il Delay alla compilazione
#define Aspetta 255 //La variabile Aspetta assume il valore 255
void pausa(char ripeti); // void è un puntatore che chiama il ciclo pausa quando viene chiamato dalprogramma principale.
main() //Inizio programma
{ //graffa del programma principale
TRISB = 0; //setta tutte le porte B come uscite
while(1) //ciclo senza fine
{ //graffa del ciclo senza fine
PORTB = 0x18; // veicolo verde - pedone rosso
pausa(22); //chiama pausa 22 volte ( vedi il ciclo for chiamato void pausa(char ripeti)
PORTB = 0x1c; // giallopausa(8); //chiama pausa 8 volte
PORTB = 0x22; // veicolo rosso - pedone verde
pausa(20); //chiama 20 volte pausa
PORTB = 0x2; // da qui' in poi lampeggio verde pedone e rosso veicolo acceso
pausa(1);
PORTB = 0x22;
pausa(1);
PORTB = 0x2;
pausa(1);
PORTB = 0x22;
pausa(1);
PORTB = 0x2;
pausa(1);
PORTB = 0x22;
pausa(1);
PORTB = 0x2;
pausa(1);
PORTB = 0x22;
pausa(1);
} //chiusura di while
} //chiusura programma principale
void //puntatore
pausa(char ripeti) //nome assegnato alla funzione del ciclo
{ //apertura della funzione ciclo
char x; //definisce l'esistenza di x
for(x=0;x<=ripeti;x++) //il ciclo vero e proprio (qui NON va il punto e virgola perché finisce dopo)
DelayMs(Aspetta); //l'argomento del ciclo (qui finisce il ciclo e ci và il punto e virgola)
} //chiusura della funzione ciclo
Questo è il listato del codice sorgente finale del programma SEMAFORO che andrà compilato e inserito nel pic della nostra demoboard. Potete divertirvi a fare i vigili comunali di turno e far durare il rosso quanto volete.Potete anche fare un programma che faccia lampeggiare i led in sequenza stile supercar o, visto che manca un mese a Natale, potete anche farvi un alberello su circuito stampato con led lampeggianti. Insomma fateci quello che vi pare, l'importante è che facciate delle prove per imparare a programmare.
Eccoci giunti al termine della lezione n. 1.
Molti punti sarebbero ancora da chiarire ma, con quello che abbiamo fatto finora, dovreste essere in grado di leggere, ed interpretare correttamente, quello che trovate scritto nei manuali di C ed in rete.
Potete guardarvi anche un piccolo corso, di Sergio Camici proposto sul sito www.microrobots.it ,noterete l'estrema somiglianza con questo, anche se scritto in un'altra forma (colpa del "C"). Ho provveduto a segnalare la somiglianza a Sergio Camici, il quale ha proposto di inserire il link in questa pagina.
Se vi è piaciuto questo piccolo corso e vorreste vedere altre lezioni, con altre demoboard, sempre più sofisticate, fatemelo sapere.
| 
