Che cosa è un Microcontrollore?

Transcript

Che cosa è un Microcontrollore?
Guida per Studenti
VERSIONE 3.0
Pagina 2 · Che cosa è un Microcontrollore?
GARANZIA
La Parallax garantisce i suoi prodotti esenti da difetti dei materiali e di fabbricazione per un periodo di 90 giorni dal
ricevimento del prodotto. Se scoprite un difetto, Parallax, a suo giudizio, riparerà o sostituirà la merce o rimborserà il
prezzo di acquisto. Prima di restituire il prodotto a Parallax, richiedete un numero di Return Merchandise
Authorization (RMA). Trascrivete il numero RMA all’esterno della scatola utilizzata per restituire la merce a
Parallax. Per favore includete le seguenti informazioni insieme alla merce restituita: il vostro nome, numero
telefonico, indirizzo della spedizione e una descrizione del problema. La Parallax restituirà il vostro prodotto riparato
o la sua sostituzione utilizzando lo stesso metodo di spedizione che avrete utilizzato per inviare il prodotto a Parallax.
GARANZIA SODDISFATTI O RIMBORSATI DI 14 GIORNI
Se, entro 14 giorni dal ricevimento del vostro prodotto, trovate che esso non soddisfa le vostre necessità, potete
restituirlo per essere totalmente rimborsati. La Parallax rimborserà il prezzo di acquisto del prodotto, costi di
spedizione/gestione esclusi. Questa garanzia è nulla se il prodotto è stato modificato o danneggiato. Si veda il
precedente paragrafo Garanzia per le istruzioni su come restituire un prodotto a Parallax.
COPYRIGHTS E MARCHI DI FABBRICA
Questo documento ha il copyright 2003-2009 della Parallax Inc. Scaricando dal sito o utilizzando una copia stampata
di questo documento o software acconsentite al suo utilizzo esclusivo con prodotti Parallax. Qualsiasi altro uso non è
consentito e può rappresentare una violazione dei copyright Parallax, punibile legalmente in base al copyright
Federale o alle leggi sulla proprietà intellettuale. Qualsiasi duplicazione della documentazione per usi commerciali è
espressamente vietata da Parallax Inc. La duplicazione per uso didattico è consentita, alle condizioni seguenti: il testo,
oppure qualsiasi sua parte, può essere duplicato solo per utilizzo con prodotti Parallax, e l’utente può esigere dallo
studente soltanto i costi di riproduzione. Consultare Parallax per l’approvazione prima di duplicare qualsiasi nostra
documentazione in parte o completamente, per qualsiasi altro uso.
BASIC Stamp, Board of Education, Boe-Bot, Stamps in Class, e SumoBot sono marchi registrati della Parallax, Inc.
HomeWork Board, PING))) Parallax, il logo Parallax, Propeller e Spin sono marchi di fabbrica della Parallax, Inc. Se
decidete di utilizzare una qualsiasi di queste parole nel vostro materiale elettronico o stampato, dovrete dire che
"(marchio di fabbrica) è marchio di fabbrica (registrato) della Parallax Inc.” fin dalla prima comparsa del marchio di
fabbrica. Altri marchi e nomi di prodotti sono marchi di fabbrica o marchi di fabbrica registrati dei loro proprietari.
ISBN 9781928982524
3.0.0-09.12.09-HKTP
SCARICO DI RESPONSABILITA’
La Parallax Inc. non è responsabile di danni speciali, occasionali o consequenziali che risultino da qualsiasi rottura di
garanzia, o sotto qualsiasi tutela legale, compresi perdite di profitto, fermo tecnico, avviamento, danno o sostituzione
di apparecchiature o proprietà, o qualsiasi costo di recupero, ri-programmazione, o riproduzione di qualsiasi dato
memorizzato in, o utilizzato con, prodotti Parallax. La Parallax Inc. inoltre non è responsabile di danni a persone,
compresi i danni di vita e salute, che risultino dall’uso di qualsiasi nostro prodotto. Vi assumete la responsabilità
completa della vostra applicazione BASIC Stamp, indipendentemente dal fatto che possa minacciare la vostra vita.
ERRATA
Anche se si fa un grosso sforzo per assicurare la correttezza dei nostri testi, possono ancora essere riscontrati errori.
Qualche volta, viene immessa sul nostro sito web, www.parallax.com, una pagina di errata-corrige con un elenco di
errori e correzioni noti per un dato testo. Se trovate un errore , vi preghiamo di comunicarcelo inviando una e-mail
all’indirizzo [email protected].
Indice del contenuto
Prefazione....................................................................................................................7
Informazioni Sulla Versione 3.0 ......................................................................................7
A chi e’ destinato il testo .................................................................................................8
Forum di Supporto ..........................................................................................................8
Risorse per gli insegnanti ...............................................................................................9
Traduzioni in altre lingue...............................................................................................10
Notizie sull’Autore .........................................................................................................10
Contributi Speciali .........................................................................................................10
Capitolo 1 : Per iniziare............................................................................................13
Quanti Microcontrollori avete utilizzati oggi? ................................................................13
BASIC Stamp 2 – il vostro nuovo Modulo Microcontrollore ..........................................13
Invenzioni affascinanti coi Microcontrollori BASIC Stamp ............................................14
Hardware e Software ....................................................................................................17
Attività #1 : ottenere il Software ....................................................................................17
Attività #2 : Usare il file di aiuto per impostare l’Hardware ...........................................23
Sommario .....................................................................................................................25
Capitolo 2 : Luci accese – Luci spente ..................................................................29
Luci Indicatrici (o luci spia)............................................................................................29
Fare in modo che un diodo a emissione (LED) emetta luce.........................................29
Attività #1 : Costruzione e prova del circuito a LED..................................................30
Attività #2 : Controllo acceso/spento con il BASIC Stamp ............................................39
Attività #3 : Conteggio e Ripetizione .............................................................................46
Attività #4 : Costruire e provare un secondo circuito LED ............................................50
Attività #5 : Uso della direzione della Corrente per Controllare un LED bicolore .........54
Sommario .....................................................................................................................60
Capitolo 3 : Ingresso Digitale – Pulsanti................................................................65
Li trovate su Calcolatrici, giochi PALMARI ed altre applicazioni...................................65
Ricevere o inviare segnali alti e bassi...........................................................................65
Attività #1 : Prova di un pulsante con un circuito a LED ...............................................65
Attività #2 : Lettura di un pulsante con il BASIC Stamp ................................................69
Attività #3 : Controllo a pulsante di un circuito a LED ...................................................74
Attività #4 : Due pulsanti che controllano due circuiti a LED ........................................77
Attività #5 : Prova di un temporizzatore di reazione .....................................................83
Sommario .....................................................................................................................92
Capitolo 4 : Controllo del Movimento.....................................................................99
Movimento Microcontrollato ..........................................................................................99
Segnali acceso/spento (On/Off) e movimento di un Motore .........................................99
Introduzione al Servo ....................................................................................................99
Attività #1 : Connessione e prova di un servo ............................................................102
Attività #2 : Programma per la prova del controllo di un servo ...................................109
Attività #3 : Controllo del tempo di mantenimento di un servo ...................................120
Attività #4 : Controllo di posizione con il vostro computer ..........................................127
Attività #5 : Conversione da posizione a movimento ..................................................136
Attività #6 : Servo controllato da un pulsante .............................................................139
Sommario ...................................................................................................................144
Capitolo 5 : Misure di rotazione............................................................................ 151
Dischi di Regolazione e apparecchi di rilevamento ...................................................151
La resistenza Variabile sotto il disco – un Potenziometro ..........................................151
Attività #1 : Costruzione e prova del circuito di un potenziometro..............................153
Attività #2 : Misura di una resistenza tramite misura del tempo .................................155
Attività #3 : Lettura di un quadrante circolare con il BASIC Stamp ............................162
Attività #4 : Controllo di un servo con un potenziometro ............................................169
Sommario ...................................................................................................................177
Capitolo 6 : Display digitale .................................................................................. 183
Il Display Digitale Quotidiano......................................................................................183
Che cosa e’ un Display a 7 Segmenti?......................................................................183
Attività #1 : Costruzione e prova del Display a LED a 7 Segmenti .............................185
Attività #2 : Controllo del display LED a 7 Segmenti ..................................................189
Attività #3 : Visualizzazione di cifre.............................................................................192
Attività #4 : Visualizzazione della posizione di un disco .............................................200
Sommario ...................................................................................................................206
Capitolo 7 : Misure di luce..................................................................................... 209
Dispositivi che contengono sensori di luce .................................................................209
Introduzione al fototransistor ......................................................................................212
Attività #1 : Costruzione e prova del misuratore di luce .............................................213
Attività #2 : Registrazione di eventi luminosi ..............................................................217
Attività #3 : Registrare graficamente misure di luce (Opzionale)................................226
Attività #4 : Un semplice misuratore di luce................................................................229
Attività #5 : Uscita On/Off di un fototransistor.............................................................240
Attività #6 : Per divertirsi—Misura della luce esterna con un LED .............................250
Sommario ...................................................................................................................254
Capitolo 8 : Frequenza e Suono ........................................................................... 261
La vostra giornata e i bip Elettronici............................................................................261
Microcontrollori, altoparlanti, e segnali On/Off............................................................261
Attività #1 : Costruzione e prova dell’altoparlante ......................................................262
Attività #2 : Suoni di azione ........................................................................................264
Attività #3 : Note musicali e semplici canzoni .............................................................269
Attività #4 : Musica con il Microcontrollore..................................................................275
Attività #5 : Suonerie con il RTTTL .............................................................................288
Sommario ...................................................................................................................301
Capitolo 9 : Mattoni (elementi di costruzione) elettronici ..................................305
Quei piccoli Chip neri ..................................................................................................305
ESpandete i vostri progetti con circuiti integrati periferici ..........................................306
Attività #1 : Controllo del flusso di Corrente con un Transistor..................................307
Attività #2 : Introduzione del Potenziometro Digitale ................................................310
Sommario ...................................................................................................................320
Capitolo 10 : Costruire prototipi delle proprie Invenzioni..................................325
Applicare le proprie conoscenze ad altre parti e componenti .....................................325
Realizzare il prototipo di un microsistema antifurto ....................................................326
Attività #1 : dall‘Idea alla prova del concetto...............................................................326
Attività #2 : Costruzione e prova singola di ciascun Circuito ......................................330
Attività #3 : Organizzazione di compiti di codifica in piccole parti ..............................332
Attività #4 : Documentazione del proprio codice!........................................................336
Attività #5 : Dotate la vostra applicazione di nuove fantastiche funzionalità...............338
Attività #6 : Come superare le difficoltà di progetto ....................................................339
Attività #7 : Cosa imparare dopo? ............................................................................347
Sommario ...................................................................................................................351
Opzioni Kit Completo ..................................................................................................354
Attività bonus: Legge di ohm, Voltaggio, e Corrente ..............................................356
Indice .......................................................................................................................365
Prefazione · Pagina 7
Prefazione
Questo testo risponde alla domanda “Che cosa è un microcontrollore?” mostrando agli
studenti come progettare le loro personali invenzioni intelligenti col modulo
microcontrollore BASIC Stamp® della Parallax Inc. Le attività in questo testo includono
molti esperimenti divertenti e interessanti progettati per catturare la loro immaginazione
con il movimento, la luce, il suono e le reazioni tattili per esplorare nuovi concetti.
Queste attività presentano allo studente molti principi base della programmazione di
computer, dell’elettricità e dell’elettronica, della matematica e della fisica. Molte di
queste attività agevolano la presentazione di pratiche di progetto utilizzate da ingegneri e
tecnici nel creare macchine ed apparecchiature moderne, utilizzando nel contempo parti
comuni ed economiche.
Che cos’è un microcontrollore? è il testo di ingresso nel programma Stamps in Class. Per
esaminare la serie completa, che include i titoli Robotica con il Boe-Bot, Sensori
intelligenti e loro Applicazioni, Controllo di Processi e altri, visitate il sito
www.parallax.com/Education.
INFORMAZIONI SULLA VERSIONE 3.0
Questa è la prima revisione di questo libro fatta, dal 2004 a oggi. I cambiamenti di
maggior rilievo includono:




Sostituzione delle fotoresistenze al solfuro di cadmio con un sensore di luce
conforme-RoHS di un tipo che sarà molto comune nel progetto di prodotti del
prossimo futuro. Ciò ha richiesto la riscrittura dei Capitoli 7 e 10, e varie
modifiche in altri capitoli.
Miglioramento delle attività e delle figure del controllo servo nel Capitolo 4.
Trasporto della porzione “Installazione e prova” del Capitolo 1 e delle appendici
Hardware e Ricerca Guasti nel file di aiuto. Ciò ha consentito di poter supportare
le connessioni hardware seriale ed USB, e altre connessioni di programmazione
dato che i nostri prodotti continuano ad espandersi. Ciò consente anche la
manutenzione dinamica del materiale di Hardware e Ricerca Guasti.
Rimozione dei riferimenti al CD Parallax, che è stato tolto dai nostri kit,
riducendo i rifiuti e assicurando ai clienti il download del software BASIC
Stamp Editor e dei driver USB più recenti disponibili per i loro sistemi operativi.
In aggiunta, sono stai corretti piccoli elementi errati notati nella versione precedente
(2.2). Il materiale punta ancora alle stesse méte, e sono stati trattati gli stessi concetti e
comandi di programmazione con l’aggiunta di pochi altri concetti nuovi. Infine, i numeri
di pagina sono stati modificati in modo che la pagina del PDF e la pagina fisica hanno
adesso gli stessi numeri, per comodità di uso.
A CHI E’ DESTINATO IL TESTO
Questo testo è progettato come primo approccio alla letteratura tecnologica, e come facile
curva di apprendimento della programmazione e del progetto di dispositivi, incorporati
nel testo. Esso è organizzato in modo che possa essere usato dalla più ampia varietà
possibile di studenti e anche da autodidatti. Gli studenti della scuola media superiore
possono provarne gli esempi in modo guidato seguendo le semplici istruzioni passopasso
contrassegnate da un segno di spunta, con la supervisione di un istruttore. D’altra parte, le
capacità di comprensione e soluzione dei problemi per gli studenti laureandi in ingegneria
saranno messe alla prova con domande, esercizi finali e progetti (con soluzioni) nel
sommario di ciascun capitolo. Gli autodidatti potranno imparare con il loro ritmo ed
ottenere assistenza attraverso il forum Stamps in Class citato qui sotto.
FORUM DI SUPPORTO
La Parallax gestisce per i propri clienti forum con moderatore, riguardanti vari argomenti:
 Chip Propeller: per tutte le discussioni relative alla linea di prodotto
Microcontrollore a più nuclei Propeller (elica) e ai suoi strumenti di sviluppo.
 BASIC Stamp: Ideee di progetto, supporto, e argomenti connessi per tutti i
modelli BASIC Stamp Parallax.
 Microcontrollori SX: Assistenza tecnica per tutti i prodotti con il chip SX,
inclusi il Complatore SX/B, e lo Strumento SX-Key.
 Sensori: Discussione riguardante il grande gruppo dei sensori Parallax, e
l’interfacciamento dei sensori con i microcontrollori Parallax.
 Stamps in Class: Studenti, insegnanti e clienti discutono qui i materiali didattici
Parallax e i progetti scolastici.
 Robotica: Per tutti i robot Parallax e i robot personalizzati costruiti con
processori e sensori Parallax.
 Cassetta di sabbia (The Sandbox): Argomenti riguardanti l’uso dei prodotti
Parallax ma non specifici degli altri forum.
 Progetti completati: Inviate qui i vostri progetti completati, realizzati con
prodotti Parallax.

Sviluppo del gioco Sistema HYDRA e Propeller: Discussione e assistenza
tecnica per il Kit di sviluppo del gioco HYDRA e della relativa programmazione
del microcontrollore Propeller.
RISORSE PER GLI INSEGNANTI
Una vasta gamma di risorse per questo testo sono progettate per supporto agli insegnanti.
“Mini Progetti Stamps in Class”
Per aggiungere un supplemento ai nostri testi, forniamo un banco di progetti per la classe.
Progettato per coinvolgere gli studenti, ciascun “Mini Progetto” contiene tutto il codice
sorgente, le spiegazioni di “Come opera”, gli schemi, e i diagrammi di cablaggio o
fotografie del dispositivo che lo studente potrebbe voler utilizzare. Molti progetti
esibiscono un video introduttivo, per promuovere lo studio autonomo negli studenti più
interessati ad elettronica e programmazione. Seguire semplicemente il link “Mini Projects
Stamps in Class” nel sito www.parallax.com/Education.
Corsi per insegnanti
Questi corsi disponibili, intensivi, di 1 o 2 giorni per gli istruttori sono tenuti da ingegneri
Parallax o da insegnanti esperti che utilizzino materiali didattici Parallax nelle loro classi.
Visitare il sito www.parallax.com/Education → Educators Courses per dettagli.
Forum dell’insegnante Parallax
In questo forum libero, privato, gli insegnanti possono rivolgere domande e condividere
le loro esperienze con utilizzo di prodotti Parallax nelle loro classi. Sono postati qui
anche materiali didattici supplementari. Per inserirsi, chiedere istruzioni per email a
[email protected]; sarà richiesta una prova dello stato di insegnante.
Materiali didattici supplementari
Testi didattici Parallax selezionati hanno un insieme non pubblicato di domande e
soluzioni che vengono postati nei nostri Forum Parallax per Insegnanti; invitiamo gli
insegnanti a copiare e modificare questo materiale a propria volontà per la preparazione
sollecita di compiti a casa, quiz, e prove. Si possono anche postare qui presentazioni
PowerPoint e materiali di prova preparati da altri insegnanti.
Permessi di Copyright per uso didattico
Non è richiesta alcuna licenza per lo scarico (download), la duplicazione e l’installazione
di software Parallax per uso didattico con prodotti Parallax su quante scuole o computer
occorra. I nostri testi Stamps in Class e il manuale BASIC Stamp sono tutti disponibili
come PDF scaricabili gratuitamente, e possono essere altresì copiati con l’intesa che si
impieghino per uso didattico esclusivamente con prodotti Parallax; lo studente deve solo
pagare il costo della copia. I file PDF non sono bloccati, consentendo la scelta di testi e
immagini per preparare sommari, trasparenze, o presentazioni PowerPoint.
TRADUZIONI IN ALTRE LINGUE
Molti dei nostril testi Stamps in Class sono stati tradotti in altre lingue; questi testi si
possono scaricare gratuitamente e sono soggetti agli stessi permessi di Copyright per uso
didattico delle nostre versioni originali. Per vederne l’elenco completo, cliccate sul link
Tutorials & Translations al sito www.parallax.com/Education. Queste traduzioni sono
state preparate in coordinamento con il programma di Traduttore Volontario Parallax. Se
siete interessati a partecipare al nostro programma di Traduttore Volontario, inviate una
email all’indirizzo [email protected].
NOTIZIE SULL’AUTORE
Andy Lindsay è entrato alla Parallax Inc. nel 1999, e da allora è stato autore di otto libri e
di numerosi articoli e documenti di prodotto per la società. Le ultimi tre versioni di Che
cos’è un microcontrollore? (What’s a Microcontroller?) sono state progettate ed
aggiornate sulla base di osservazioni e reazioni didattiche che Andy ha raccolto nei suoi
viaggi attraverso il paese e all’estero gestendo Corsi per Insegnanti e manifestazioni
Parallax. Andy ha studiato Ingegneria Elettrotecnica ed Elettronica all’università statale
della California, a Sacramento, ed è autore contributore di molti articoli che riguardano i
microcontrollori nei curricola dei laureandi (tesine). Quando non scrive materiale
didattico, Andy si occupa di ingegnerizzazione di prodotto e applicazioni per la Parallax.
CONTRIBUTI SPECIALI
Il Gruppo di lavoro che la Parallax ha messo insieme per scrivere la presente edizione del
testo comprende: l’eccellente direzione di dipartimento di Aristides Alvarez, il progetto
delle lezioni e la scrittura tecnica a cura di Andy Lindsay; la grafica di copertina di Jen
Jacobs; le illustrazuioni grafiche di Rich Allred e Andy Lindsay; la revisione tecnica di
Jessica Uelmen; la ricerca di peculiarità tecniche, l’editing, e l’organizzazione del testo di
Stephanie Lindsay. Ringraziamenti speciali vanno a Ken Gracey, fondatore del
programma Stamps in Class, e a Tracy Allen e Phil Pilgrim per la consultazione nella
scelta del sensore di luce utilizzato in questa versione per sostituire la fotoresistenza al
solfuro di cadmio.
Molte persone hanno contribuito allo sviluppo di Che cos’è un Microcontrollore? e
hannpo dato assistenza nelle edizioni precedenti, e ad essi siamo ancora grati. Parallax
desidera ringraziare di nuovo Robert Ang per la sua attenta revisione e i suoi inserimenti
dettagliati, e l’anziano ingegnere veterano e stimato cliente Sid Weaver per la sua
perspicace revisione. Grazie anche agli autori Stamps in Class Tracy Allen (Applied
Sensors, Sensori applicati) e Martin Hebel (Process Control, Controllo di Processo) per
la loro revisione e le loro raccomandazioni. Andy Lindsay desidera ringraziare suo padre
Marshall e suo cognato Kubilay per i loro consigli e suggerimenti musicali esperti.
Per iniziare · Pagina 13
Capitolo 1: Per iniziare
QUANTI MICROCONTROLLORI AVETE UTILIZZATI OGGI?
Un microcontrollore è una specie di computer in miniatura che potete trovare in tutti i tipi
di oggetti. Alcuni esempi di oggetti comuni, di tutti i giorni, che contengono
microcontrollori sono illustrati in Figura 1-1. Se l’oggetto possiede dei tasti ed un
display, è probabile che abbia anche un cervello a microcontrollore.
Figura 1-1
Esempi di oggetti comuni
che contengono un
Microcontrollore.
Provate a fare un elenco e a contare quanti dispositivi con microcontrollore usate in una
giornata tipo. Ecco alcuni esempi: se al mattino la vostra radio-sveglia si spenge, e se
premete più volte il tasto “snooze”, la prima cosa che fate nella vostra giornata è
interagire con un microcontrollore. Riscaldare dei cibi nel forno a microonde oppure fare
una telefonata con il cellulare, implica usare microcontrollori. E questo è solamente
l’inizio. Ecco alcuni altri esempi: accendere un televisore con il telecomando, giocare con
un videogioco, e usare una calcolatrice. Tutti questi dispositivi contengono dei
microcontrollori che interagiscono con voi.
BASIC STAMP 2 – IL VOSTRO NUOVO MODULO MICROCONTROLLORE
Il modulo BASIC Stamp 2 della Parallax Inc. mostrato in Figura 1-2 ha incorporato al
suo interno un microcontrollore; è il circuito integrato più grosso, di colore nero. Il resto
dei componenti nel modulo BASIC Stamp si trovano anche negli oggetti comuni che
usate tutti i giorni. Tutto l'insieme è chiamato sistema computerizzato entrocontenuto.
Questo nome è comunemente accorciato in “sistema incorporato”. Frequentemente, tali
moduli sono comunemente chiamati solo “microcontrollori.”
Le attività in questo testo vi guideranno nella costruzione di circuiti simili a quelli
presenti negli apparecchi di uso comune e nei gingilli ad alta tecnologia. Scriverete
inoltre programmi al computer che il modulo BASIC Stamp eseguirà. Questi programmi
Pagina 14 · Che cosa è un microcontrollore?
sorveglieranno e faranno controllare dal BASIC Stamp i circuiti cosicché essi svolgano
funzioni utili.
Figura 1-2
Modulo
Microcontrollore
BASIC Stamp 2
®
In questo testo, “BASIC Stamp” si riferisce al modulo microcontrollore BASIC Stamp
2. Progettato e prodotto dalla Parallax Incorporated, il nome di questo modulo di solito si
abbrevia in BS2, ed è il primo della serie di moduli mostrati in Figura 1-3. Ciascun modulo è
leggermente diverso, ed è caratterizzato da velocità più alta, memoria pià grande, funzioni
aggiuntive, o alcune combinazioni di queste caratteristiche extra. Per saperne di più,
seguite il link “Compare BASIC Stamp Modules” al sito www.parallax.com/basicstamp.
Figura 1-3
Modelli BASIC
Stamp 2, da
sinistra a destra:
BS2, BS2e,
BS2sx, BS2p24,
BS2p40, BS2pe,
BS2px
INVENZIONI AFFASCINANTI COI MICROCONTROLLORI BASIC STAMP
Le applicazioni comuni non sono le sole cose con microcontrollori. Robot, macchinari,
progetti aerospaziali ed altri dispositivi ad alta tecnologia sono anch’essi fabbricati con
microcontrollori. Diamo uno sguardo ad alcuni esempi creati con i BASIC Stamp.
I Robot sono stati progettati per fare qualsiasi cosa, dall’aiutare gli studenti ad apprendere
di più circa i microcontrollori, a rasare i prati, alla soluzione di problemi meccanici
complessi. La Figura 1-4 mostra due robot esempio. Su ciascuno di essi, gli studenti
usano il BASIC Stamp per leggere sensori, controllare motori, e comunicare con altri
computer. Il robot sulla sinistra è chiamato Boe-Bot. Il progetto pubblicato nel libro
Robotica con il Boe-Bot può essere approfondito usando il Boe-Bot dopo aver eseguito
le attività di questo testo. Il robot sulla destra, chiamato VCD (veicolo con controllo a
distanza: in inglese ROV, Remotely Operated Vehicle), è stato costruito e collaudato in
un Istituto per Insegnanti Estivo MATE (Marine Advanced Technology Education). Gli
operatori vedono un televisore che visualizza quello che il ROV vede tramite una videocamera e lo controllano con una combinazione di controlli manuali e un notebook. Il suo
BASIC Stamp misura profondità e temperatura, controlla il motore di spinta verticale, e
scambia informazioni con il notebook. Il MATE coordina gare regionali e internazionali
di ROV, per studenti che vanno dal livello di scuola media superiore all’università.
Figura 1-4
Robot didattici
Robot Boe-Bot (a
sinistra); ROV all’Istituto
Estivo per Insegnanti
MATE (a destra,
www.marinetech.org)
Altri robot risolvono problemi complessi, come il robot per il volo autonomo illustrato
nella Figura 1-5, a sinistra. Questo robot è stato costruito e collaudato dagli studenti di
ingegneria meccanica dell’università di California, a Irvine. Hanno usato un BASIC
Stamp per comunicare con un satellite del sistema GPS, cosicché il robot possa conoscere
la sua posizione ed altitudine. Il BASIC Stamp legge inoltre i sensori di livellamento e
controlla le impostazioni dei motori perché il robot possa volare correttamente. Il robot
millepiedi meccanico, sulla destra, è stato sviluppato da un professore all’università
tecnica Nanyang di Singapore. Ha più di 50 BASIC Stamp, e ciascuno comunica con gli
altri tramite una rete complessa che aiuta a controllare ed orchestrare il movimento di
ciascun set di zampe. Robot come questi non solo ci aiutano a capire meglio i progetti
della natura, ma potrebbero eventualmente essere usati per esplorare località remote o
perfino altri pianeti.
Figura 1-5
Robot di ricerca che
contengono
Microcontrollori
Robot volante autonomo
a Università di California,
Irvine (a sinistra) e
Progetto Millepiedi alla
Universià di Nanyang (a
destra)
Con l’aiuto dei microcontrollori, i robot si assumeranno anche i lavori quotidiani, come
per esempio tagliare l’erba. Il BASIC Stamp all’interno del tagliaerba robotizzato della
figura 1-6 fa sì che il tagliaerba rimanga entro i confini del prato, legge anche i sensori
che rilevano ostacoli e controlla i motori che lo fanno muovere.
Figura 1-6
Tagliaerba robotizzato
con Modulo
Microcontrollore
BASIC Stamp 2
I microcontrollori sono usati anche nei progetti scientifici, ad alta tecnologia, ed
aerospaziali. La stazione meteorologica, mostrata a sinistra nella Figura 1-7, è usata per
raccogliere dati ambientali sulla degradazione della barriera corallina. Il BASIC Stamp al
suo interno raccoglie dati da molti sensori e li memorizza per farli recuperare
successivamente dagli scienziati. Il sottomarino al centro è un veicolo per l’esplorazione
sottomarina, e le sue eliche, telecamere e luci, sono tutte controllate da microcontrollori
BASIC Stamp. Il razzo mostrato sulla destra fa parte di una gara per lanciare nello spazio
un razzo privato. Nessuno ha vinto la gara, ma questo razzo ha almeno partecipato. Il
BASIC Stamp controllava esattamente ogni aspetto della sequenza di lancio.
Figura 1-7
Esempi di microcontrollori per
uso ambientale ed Aerospaziale
Raccolta dati ambientali dalla
EME Systems (a sinistra),
ricerca sottomarina dallo Harbor
Branch Institute (al centro), e
lancio di prova della JP
Aerospace (a destra)
Dalle comuni applicazioni domestiche su su fino alle applicazioni scientifiche ed
aerospaziali, saranno qui introdotte le basi dei microcontrollori che vi occorre conoscere
per iniziare progetti come questi. Lavorando sulle attività di questo libro, sperimenterete
ed apprenderete l’uso di una molteplicità di blocchi basilari presenti in tutti questi oggetti
ad alta tecnologia. Costruirete circuiti per display, sensori, e controlli di motori.
Apprenderete come collegare questi circuiti al BASIC Stamp, ed a scrivere programmi
che faranno controllare display, raccogliere dati da sensori, e controllare il movimento.
Di conseguenza, imparerete molti concetti e tecniche di elettronica e programmazione.
Prima di fine corso, potreste aver inventato un dispositivo di vostra progettazione.
HARDWARE E SOFTWARE
Ambientarsi con il BASIC Stamp è come l’utilizzo iniziale di un PC o un portatile. La
prima cosa che molte persone devono fare con un PC o un portatile nuovo, è di toglierlo
dalla scatola, collegarlo, installare e provare i programmi e forse, perfino scrivere di
propria mano del software usando un linguaggio di programmazione. Se è la prima volta
che utilizzate il BASIC Stamp, dovrete fare le stesse attività. Se siete in una classe, potete
trovare il BASIC Stamp già assemblato. In questo caso, il vostro insegnante può fornirvi
altre istruzioni. Altrimenti, questo capitolo vi guiderà in tutte le fasi di assemblaggio e
accensione del vostro nuovo microcontrollore BASIC Stamp.
ATTIVITÀ #1: OTTENERE IL SOFTWARE
Il software che userete in quasi tutte le attività e i progetti di questo testo, è l’Editor del
BASIC Stamp (versione 2.5 o superiore). Userete questo software per scrivere
programmi che il BASIC Stamp eseguirà. Potrete usare questo software anche per
visualizzare messaggi inviati dal BASIC Stamp. utili per capire che cosa sta accadendo.
Requisiti del sistema (Computer)
Per eseguire il software BASIC Stamp Editor vi occorrerà un Personal Computer. Il
vostro computer dovrà avere le seguenti caratteristiche:



Microsoft Windows 2000 o sistema operativo più recente
Una porta seriale o USB disponibile
Accesso ad Internet e un programma browser per Internet
Scaricare il software da Internet
È importante, se possibile, utilizzare sempre l’ultima versione del software Editor BASIC
Stamp. Il primo passo è andare sul sito web della Parallax e scaricare il software.
 Utilizzando un browser web, andate a www.parallax.com/basicstampsoftware
(Figura 1-8).
Figura 1-8
La pagina del software
BASIC Stamp Editor al
sito www.parallax.com/
basicstampsoftware
Questo è il sito per
scaricare l’ultima
versione del software.
 Cliccare sul pulsante Click Here to Download per scaricare l’ultima versione del
software BASIC Stamp Editor per Windows (Figura 1-9).
Figura 1-9
Il pulsante Download
sulla pagina del Software
Editor BASIC Stamp.
Cliccare sul pulsante per
iniziare lo scarico.
 Si aprirà una finestra di Scarico File, e vi verrà chiesto se volete eseguire o
salvare questo file (Figura 1-10). Cliccare sul pulsante Save.
Figura 1-10
Finestra di scarico File
Cliccare Save, quindi
salvare il file sul proprio
computer.
 Usare il campo Save in per scegliere un luogo sul vostro computer ove salvare il
file di installazione, quindi ciccare il pulsante Save (Figura 1-11).
Figura 1-11
Finestra Save As
Scegliere un posto sul
vostro computer ove
salvare l’installatore di
software,poi cliccare su
Save.
 Quando vedrete “Download Complete,” cliccate sul pulsante Run (Figura 1-12.)
 Seguite le richieste che appariranno. Potrete vedere messaggi dal vostro sistema
operativo che vi chiedono di voler continuare con l’installazione. Accettate
sempre di voler continuare.
Figura 1-12
Messaggio
Download Complete
Cliccare Run.
Se viene richiesto,
confermate sempre di
voler continuare.
 Si aprirà la finestra dell’installatore di BASIC Stamp Editor (Figura 1-13).
Cliccate Next e seguite le richieste, accettando tutti i default.
Figura 1-13
Finestra
dell’installatore del
BASIC Stamp Editor
Cliccate Next.
 IMPORTANTE: quando appare il messaggio “Install USB Driver” (Figura
1-14), lasciate il segno di spunta al suo posto per il box Automatically
install/update driver (raccomandato) , e poi cliccate Next.
Figura 1-14
Messaggio
Install USB Driver
Lasciare il box
spuntato,e cliccate
Next.
 Quando apparirà il messaggio “Ready to Install the Program” (Figura 1-15),
cliccare sul pulsante Install. Può apparire una barra di progresso, e il processo di
installazione può prendere alcuni minuti.
Figura 1-15
Pronto ad installare il
programma
Per continuare
cliccate Install.
A questo punto, può apparire una finestra aggiuntiva dietro la finestra corrente mentre
vengono aggiornati i driver USB. Questa finestra eventualmente si chiuderà da sola
quando l’installazione del driver è completa. Se non vedete questa finestra, non c’è alcun
problema.
Sui driver USB. I driver USB che vengono installati di default con la finestra dell’installatore
dell’Editor BASIC Stamp sono necessari per usare qualsiasi hardware Parallax connesso
alla porta USB del vostro computer. VCP sta per Virtual COM Port (porta COM virtuale), e
consentirà alla porta USB del vostro computer di apparire ed essere considerata dal
hardware Parallax come una porta seriale standard RS232.
Driver USB per Sistemi Operativi diversi I driver USB VCP inclusi nella finestra del
software Editor BASIC Stamp sono unicamente per alcuni sistemi operativi Windows. Per
maggiori informazioni, visitate il sito www.parallax.com/usbdrivers.
 Quando la finestra vi comunica che l’installazione è stata completata con
successo, cliccate Finish (Figura 1-16).
Figura 1-16
Installazione del
Editor BASIC
Stamp completata
Cliccare Finish.
ATTIVITÀ #2: USARE IL FILE DI AIUTO PER IMPOSTARE L’HARDWARE
In questo capitolo eseguirete il file di aiuto dell’Editor BASIC Stamp. All’interno del file
di aiuto, imparerete a conoscere le diverse schede di programmazione del BASIC Stamp
disponibili per il programma Stamps in Class, e determinerete quale state utilizzando.
Quindi, seguirete i passi nel file di Aiuto per connettere il vostro hardware al vostro
computer e provare il vostro sistema di programmazione BASIC Stamp.
Prima esecuzione dell’Editor BASIC Stamp
 Se vedete l’icona dell’Editor BASIC Stamp sul desktop del vostro computer,
cliccatela due volte (Figura 1-17).
 Oppure, cliccate sul menù Start del vostro computer, quindi scegliete Tutti i
programmi  Parallax Inc  BASIC Stamp Editor 2.5  BASIC Stamp Editor 2.5.
Figura 1-17
Icona del Editor BASIC
Stamp sul Desktop
Cliccare due volte per
lanciare il programma.
 Sulla barra strumenti del Editor BASIC Stamp, cliccare Help sulla barra dei
menu (Figura 1-18) e poi selezionare BASIC Stamp Help… dal menù a tendina.
Figura 1-18
Aprire il Menu Help
Cliccare Help,poi
scegliere BASIC
Stamp Help dal
menu a tendina
.
Figura 1-19: Aiuto (Help) del Editor BASIC Stamp
 Cliccare sul link Getting Started with Stamps in Class nella parte in basso a destra
della pagina di Benvenuto (Welcome), come mostrato nell’angolo in basso a
destra della Figura 1-19.
Seguire le istruzioni nel file di aiuto
Da qui, seguirete le istruzioni nel file di Aiuto per completare questi compiti:






Identificate quale scheda di sviluppo BASIC Stamp state usando
Connettete la scheda di sviluppo al vostro computer
Provate la vostra connessione di programmazione
Provate a cercare i guasti della connessione di programmazione, se necessario
Scrivete il vostro primo programma PBASIC per il vostro BASIC Stamp
Quando avete finito, togliete alimentazione al vostro hardware
Quando avete completato le attività nel vostro file di Aiuto, tornate a questo libro e
continuate con il Sommario qui sotto prima di passare al Capitolo 2.
Che fare se non si sa cosa fare?
Se riscontrate problemi mentre seguite le istruzioni di questo libro o del file di Aiuto, avete
molte opzioni per ottenere supporto tecnico gratuito:




Forum: iscrivetevi ad un forum e postate un messaggio al nostro forum gratuito
Stamps in Class con moderatore al sito forums.parallax.com.
Email: inviate una email a [email protected].
Telefono: Negli Stati Uniti Continentali, chiamate il numero gratuito 888-99STAMP (888-997-8267). In tutti gli altri Stati chiamare (916) 624-8333.
Maggiori risorse: Visitate www.parallax.com/support.
SOMMARIO
Questo capitolo vi ha guidato attraverso i seguenti argomenti:
 Una introduzione ad alcuni dispositivi che contengono microcontrollori
 Una introduzione al modulo BASIC Stamp
 Panoramica di alcune interessanti invenzioni fatte con i moduli BASIC Stamp
 Dove trovare il software gratuito Editor BASIC Stamp che userete in quasi tutti
gli esperimenti in questo testo
 Come installare il software Editor BASIC Stamp









Come utilizzare il file di Aiuto dell’Editor BASIC Stamp e il Manuale BASIC
Stamp
Introduzione al modulo BASIC Stamp, alla scheda Board of Education, e alla
scheda HomeWork Board
Come impostare il vostro hardware BASIC Stamp
Come provare i vostri software ed hardware
Come scrivere ed eseguire un programma PBASIC
Usare i comandi DEBUG ed END
Usare il carattere di controllo CR e il formattatore DEC
Una breve introduzione al codice ASCII
Come togliere tensione alla vostra scheda Board of Education o HomeWork
Board quando avete finito
Domande
1. Che cosa è un microcontrollore?
2. Un modulo BASIC Stamp è un microcontrollore, o ne contiene uno?
3. Quali tracce cerchereste per verificare se un meccanismo come una radio sveglia
o un telefono cellulare contiene un microcontrollore o no?
4. Cosa significa un apostrofo all’inizio di una riga di codice in un programma
PBASIC?
5. Quali istruzioni PBASIC avete appreso in questo capitolo?
6. Diciamo che volete interrompere il vostro progetto BASIC Stamp per andare a
fare uno spuntino, oppure volete forse fare una pausa più lunga e tornare ad
occuparvi del progetto tra due giorni. Cosa dovrete sempre fare prima della
vostra interruzione?
Esercizi
1. Spiegate cosa fa l’asterisco in questa istruzione:
DEBUG DEC 7 * 11
2. Indovinate cosa visualizzerà il terminale di Debug se eseguite questa istruzione:
DEBUG DEC 7 + 11
3. C’è un problema con queste due istruzioni. Quando eseguite il codice, i numeri
che esse visualizzano sono attaccati insieme, cosicché ci appare un unico grande
numero invece di due numeri piccoli. Modificate queste due istruzioni in modo
che le risposte appaiano su righe distinte nel terminale di Debug.
DEBUG DEC 7 * 11
DEBUG DEC 7 + 11
Progetti
1. Usare DEBUG per visualizzare la soluzione del problema: 1 + 2 + 3 + 4.
2. Salvate FirstProgramYourTurn.bs2 (PrimoProgrammaVostroTurno.bs2) sotto
altro nome. Se dovete porre l’istruzione DEBUG mostrata sotto sulla riga che
precede l’istruzione END nel programma, quali altre righe dovrete cancellare e
avere lo stesso funzionamento? Modificate la copia del programma per provare
la vostra ipotesi (la vostra previsione di cosa accadrà).
DEBUG "Quant’è 7 X 11?", CR, "Risposta: ", DEC 7 * 11
Soluzioni
Q1. Un microcontrollore è una specie di computer in miniatura che si trova in
prodotti elettronici.
Q2. Il modulo BASIC Stamp contiene un chip microcontrollore.
Q3. Se l’apparato ha pulsanti ed un display digitale, queste sono buone tracce perché
al suo interno contenga un microcontrollore.
Q4. Un commento.
Q5. DEBUG ed END
Q6. Scollegare la alimentazione elettrica dal progetto BASIC Stamp.
E1. Moltiplica i due operandi 7 ed 11, e dà come risultato il prodotto 77. L’asterisco
è l’operatore di moltiplicazione.
E2. Il terminale di Debug visualizza: 18
E3. Per risolvere il problema, aggiungere un ritorno carrello usando i carattere di
controllo CR e una virgola.
DEBUG DEC 7 * 11
DEBUG CR, DEC 7 + 11
P1. Ecco un programma che visualizza la soluzione del problema: 1+2+3+4.
' Che cos’è un Microcontrollore - Cap01Pr01_Aggiungi1234.bs2
'{$STAMP BS2}
'{$PBASIC 2.5}
DEBUG "Quant’è 1+2+3+4?"
DEBUG CR, "Risposta: "
DEBUG DEC 1+2+3+4
END
P2. Le ultime tre righe DEBUG possono essere cancellate. Occorre un CR aggiuntivo
dopo il messaggio "Ciao".
' Che cos’è un Microcontrollore - Cap01Pr02_PrimoProgrVostroTurno.bs2
' BASIC Stamp invia un messaggio al terminale di Debug.
' {$STAMP BS2}
' {$PBASIC 2.5}
DEBUG "Ciao, sono io, il tuo BASIC Stamp!", CR
DEBUG "Quant’è 7 X 11?", CR, "Risposta: ", DEC 7 * 11
END
L’uscita dal terminale di Debug è:
Ciao, sono io, il tuo BASIC Stamp!
Quant’è 7 X 11?
Risposta: 77
Questa uscita è la stessa di quella prodotta dal codice precedente. Questo è un
esempio di come utilizzare le virgole per far uscire una serie di informazioni,
tramite una sola istruzione DEBUG contenente più elementi al suo interno
.
Ingresso digitale - Pulsanti · Pagina 29
Capitolo 2: Luci accese – Luci spente
LUCI INDICATRICI (O LUCI SPIA)
Le luci indicatrici (o spie luminose, o indicatori luminosi) sono talmente comuni che la
maggior parte delle persone tende a non dar loro molta importanza. La Figura 2-1 mostra
tre luci indicatrici su una stampante laser. A seconda di quale luce sia accesa, la persona
che sta utilizzando la stampante sa se sta funzionando in modo corretto o richiede
attenzione. Ecco pochi esempi di dispositivi con spie luminose: impianti stereo da
automobile, televisori, riproduttori DVD, unità disco, stampanti, e pannelli di controllo di
sistemi di allarme.
Figura 2-1
Luci indicatrici
Le luci indicatrici
sono d’uso comune
in molti dispositivi
d’impiego quotidiano.
Accensione e spegnimento di indicatori luminosi è semplicemente un problema di
connessione o disconnessione da una sorgente di energia. In alcuni casi, la spia luminosa
è connessa direttamente alla batteria o all’alimentatore elettrico, come ad esempio la spia
indicatrice di alimentazione sulla Board of Education. Altre spie luminose sono accese o
spente da un microcontrollore contenuto entro il dispositivo. Queste sono, di solito, spie
luminose dello stato che informano quale dispositivo sta funzionando.
FARE IN MODO CHE UN DIODO A EMISSIONE (LED) EMETTA LUCE
La maggior parte delle luci indicatrici che vedete sui dispositivi sono dette diodi a
emissione di luce. Spesso, nei libri e negli schemi circuitali, ci si riferisce ai diodi a
emissione di luce con le lettere LED. Il nome si legge con le tre lettere: “L-E-D.” Potete
costruire un circuito a LED e dargli energia, e il LED emette luce. Potete scollegare
l’energia da un circuito a LED, e il LED smette di emettere luce.
Un circuito a LED può essere connesso al BASIC Stamp, e il BASIC Stamp può essere
programmato per collegare e scollegare l’energia al circuito LED. Ciò è molto più facile
che cambiare manualmente il cablaggio del circuito o connettere e disconnettere la
batteria. Il BASIC Stamp può essere anche programmato per fare quanto segue:




Accendere e spegnere un circuito LED con velocità diverse
Accendere e spegnere un circuito LED un certo numero di volte
Controllare più di un circuito LED
Controllare il colore di un circuito a LED bicolore (a due colori)
ATTIVITÀ #1: COSTRUZIONE E PROVA DEL CIRCUITO A LED
È importante provare singolarmente i componenti prima di assemblarli in un sistema più
grande. L’attività ha lo scopo di costruire e provare due diversi circuiti a LED. Il primo
circuito è quello che fa in modo che il LED emetta luce. Il secondo circuito è quello che
non gli fa emettere luce. Nell’attività successiva a questa, costruirete il circuito a LED in
un sistema più grande connettendolo al BASIC Stamp. Scriverete poi un programma che
fa in modo che il BASIC Stamp faccia emettere luce al LED, quindi non gli faccia
emettere luce. Provando prima ciascun circuito LED per accertarvi che funzioni, avrete
maggior confidenza col suo funzionamento quando lo collegate ad un BASIC Stamp.
Introduzione della Resistenza
Una resistenza (o resistore) è un componente che “resiste” al flusso di elettricità. Questo
flusso di elettricità è chiamato corrente. Ciascuna resistenza ha un valore che dice con
quanta forza essa resiste al flusso di corrente. Il valore della resistenza è detto ohm, e il
simbolo per l’ohm è la lettera greca omega: Ω. Più avanti in questo libro vedrete il
simbolo kΩ, che significa kilo-ohm, o un migliaio di ohm. La resistenza con cui
lavorerete in questa attività è la resistenza da 470 Ω mostrata in Figura 2-2. La
resistenza ha due fili (detti conduttori o fili, leads in inglese, pronuncia “lìds”), ciascuno
che esce da una delle due estremità. Tra i due conduttori c’è un involucro ceramico, ed è
questa la parte che resiste al flusso di corrente. In tutti gli schemi circuitali che hanno
resistenze si usa il simbolo linea seghettata (a sinistra) per dire alla persona che costruisce
il circuito che deve usare una resistenza da 470 Ω. Questo è un simbolo schematico. Il
disegno a destra è un disegno di parte usato in alcuni testi Stamps in Class a livello
principianti per aiutarvi a identificare la resistenza nel vostro kit, e dove porla quando
costruite il circuito.
Gold
Silver
or
Blank
470 
Yellow
Brown
Giallo
Marrone
Violet
Viola
Figura 2-2
Disegno di parte di una Resistenza da
470 Ω
Simbolo schematico (a sinistra) e
Disegno di Parte (a destra)
Le resistenze come quelle che stiamo usando in questa attività hanno strisce colorate che
ci dicono quali sono i loro valori di resistenza. Per ogni valore di resistenza c’è una
diversa combinazione (o codice) di colori. Ad esempio, il codice di colori per la
resistenza da 470 Ω è giallo-viola-marrone (yellow-violet-brown).
C’è anche una quarta striscia che indica la tolleranza sul valore della resistenza. La
tolleranza è misurata in percentuale, e ci dice quanto la vera resistenza della parte
potrebbe essere fuori dalla resistenza indicata. La quarta striscia potrebbe essere oro
(gold) (5%), argento (silver) (10%) o nessuna striscia (20%). Per le attività in questo
libro la tolleranza delle resistenze non è importante, ma lo è il loro valore.
Ciascuna striscia colorata che dà il valore della resistenza corrisponde a una cifra, e
questi colori/cifre sono elencati nella Tabella 2-1. La Figura 2-3 mostra come usare
ciascuna striscia di colore con la tabella per determinare il valore di una resistenza.
Tabella 2-1
Valori del codice dei
colori per le resistenze
Cifra
Colore (inglese)
0
1
2
3
4
5
6
7
8
9
Nero (Black)
Marrone (Brown)
Rosso (Red)
Arancio (Orange)
Giallo (Yellow)
Verde (Green)
Blu (Blue)
Viola (Violet)
Grigio (Gray)
Bianco (White)
Tolerance
Valore di
Code
Tolleranza
First
Digit
Number
of Zeros
Prima
cifra
|
Seconda
cifra
Numero di zeri
Second Digit
Tolerance Code = Valore di tolleranza
Oro
(gold) 5%
Argento (silver) 10%
Nessuna striscia 20%
Figura 2-3
Codice dei
Colori per le
Resistenze
Ecco un esempio che mostra come usare la Tabella 2-1 e la Figura 2-3 per descrivere un
valore di resistenza che prova che giallo-viola-marrome è davvero 470 Ω:



La prima striscia è gialla, il ché significa che la cifra più a sinistra è un 4.
La seconda striscia è viola, il ché significa che la successiva cifra è un 7.
La terza striscia è marrone. Poiché marrone è 1, ciò significa aggiungere uno
zero a destra delle prime due cifre.
Giallo-Viola-Marrone = 4-7-0 = 470 Ω.
Introduzione del LED
Un diodo è una valvola con corrente in un solo senso, e un diodo emettitore di luce
(LED) emette luce quando la corrente lo attraversa. A differenza dei codici di colore su
una resistenza, il colore del LED di solito ci dice di quale colore si illuminerà quando la
corrente lo attraverserà. I contrassegni importanti di un LED sono contenuti nella sua
forma. Poiché è una valvola elettronica ad un solo senso, accertatevi di connetterlo al
vostro circuito nel modo corretto oppure non lavorerà nel modo che volevate.
La Figura 2-4 mostra il simbolo schematico e il disegno di parte di un LED. Un LED ha
due terminali. Uno è detto anodo, e l’altro catodo. In questa attività, dovrete costruire un
circuito che incorpori il LED, assicurandovi con attenzione che i conduttori collegati
all’anodo e al catodo siano connessi al circuito in modo corretto. Sul disegno di parte, il
conduttore dell’anodo è contrassegnato col segno più (+). Sul simbolo schematico,
l’anodo è la parte larga del triangolo. Nel disegno di parte, il condutttore del catodo è il
piedino non contrassegnato, e sul simbolo schematico, il catodo è la linea che esce dalla
punta del triangolo.
Figura 2-4
Disegno di Parte e simbolo
schematico di un LED
Disegno di Parte (sopra) e simbolo
schematico (sotto).
Il disegno di parte del LED nelle
ultime immagini avrà un segno + in
prossimità della gamba dell’anodo.
+
LED
Quando iniziate ad assemblare il vostro circuito, assicuratevi di controllare il simbolo
schematico e il disegno di parte. Per il disegno di parte, notate che i conduttori del LED
hanno lunghezze diverse. Il più lungo è connesso all’anodo del LED, e il più corto è
connesso al suo catodo. Inoltre, se osservate da vicino l’involucro plastico del LED, esso
è rotondo, ma ha una piccolo sporgenza piatta vicino al conduttore più corto, per dire che
è il catodo. Questo risulta comodo quando i fili vengono tagliati alla stessa lunghezza.
Parti del circuito di prova del LED
(1) LED – Verde
(1) Resistenza – 470 Ω (giallo-viola-marrone)
Identificazione delle parti: In aggiunta ai disegni di parte nella Figura 2-2 e nella Figura
2-4, potete utilizzare le foto nell’ultima pagina del libro per identificare le parti del kit
necessarie per questa attività e per tutte le altre.
Assemblaggio del circuito di prova del LED
Costruirete un circuito inserendo i fili del LED e della resistenza in piccoli fori detti
zoccoli sull’area per i prototipi mostrata in Figura 2-5. Quest‘area per i prototipi ha
zoccoli neri lungo la parte superiore e il lato sinistro. Quelli lungo la parte superiore
hanno etichette sopra di essi: Vdd (+5 V), Vin (la tensione non regolata proveniente
direttamente dalla batteria o dall’alimentatore), e Vss (0 V, chiamata anche terra o
massa). Questi zoccoli sono detti terminali a tensione, e saranno usati per alimentare i
vostri circuiti con elettricità. Gli zoccoli neri sul lato sinistro hanno etichette come P0,
P1, fino a P15. Potrete usare questi zoccoli per connettere il vostro circuito a piedini di
ingresso/uscita del modulo BASIC Stamp.
Vdd
Vin
Vss
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Figura 2-5
Area per i prototipi
Terminali a tensione (zoccoli neri
lungo la parte superiore), piedini I/O
di accesso (zoccoli neri lungo il lato),
e schedina senza saldature o
breadboard (zoccoli bianchi)
I piedini di Ingresso/uscita sono chiamati di solito piedini (pin) I/O, e dopo aver connesso il
vostro circuito ad uno o più di questi piedini I/O, potete programmare il vostro BASIC Stamp
per controllare il circuito (ingresso o input) oppure inviare segnali acceso o spento al circuito
(uscita o output). Potrete provare questo nella prossima attività.
La tavoletta bianca con molti fori è detta breadboard senza saldature. Userete la
breadboard per connettere componenti tra loro e costruire circuiti. La breadboard ha 17
righe di zoccoli. In ciascuna riga ci sono due gruppi da cinque zoccoli, separati da un
solco nel mezzo. Tutti gli zoccoli di un gruppo sono collegati assieme. Quindi, se infilate
due fili nello stesso gruppo di 5 zoccoli, essi saranno in contatto elettrico. Due fili nella
stessa riga ma su lati opposti rispetto al solco centrale non saranno collegati. Molti
dispositivi sono progettati per essere connessi sopra questo solco, come il pulsante che
useremo nel Capitolo 3.
Unteriori notizie sul breadboarding: Per imparare la storia delle breaboard, come sono
costruite le breadboard moderne, e come usarle, vedere le risorse video al sito
www.parallax.com/go/WAM.
La Figura 2-6 mostra lo schema di un circuito, e una figura di come apparirà quel circuito
se costruito nell’area prototipi. Ciascun gruppo di 5 zoccoli può collegare fino a 5 fili, o
conduttori, l’uno all’altro. Per questo circuito, la resistenza e il LED sono connessi
perché ciascuno ha un filo connesso allo stesso gruppo di 5 zoccoli. Notare che un filo
della resistenza è connesso a Vdd (+5 V) cosicché il circuito può assorbire potenza
elettrica. L’altro filo è connesso al filo dell’anodo del LED. Il filo del catodo del LED è
connesso a Vss (0 V, terra) e completa il circuito.
Siete ora pronti a montare il circuito mostrato in Figura 2-6 (sotto) connettendo i fili del
LED e della resistenza entro gli zoccoli dell’area prototipi. Seguite questi passi:
 Scollegate energia dalla vostra Board of Education o dalla HomeWork Board.
 Usate la Figura 2-4 per decidere quale filo è connesso al catodo del LED.
Cercate il filo più corto e la sporgenza piatta sulla parte plastica del LED.
 Connettete il catodo del LED ad uno degli zoccoli neri etichettati Vss nell’area
prototipi.
 Collegate l’anodo del LED (l’altro filo, più lungo) allo zoccolo indicato sulla
porzione breadboard dell’area prototipi.
 Collegate uno dei fili della resistenza allo stesso gruppo di 5 zoccoli dell’anodo
del LED. Così questi due fili saranno interconnessi.
 Collegate l’altro filo della resistenza ad uno degli zoccoli contrassegnati Vdd.
La direzione è importante per il LED, non per la resistenza. Se collegate il LED al
rovescio, il LED non emetterà alcuna luce quando date energia. La resistenza resiste
soltanto al flusso di corrente. Non c’è verso avanti o indietro per una resistenza.
 Ricollegate energia alla vostra Board of Education o alla HomeWork Board.
 Controllate che il vostro LED verde emetta luce. Dovrebbe risplendere di verde.
Vdd
Vdd
X3
470 
LED
Vss
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vin
Vss
+
Figura 2-6
LED acceso, cablato direttamente a
tensione
Schema del circuito (a sinistra) e
diagramma di cablaggio (a destra).
Notare che uno dei fili della
resistenza e iI filo dell’anodo del
LED verde sono connessi allo
stesso gruppo di 5 zoccoli. I due
componenti risultano quindi
connessi elettricamente.
Se il vostro LED verde non emette luce quando collegate la scheda a tensione:
 Alcuni LED sono più brillanti se visti dall’alto. Tentate di osservare direttamente
dal di sopra la cupola dell’involucro plastico del LED.
 Se la stanza è illuminata, provate a spegnere alcune luci, oppure fate ombra sul
LED con le vostre mani.
Se nn vedete ancora alcuna luce verde, provate questi passi:
 Controllate due volte il circuito per accertarvi che il catodo e l’anodo del LED
siano connessi in modo corretto. Se non lo sono, rimuovete semplicemente il
LED, dategli mezzo giro e reinseritelo negli zoccoli. Il LED non si danneggia se
lo inserite al rovescio, semplicemente non emetterà luce. Quando lo avrete
connesso nel verso corretto, emetterà luce.
 Controllate due volte il circuito per accertarvi di avelo costruito esattamente
come mostra la Figura 2-6.
 Se state utilizzando un kit “What’s a Microcontroller” (Che cos’è un
microcontrollore) utilizzato da altre persone prima di voi, il LED può essere
stato danneggiato, quindi provatene un altro.
 Se siete in una classe di laboratorio, fate il controllo con il vostro istruttore.
Ancora bloccati? Provate queste risorse gratuite disponibili online:
Visitate i forum moderati Stamps In Class: Se non avete un istruttore o un amico che vi
può aiutare, potete sempre servirvi del forum Stamps in Class al sito
http://forums.parallax.com. Se non ottenete risposta alla vostra domanda sul sito, potete
contattare il supporto tecnico Parallax (Parallax Technical Support) seguendo il link di
supporto al sito www.parallax.com.
Come opera il circuito di prova del LED
I terminali Vdd e Vss forniscono pressione elettrica nello stesso modo in cui lo fa una
batteria. Gli zoccoli Vdd sono come il polo positivo di una batteria, e gli zoccoli Vss
sono come il polo negativo della batteria. La Figura 2-7 mostra come l’applicare la
pressione elettrica ad un circuito con una batteria provoca il flusso di elettroni attraverso
di esso. Questo flusso di elettroni è detto corrente elettrica, o più spesso soltanto
corrente. La corrente elettrica è limitata dalla resistenza. Questa corrente produce
l’emissione di luce del diodo.
+
N
-
-
+++
+++
+++
_
--- - -N
-N - N
-
-
-
N N
+
+
=
N
-
-
-
-
-
-
-
-
Figura 2-7
LED Acceso: Flusso di elettroni nel
circuito
I segni meno nei cerchietti mostrano
gli elettroni che fluiscono dal polo
negativo della batteria al suo polo
positivo.
-
Le reazioni chimiche entro la batteria forniscono la corrente al circuito. Il polo negativo
della batteria contiene un composto che ha molecole con un elettrone in più (mostrate in
Figura 2-7 da segni meno). Il polo positivo della batteria ha un composto chimico con
molecole alle quali manca un elettrone (mostrate da segni più). Quando un elettrone lascia
una molecola nel polo negativo e viaggia attraverso il filo, è detto elettrone libero (mostrato
anche dai segni meno). La molecola che perde questo elettrone in più non ha più una
carica negativa extra; ed è ora detta neutra (mostrata da una N). Quando un elettrone
raggiunge il polo positivo, si unisce ad una molecola cui mancava un elettrone, e ora la
molecola è anch’essa neutra.
La Figura 2-8 mostra il flusso di elettricità che attraversa il LED utilizzando la notazione
dello schema circuitale. La pressione elettrica attraverso il circuito è chiamata voltaggio
(o tensione). Per mostrare il voltaggio applicato ad un circuito sono usati i segni + e – .
La freccia mostra la corrente che fluisce attraverso il circuito. Questa freccia è quasi
sempre mostrata puntare nella direzione opposta al flusso reale degli elettroni.
Beniamino Franklin è stato accusato di non essere stato attento agli elettroni quando ha
deciso di rappresentare il flusso di corrente come carica che passa dal terminale positivo
di un circuito a quello negativo. Al momento in cui i fisici scoprirono la vera natura della
corrente, la convenzione era già stata ben stabilita.
Voltaggio
Voltaggio
Voltage
+
Vdd
Resistance
Resistenza
Corrente
Current
LED
Voltaggio
Voltage
Voltaggio
-
Vss
Figura 2-8
Schema circuitale LED-Acceso che
mostra il flusso di corrente e il
voltaggio convenzionali
I segni + e – mostrano il voltaggio
applicato al circuito, e la freccia
mostra il flusso di corrente che
attraversa il circuito.
Un disegno schematico (simile alla Figura 2-8) è una imagine che spiega come uno o più
circuiti sono connessi tra loro. i disegni schematici (o schemi di circuito) sono usati dagli
studenti, dagli hobbisti di elettronica, dagli elettricisti, dagli ingegneri, e di solito da chiunque
lavori con circuiti.
: Aggiunte su elettricità contiene alcuni termini di glossario e una attività dalla quale potete
acquisire maggior familiarità con le misure di tensione (o voltaggio), corrente e resistenza.
Il vostro turno – Modifica del circuito di prova del LED
Nella prossima attività, programmerete il BASIC Stamp per accendere il LED, poi
spegnerlo, poi accenderlo di nuovo. Il BASIC Stamp farà questo commutando il circuito
del LED posto tra due connessioni differenti, Vdd e Vss. Il vostro lavoro con il circuito
sarà finito quando la resistenza è stata connessa a Vdd, e il LED emette luce. Fate i
cambiamenti mostrati in Figura 2-9 per verificare che il LED si spegnerà (non emette
luce) quando il filo della resistenza viene scollegato da Vdd e connesso a Vss.
 Scollegate energia dalla vostra Board of Education o HomeWork Board.
 Disinnestate il filo della resistenza innestato nello zoccolo Vdd, e connettetelo ad
uno zoccolo etichettato Vss come mostrato in Figura 2-9.
 Ricollegate energia alla vostra Board of Education o HomeWork Board.
 Controllate che il vostro LED verde non stia emettendo luce. Non deve splendere
di luce verde.
Perché il LED non si illumina? Poiché entrambe le estremità del circuito sono connesse
allo stesso voltaggio (Vss), non c’è alcuna pressione elettrica attraverso il circuito. Quindi,
nessuna corrente fluisce nel circuito, e il LED rimane spento.
Vdd
X3
470 
Vss
LED
Vss
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vin
Vss
+
Figura 2-9
Circuito con LED spento
Schema (a sinistra) e
diagramma di cablaggio
(a destra).
ATTIVITÀ #2: CONTROLLO ACCESO/SPENTO CON IL BASIC STAMP
Nell’attività #1, sono stati costruiti e provati due diversi circuiti. Un circuito faceva
emettere luce al LED, l’altro no. La Figura 2-10 mostra come il BASIC Stamp può fare
la stessa cosa se connettete un circuito LED ad uno dei suoi piedini (pin) di I/O. In questa
attività, connetterete il circuito del LED al BASIC Stamp e programmerete che accenda e
spenga il LED. Esperimenterete anche programmi che fanno sì che il BASIC Stamp
faccia questo a velocità diverse.
SOUT
1
SIN
2
ATN
3
VSS
4
P0
5
P1
6
BS2
Vdd
Vss
24
VIN
23
VSS
SIN
2
22
SOUT
1
RES
ATN
3
21
VDD (+5V)
VSS
4
20
P15
P0
5
19
P14
P1
6
BS2
Vdd
Vss
24
VIN
23
VSS
22
RES
21
VDD (+5V)
20
P15
19
P14
P2
7
18
P13
P2
7
18
P13
P3
8
17
P12
P3
8
17
P12
P4
9
16
P11
P4
9
16
P11
P5
10
15
P10
P5
10
15
P10
P6
11
14
P9
P6
11
14
P9
P7
12
13
P8
P7
12
13
P8
BS2-IC
BS2-IC
Figura 2-10
Commutazione
del BASIC
Stamp
Il BASIC Stamp
può essere
programmato
per connettere
internamente
l’ingresso del
circuito LED a
Vdd o Vss.
Ci sono due grosse differenze tra cambiare la connessione manualmente e far fare questo
al BASIC Stamp. La prima: il BASIC Stamp non deve togliere tensione alla scheda di
sviluppo quando cambia l’alimentazione del circuito LED da Vdd a Vss. La seconda:
mentre un uomo può effettuare questo cambiamento molte volte al minuto, il BASIC
Stamp può far questo migliaia di volte al secondo!
Parti del circuito di prova del LED
Le stesse dell’attività #1.
Connettere il circuito del LED al BASIC Stamp
Il circuito del LED mostrato in Figura 2-11 è cablato in modo quasi identico al circuito
dell’esercizio precedente. La differenza è che il filo della resistenza che è stato
commutato manualmente tra Vdd e Vss, è ora connesso ad un pin I/O del BASIC Stamp.
 Scollegate energia dalla vostra Board of Education o dalla HomeWork Board.
 Modificate il circuito col quale stavate lavorando nell’attività #1 in modo che
corrisponda alla Figura 2-11.
Vdd
P14
Vin
X3
470 
LED
Vss
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vss
+
Figura 2-11
Circuito del LED
controllato da BASIC
Stamp
L’ingresso del circuito
del LED è ora
connesso ad un pin
I/O di un BASIC
Stamp invece che a
Vdd o Vss.
Le resistenze sono essenziali. Ricordare sempre di usare una resistenza. Senza di essa,
nel circuito fluirebbe troppa corrente, ed essa potrebbe danneggiare più parti del vostro
circuito, o del BASIC Stamp, o della Board of Education o HomeWork Board.
Accendere e spegnere il LED con un programma
Il programma esempio fa lampeggiare il LED – acceso e spento – una volta per secondo.
Esso inoltre introduce molte nuove tecniche di programmazione. Dopo averlo eseguito,
farete esperimenti con diverse parti del programma per comprendere meglio come lavora.
Programma esempio: LedAccesoSpento.bs2





Digitare il codice di LedAccesoSpento.bs2 nell’Editor del BASIC Stamp.
Ricollegare energia alla vostra Board of Education o HomeWork Board.
Eseguire il programma.
Verificare che il LED lampeggi acceso e spento una volta per secondo.
Scollegare energia quando avete finito di usare il programma.
'Che cos’è un microcontrollore - LedAccesoSpento.bs2
'Accende e spegne un LED. Ripete 1 volta per secondo indefinitamente.
'{$STAMP BS2}
'{$PBASIC 2.5}
DEBUG "Il LED connesso a P14 sta lampeggiando!"
DO
HIGH 14
PAUSE 500
LOW 14
PAUSE 500
LOOP
Come lavora LedAccesoSpento.bs2
Il comando (o istruzione) DEBUG "Il LED connesso a P14 sta lampeggiando!" fa
apparire questa frase nel terminale di Debug. Il comando HIGH 14 fa in modo che il
BASIC Stamp colleghi internamente il pin I/O P14 a Vdd. Questo accende il LED.
Il comando PAUSE 500 fa in modo che il BASIC Stamp non faccia niente per ½ secondo
mentre il LED rimane acceso. Il numero 500 dice al comando PAUSE di attendere per
500/1000 di un secondo. Il numero che segue PAUSE è chiamato argomento. Gli
argomenti danno ai comandi PBASIC l’informazione che occorre per eseguire il
comando. Se cercate PAUSE nel Manuale BASIC Stamp, scoprirete che questo numero è
detto argomento Duration (Durata). Il nome Duration per questo argomento è stato scelto
per dire che il comando PAUSE fa una pausa di una certa “durata” di tempo, in
millisecondi.
Che cos’è un millisecondo? Un millisecondo è 1/1000 di un secondo. Si abbrevia con ms.
Occorrono 1000 ms per uguagliare un secondo.
Il comando LOW 14 fa in modo che il BASIC Stamp colleghi internamente il pin I/O P14
a Vss. Questo spegne il LED. Poiché LOW 14 è seguito da un altro comando PAUSE
500, il LED rimane spento per mezzo secondo.
La ragione per cui il codice si ripete di nuovo indefinitamente è il fatto che è annidato tra
le parole chiave PBASIC DO e LOOP. La Figura 2-12 mostra come lavora un ciclo
DO…LOOP. Ponendo il segmento di codice che accende e spegne il LED con le pause, tra i
comandi DO e LOOP, si dice al BASIC Stamp di eseguire questi quattro comandi di nuovo,
indefinitamente. Il risultato è che il LED lampeggia acceso e spento, di nuovo
indefinitamente. Il LED si mantiene lampeggiante finché scollegate l’energia, o premete
e tenete premuto il pulsante Reset, o finché la batteria si scarica. Il codice che ripete
indefinitamente un insieme di comandi si chiama ciclo infinito (infinite loop).
DO
HIGH 14
PAUSE 250
LOW 14
PAUSE 250
Figura 2-12
DO…LOOP
Il codice tra le parole chiave DO e
LOOP viene eseguito ripetutamente
senza fine.
LOOP
Un test diagnostico per il vostro computer
Sebbene non sia frequente, ci sono alcuni computer, come alcuni laptop e stazioni di
aggancio, che arrestano un programma PBASIC dopo la prima volta che il programma
esegue un ciclo DO...LOOP. Questi computer hanno porte seriali di progetto non
standard. Ponendo un comando DEBUG nel programma LedAccesoSpento.bs2, il terminale
di Debug resta aperto ed evita che si verifichi quesrto comportamento. Rieseguirete
questo programma senza il comando DEBUG per vedere se il vostro computer ha il
problema di porta seriale non standard. Non è probabile, ma è importante che lo sappiate.
 Aprite LedAccesoSpento.bs2.
 Cancellate completamente il comando DEBUG.
 Eseguite il programma modificato mentre osservate il vostro LED.
Se il LED lampeggia continuamente acceso e spento, come faceva quando eseguivate il
programma originario con il comando DEBUG, il vostro computer non ha questo problema.
Se il LED lampeggia acceso e spento una sola volta e quindi smette di lampeggiare, avete
un computer con una porta seriale di progetto non standard. Se scollegate il cavo seriale
dalla vostra scheda e premete il pulsante Reset, il BASIC Stamp eseguirà il programma
correttamente senza congelarsi. In programmi scritti da voi, vi occorrerà sempre
aggiungere un singolo comando DEBUG, come ad esempio questo:
DEBUG "Programma in esecuzione!"
…proprio dopo le direttive al compilatore. Questo comando aprirà il terminale di Debug
e manterrà aperta la porta COM. Ciò eviterà il congelamento dei vostri programmi dopo
la prima esecuzione di un ciclo DO...LOOP, oppure dopo un qualsiasi altro comando di
ciclo, che imparerete negli ultimi capitoli. Vedrete questi comandi in alcuni dei
programmi esempio che altrimenti non avrebbero alcun bisogno di una istruzione DEBUG.
Quindi, dovreste riuscire ad eseguire tutti i programmi rimanenti di questo libro perfino
se il vostro computer fallisse il test diagnostico, ma in quel caso accertatevi di aggiungere
un breve comando DEBUG quando iniziate a scrivere programmi progettati e scritti da voi.
Il vostro turno – Temporizzazione e ripetizioni
Modificando l’argomento Duration del comando PAUSE potete modificare la quantità di
tempo in cui il LED resta acceso e spento. Per esempio, cambiando entrambi gli
argomenti Duration in 250, provochereste il lampeggiamento acceso – spento del LED
due volte per secondo. Il ciclo DO…LOOP nel vostro programma apparirebbe ora così:
DO
HIGH 14
PAUSE 250
LOW 14
PAUSE 250
LOOP
 Aprite
LedAccesoSpento.bs2
e
salvatene
una
copia
come
LedAccesoSpentoVostroTurno.bs2.
 Cambiate gli argomenti Duration di entrambi i comandi PAUSE da 500 a 250, e
rieseguite il programma.
Se volete far lampeggiare il LED acceso e spento una volta ogni tre secondi, col tempo di
spento due volte più lungo del tempo di acceso, potrete modificare il comando PAUSE
dopo il comando HIGH 14 in modo che impieghi un secondo utilizzando PAUSE 1000. Il
comando PAUSE dopo il comando LOW 14 dovrà essere PAUSE 2000.
DO
HIGH 14
PAUSE 1000
LOW 14
PAUSE 2000
LOOP
 Modificate e rieseguite il programma usando il frammento di codice qui sopra.
Un esperimento divertente è vedere quanto brevi potrete fare le pause e vedere ancora che
il LED stia lampeggiando. Quando il LED sta lampeggiando molto rapidamente, ma
appare come se fosse sempre acceso, si ha ciò che si chiama persistenza della visione.
Ecco come provare per vedere qual’è la vostra soglia di persistenza della visione:
 Provate a modificare entrambi gli argomenti Duration dei vostri comandi PAUSE
in modo che siano 100.
 Rieseguite il vostro programma e controllate il lampeggiamento.
 Riducete entrambi gli argomenti Duration a 5 e provate di nuovo.
 Tentate di ridurre gli argomenti Duration fin quando il LED appare sempre
acceso senza lampeggiamento. Sarà meno luminoso del normale, ma dovrebbe
apparire non lampeggiante.
Un’ultima cosa da provare è creare un LED con un solo lampeggiamento. Quando il
programma è eseguito, il LED lampeggia una sola volta. Questo è un modo per osservare
la funzionalità del ciclo DO…LOOP. Potete rimuovere temporaneamente dal programma il
ciclo DO…LOOP ponendo un apostrofo a sinistra di entrambe le parole chiave DO e LOOP
come mostrato qui sotto.
' DO
HIGH 14
PAUSE 1000
LOW 14
PAUSE 2000
' LOOP
 Modificate e rieseguite il programma usando il frammento di codice qui sopra.
 Spiegate cosa è accaduto, perché il LED aveva lampeggiato una sola volta?
Commentare una riga di codice: Porre un apostrofo a sinistra di un comando cambia il
comando stesso in un commento. Il commento è uno strumento molto utile poiché, per
vedere cosa accade quando togliete l’istruzione dal programma, non dovrete cancellarla
davvero. È molto più facile aggiungere e rimuovere un apostrofo che cancellare e ridigitare
le istruzioni.
ATTIVITÀ #3: CONTEGGIO E RIPETIZIONE
Nell’attività precedente, il circuito del LED lampeggiava acceso - spento indefinitamente,
oppure lampeggiava una sola volta e poi si fermava. Come fare se volete che lampeggi
acceso – spento dieci volte? I computer (incluso il BASIC Stamp) sono grandi nel
mantenere i totali dinamici di quante volte accade un certo evento. I computer possono
essere programmati anche per prendere decisioni basate su molte condizioni. In questa
attività, programmerete il BASIC Stamp perché smetta di far lampeggiare il LED acceso
– spento dopo dieci ripetizioni.
Parti del conteggio e circuito di prova
Usate il circuito di esempio mostrato in Figura 2-11 a pagina 41.
Quante volte?
Esistono molti modi per far lampeggiare il LED acceso – spento dieci volte. Il modo più
semplice è quello di usare un ciclo FOR...NEXT. FOR...NEXT è simile al ciclo
DO...LOOP. Sebbene entrambi i cicli possano essere usati per ripetere comandi un
numero fisso di volte, il ciclo FOR...NEXT è di uso più facile. È chiamato spesso ciclo
contato o finito.
Il ciclo FOR...NEXT dipende da una variabile che tiene traccia di quante volte il LED ha
lampeggiato acceso – spento. Una variabile è una parola di vostra scelta, utilizzata per
memorizzare un valore. Il programma esempio che segue sceglie la parola contatore
per “contare” quante volte il LED è stao acceso - spento.
Scegliere parole come nomi di variabile è cosa soggetta a molte regole:
1.
Il nome non può essere una parola che sia già stata utilizzata dal PBASIC. Queste
parole sono chiamate parole riservate, e alcuni esempi con cui dovreste esservi già
familiarizzati sono DEBUG, PAUSE, HIGH, LOW, DO, e LOOP. Potete consultare
l’elenco completo delle Parole Riservate nel Manuale BASIC Stamp.
2.
Il nome non può contenere uno spazio.
3.
Anche se il nome può contenere lettere, numeri, o sottolineature, deve cominciare
obbligatoriamente con una lettera.
4.
Il nome deve essere lungo meno di 33 caratteri.
Programma esempio: LedAccesoSpentoDieciVolte.bs2
Il programma LedAccesoSpentoDieciVolte.bs2 mostra come si usa un ciclo FOR...NEXT
per far lampeggiare un LED acceso – spento dieci volte.
 Dovreste costruire (o ricostruire) il vostro circuito di prova dalla attività #2 e
prepararvi ad usarlo.
 Digitate il codice di LedAccesoSpentoDieciVolte.bs2 nell’editor del BASIC
Stamp.
 Collegate corrente elettrica alla vostra Board of Education o HomeWork Board.
 Eseguite il programma.
 Verificate che il LED lampeggia acceso – spento dieci volte.
 Eseguite il programma una seconda volta, e verificate che il valore di
contatore mostrato nel terminale di Debug conteggia con precisione quante
volte il LED ha lampeggiato. Suggerimento: invece di cliccare Run una seconda
volta, potete premere e rilasciare il pulsante Reset sulla vostra Board of
Education o HomeWork Board.
' Che cosa è un microcontrollore - LedAccesoSpentoDieciVolte.bs2
' Accende e spegne un LED. Ripete 10 volte.
' {$STAMP BS2}
' {$PBASIC 2.5}
contatore VAR Byte
FOR contatore = 1 TO 10
DEBUG ? contatore
HIGH 14
PAUSE 500
LOW 14
PAUSE 500
NEXT
DEBUG "Tutto fatto!"
END
Come funziona LedAccesoSpentoDieciVolte.bs2
Questa istruzione PBASIC:
contatore VAR Byte
…dice all’editor del BASIC Stamp che il programma userà la parola contatore come
variabile che può memorizzare una informazione del valore di un byte.
Che cos’è un Byte? Un byte è una memoria sufficiente a memorizzare un numero
compreso tra 0 e 255. Il BASIC Stamp ha quattro tipi diversi di variabili, e ciascuna può
memorizzare una gamma diversa di numeri:
Tavola 2-2: Tipi di variabili e valori che possono
memorizzare
Tipo di variabile
Gamma di valori
Bit
Nib
Byte
Word
Da 0 a 1
Da 0 a 15
Da 0 a 255
Da 0 a 65535
Una istruzione DEBUG può includere formattatori che determinano quanta informazione
si deve visualizzare nel terminale di Debug. Ponendo il formattatore punto interrogativo
“?” prima di una variabile in una istruzione (comando) DEBUG si dice al terminale di
Debug di visualizzare nome della variabile e valore. Questo è il motivo per cui il
comando:
DEBUG ? contatore
…visualizza nel terminale di Debug tanto il nome che il valore della variabile
contatore.
Il ciclo FOR...NEXT e tutti i comandi interni ad esso (compresi tra la parola FOR e la
parola NEXT) sono mostrati qui sotto. L’istruzione FOR contatore = 1 to 10 dice al
BASIC Stamp che deve impostare la variabile contatore ad 1, quindi mantenere in
esecuzione i comandi fin quando raggiunge l’istruzione NEXT. Quando il BASIC Stamp
giunge alla istruzione NEXT, salta indietro alla istruzione FOR. L’istruzione FOR aggiunge
uno al valore di contatore. Quindi, controlla se contatore è ancora maggiore di dieci.
Se non lo è, ripete la procedura. Quando il valore di contatore raggiunge finalmente
undici, il programma salta i comandi tra l’istruzione FOR e la NEXT e si muove sul
comando che viene dopo l’istruzione NEXT.
FOR contatore = 1 to 10
DEBUG ? contatore
HIGH 14
PAUSE 500
LOW 14
PAUSE 500
NEXT
Il commando che segue l’istruzione NEXT è:
DEBUG "Tutto fatto!"
Questo commando è stato incluso solo per mostrare cosa fa il programma dopo le dieci
volte che ha eseguito il ciclo FOR...NEXT. Si muove sul comando seguente l’istruzione
NEXT.
Il vostro turno – Altri modi per contare
 Nel programma LedAccesoSpentoDieciVolte.bs2, sostituite l’istruzione:
con questa:
 Rieseguite il programma. Che cosa fa di diverso ed era ciò che aspettavate?
 Provate una seconda modifica all’istruzione FOR. Questa volta, cambiatela in:
FOR contatore = 20 to 120 STEP 10
Quante volte il LED ha lampeggiato? Quali valori sono stati visualizzati nel terminale di
Debug?
ATTIVITÀ #4: COSTRUIRE E PROVARE UN SECONDO CIRCUITO LED
Gli indicatori a LED possono essere usati per dire all’utente di una macchina molte cose.
Molti dispositivi necessitano di due, tre, o più LED per dire all’utente se la macchina è
pronta o meno, se c’è un guasto, se un compito è stato eseguito, e così via.
In questa attività, ripeterete la prova del circuito LED fatta nell’Attività #1 per un
secondo circuito LED. Poi modificherete di conseguenza il programma esempio della
Attività #2 per assicurarvi che il circuito LED sia connesso al BASIC Stamp in modo
corretto. Poi modificherete il programma esempio dell‘Attività #2 per far funzionare i
LED in tandem.
Parti extra richieste
In aggiunta alle parti che avete usato nelle Attività 1 e 2, vi occorreranno queste parti:
(1) LED – giallo
(1) Resistenza – 470 Ω (giallo – viola – marrone)
Costruzione e prova del secondo circuito LED
Nell’Attività #1, avete provato manualmente il primo circuito LED per assicurarvi che
lavorasse, prima di connetterlo al BASIC Stamp. Prima di connettere il secondo circuito
LED al BASIC Stamp, è importante provare anche questo.




Scollegate energia dalla vostra Board of Education o HomeWork Board.
Costruite il secondo circuito LED come mostrato in Figura 2-13.
Ricollegate energia alla vostra Board of Education o HomeWork Board.
Il circuito LED che avete appena aggiunto si accendeva? Se si, allora continuate.
Se no, l’attività #1 ha alcuni suggerimenti di ricerca guasti che dovrete ripetere
per questo circuito.
Vdd
X3
Vdd
470 
P14
470 
LED
LED
Vss
Vss
Vin
+
Vss
+
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Figura 2-13
Circuito di prova
manuale per il
secondo LED
 Scollegate energia dalla vostra Board of Education o HomeWork Board.
 Modificate il secondo circuito LED che avete appena provato collegando il filo
della resistenza del circuito LED (input) a P15 come mostra la Figura 2-14.
Vdd
X3
P15
470 
P14
470 
LED
Vss
LED
Vss
Vin
+
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vss
+
Figura 2-14
Collegare il
secondo LED
al BASIC
Stamp
Schema (a
sinistra) e
diagramma di
cablaggio (a
destra).
Uso di un programma per provare il secondo circuito LED
Nell’attività #2, avete usato un programma esempio e le istruzioni HIGH e LOW per
controllare il circuito a LED collegato a P14. Queste istruzioni dovranno essere
modificate per controllare il circuito a LED collegato a P15. Invece di usare HIGH 14 e
LOW 14, userete HIGH 15 e LOW 15.
Programma esempio: ProvaSecondoLed.bs2




Digitate ProvaSecondoLed.bs2 nell’editor del BASIC Stamp.
Collegate energia alla vostra Board of Education o HomeWork Board.
Eseguite ProvaSecondoLED.bs2.
Accertatevi che il circuito LED collegato a P15 stia lampeggiando. Se il LED
collegato a P15 lampeggia, andate all’esempio successivo (Controllare entrambi
i LED). Se il circuito a LED collegato a P15 non lampeggia, controllate se il
circuito ha errori di cablaggio o se il programma ha errori di digitazione e
riprovate .
' Che cosa è un microcontrollore - ProvaSecondoLed.bs2
' Accende e spegne il LED collegato a P15.
' Ripete 1 volta per secondo indefinitamente.
' {$STAMP BS2}
' {$PBASIC 2.5}
DEBUG "Il programma è in esecuzione!"
DO
HIGH 15
PAUSE 500
LOW 15
PAUSE 500
LOOP
Controllo di entrambi i LEDs
Si, potrete far lampeggiare entrambi i LED contemporaneamente. Un modo per farlo è
usare due comandi HIGH prima del primo comando PAUSE. Un comando HIGH imposta
P14 al valore alto, e il successivo comando HIGH imposta P15 al valore alto. Potranno
anche occorrervi due comandi LOW per spegnere entrambi i LED. È vero che entrambi i
LED non si accenderanno e non si spegneranno esattamente allo stesso tempo poiché uno
è acceso o spento dopo l’altro. Comunque, non c’è più di un millisecondo di differenza
tra le due variazioni, e l’occhio umano non lo rileverà.
Programma esempio: LampeggiaEntrambiILed.bs2
 Digitare il codice di LampeggiaEntrambiILed.bs2 nell’editor del BASIC Stamp.
 Eseguire il programma.
 Verificare che entrambi i LED appaiono lampeggiare allo stesso tempo.
' Che cosa è un microcontrollore - LampeggiaEntrambiILed.bs2
' Accende e spegne i LED collegati a P14 e P15.
' {$STAMP BS2}
' {$PBASIC 2.5}
DO
HIGH 14
HIGH 15
PAUSE 500
LOW 14
LOW 15
PAUSE 500
LOOP
Il vostro turno – LED alternati
Potete alternare il funzionamento dei LEDs alternando i comandi HIGH e LOW che
controllano uno dei due pin I/O. Questo significa che mentre un LED è acceso, l’altro
sarà spento.
 Modificate LampeggiaEntrambiILed.bs2 in modo che i comandi tra le parole
chiave DO e LOOP appaiano così:
HIGH 14
LOW 15
PAUSE 500
LOW 14
HIGH 15
PAUSE 500
 Eseguire la versione modificata di LampeggiaEntrambiILed.bs2 e verificate che i
LED lampeggino alternativamente.
ATTIVITÀ #5: USO DELLA DIREZIONE DELLA CORRENTE PER
CONTROLLARE UN LED BICOLORE
Il dispositivo mostrato in Figura 2-15 è un monitor di sicurezza per tasti elettronici.
Quando viene utilizzato un tasto elettronico con il codice corretto, il LED cambia colore,
e si apre una porta. Questo tipo di LED si chiama LED bicolore. Questa attività
risponde a due domande:
1. Come fa il LED a cambiare colore?
2. Come potete usarne uno con il BASIC Stamp?
Figura 2-15
LED Bicolore in un
dispositivo di sicurezza
Quando la porta è
bloccata,questo LED
bicolore ha luce rossa.
Quando la porta è
sbloccata da un tasto
elettronico con il codice
corretto, il LED diventa
verde.
Introduzione al LED Bicolore
Il simbolo schematico e il disegno di parte per il LED bicolore sono mostrati nella Figura
2-16.
LED
bicolore
verde
Area
piatta
rosso
pin
lungo
Figura 2-16
LED Bicolore
Simbolo schematico (a
sinistra) e disegno di parte
(a destra).
Il LED bicolore è in realtà proprio costituito da due LED in un unico contenitore. La
Figura 2-17 mostra come potete applicare tensione in una direzione e il LED fa luce
verde. Scollegando il LED e reinserendolo in posizione inversa, il LED si illumina di
rosso. Come per gli altri LED, se collegate entrambi i terminali del circuito a Vss, il LED
non emetterà luce.
Figura 2-17
LED Bicolore e
tensione applicata
LED
verde
LED
rosso
Parti del circuito del LED bicolore
(1) LED – bicolore
(1) Cavallotto di filo
LED
spento
Verde (sinistra),
rosso (centro) e
nessuna luce
(destra)
Costruzione e prova del circuito del LED bicolore
La Figura 2-18 mostra la prova manuale per il LED bicolore.








Scollegate energia dalla vostra Board of Education o HomeWork Board.
Costruite il circuito mostrato nel lato sinistro della Figura 2-18.
Ricollegate energia e verificate che il LED bicolore emetta luce verde.
Scollegate ancora energia.
Modificate il vostro circuito come appare nel lato destro di Figura 2-18.
Ricollegate energia.
Verificate che il LED bicolore emetta ora luce rossa.
Scollegate energia.
Che succede se i colori del mio LED bicolore sono rovesciati? I LED bicolore sono
fabbricati come quello in Figura 2-16 ma anche con i colori rovesciati. Se il vostro LED
bicolore si illumina rosso quando è collegato nel circuito che dovrebbe farlo illuminare verde
e viceversa, i colori del vostro LED sono rovesciati. Se è così, collegate sempre il pin 1 nel
luogo dove i diagrammi mostrano il pin 2, e il pin 2 dove i diagrammi mostrano il pin 1.
Vdd
1 Vin 2
Vss
Vdd
X3
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
2 Vin 1
Vss
Figura 2-18
Prova manuale del LED
bicolore
LED bicolore verde
(sinistra) e rosso
(destra).
Controllare un LED bicolore con il BASIC Stamp richiede due pin I/O. Dopo aver
verificato manualmente che il LED bicolore lavora nella prova manuale, potete
connettere il circuito al BASIC Stamp come mostrato in Figura 2-19.
 Collegate il circuito del LED bicolore al BASIC Stamp come mostra la Figura
2-19.
Figura 2-19
LED bicolore collegato al
BASIC Stamp
Schema (sinistra) e
(destra).
Controllo di un LED bicolore con il BASIC Stamp
La Figura 2-20 mostra come potete usare P15 e P14 per controllare il flusso di corrente
nel circuito del LED bicolore. Lo schema superiore mostra come la corrente fluisce nel
LED verde quando P15 è impostato a Vdd con il comando HIGH e P14 è impostato a Vss
con il comando LOW. Questo avviene perché il LED verde lascerà che la corrente lo
attraversi quando la tensione elettrica è applicata al LED come mostrato, ma il LED rosso
agisce come una valvola chiusa e non fa passare la corrente. Il LED bicolore si illumina
di verde.
Lo schema inferiore mostra cosa accade quando P15 è impostato a Vss e P14 è impostato
a Vdd. La tensione elettrica è ora rovesciata. Il LED verde si chiude e non consente il
passaggio della corrente attraverso di esso. Nel frattempo, il LED rosso si accende, e la
corrente passa attraverso il circuito in direzione opposta.
HIGH = Vdd P15
1
Current
Corrente
Corrente
2
LOW = Vss P14

LOW = Vss P15
Figura 2-20
Prova del LED bicolore
con il BASIC Stamp
1
CorCurrent
rente
Corrente attraverso il
LED verde (superiore) e
il LED rosso (inferiore).
2
HIGH = Vdd P14

La Figura 2-20 mostra anche la chiave per programmare il BASIC Stamp in modo che
faccia illuminare il LED bicolore di due colori diversi. Lo schema superiore mostra
come far diventare verde il LED bicolore usando HIGH 15 e LOW 14. Lo schema
inferiore mostra come far diventare rosso il LED bicolore usando LOW 15 e HIGH 14.
Per spegnere il LED, inviate segnali bassi ad entrambi i pin P14 e P15 usando LOW 15 e
LOW 14. In altri termini, usate LOW su entrambi i pin.
Il LED bicolore si spegnerà anche se inviate segnali alti ad entrambi i pin P14 e P15.
Perché? Perché la tensione elettrica (voltaggio) è la stessa a P14 e P15 indipendentemente
dal fatto che voi impostiate entrambi i pin I/O alti o bassi.
Programma esempio: ProvaLEDBiColore.bs2
 Ricollegate energia.
 Digitate ed eseguite il codice ProvaLedBiColore.bs2 nell’editor del BASIC
Stamp.
 Verificate che il LED cicli tra gli stati rosso, verde, e spento.
' Che cosa è un microcontrollore - ProvaLedBiColore.bs2
' Accende in ciclo un LED bicolore rosso, poi verde, poi spento.
' {$STAMP BS2}
' {$PBASIC 2.5}
PAUSE 1000
DEBUG "Il programma è in esecuzione!", CR
DO
DEBUG "Verde..."
HIGH 15
LOW 14
PAUSE 1500
DEBUG "Rosso..."
LOW 15
HIGH 14
PAUSE 1500
DEBUG "Spento..", CR
LOW 15
LOW 14
PAUSE 1500
LOOP
Il vostro turno– Visualizzare le luci
Nell’attività #3, per controllare quante volte lampeggiava un LED era stata usata una
variabile chiamata contatore. Cosa accade se usate il valore di contatore per
controllare l’argomento Duration del comando PAUSE mentre il colore del LED bicolore
sta cambiando ripetitivamente?
 Rinominate
e
salvate
ProvaLEDBicolore.bs2
come
ProvaLEDBicoloreVostroTurno.bs2.
 Aggiungete una dichiarazione di variabile contatore prima dell’istruzione DO:
contatore VAR BYTE
 Sostituite il codice di prova nel ciclo DO...LOOP con questo ciclo FOR...NEXT.
HIGH 15
LOW 14
PAUSE contatore
LOW 15
HIGH 14
PAUSE contatore
NEXT
Quando avrete finito il vostro codice dovrebbe apparire così:
contatore VAR BYTE
DO
HIGH 15
LOW 14
PAUSE contatore
LOW 15
HIGH 14
PAUSE contatore
NEXT
LOOP
All’inizio di ciascun passo nel ciclo FOR...NEXT, il valore dentro PAUSE (argomento
Duration) è soltanto di un millisecondo.
Ogni volta che viene eseguito il ciclo
FOR...NEXT, il comando fa una pausa più lunga di un millisecondo per volta, fin quando
raggiunge 50 millisecondi. Il ciclo DO...LOOP fa eseguire il ciclo FOR...NEXT di nuovo
all’infinito.
 Eseguite il programma modificato ed osservate il suo effetto.
SOMMARIO
Il BASIC Stamp può essere programato per commutare un circuito con la luce indicatrice
di un diodo emettitore di luce (LED) accesa o spenta. Gli indicatori LED sono utili in
vari luoghi compresi molti monitor di computer, drive a disco, e altri dispositivi. Il LED
è stato descritto prima assieme ad una tecnica per identificare i suoi terminali anodo e
catodo. Un circuito a LED deve avere una resistenza per limitare la corrente che lo
attraversa. Le resistenze sono state presentate con uno degli schemi di codifica più
comuni per indicarne il loro valore (noto come codice dei colori, ndt).
Il BASIC Stamp commuta un circuito a LED acceso e spento collegando internamente un
suo pin I/O sia a Vdd, sia a Vss. Per far collegare internamente al BASIC Stamp uno dei
suoi pin I/O a Vdd si può usare un comando HIGH, e per far collegare un pin I/O a Vss
si può usare un comando LOW. Il comando PAUSE è usato per fare in modo che il BASIC
non esegua comandi per una certa quantità di tempo. Questo sistema è stato usato per far
stare i LED accesi o spenti per determinate quantità di tempo. La quantità di tempo è
determinata dal numero usato nell’argomento Duration del comando PAUSE.
Per creare un ciclo infinito possono essere usate le parole chiave DO...LOOP. I comandi
compresi tra le parole chiave DO e LOOP saranno eseguiti ripetutamente, all’infinito.
Anche se questo è detto ciclo infinito, il programma può ancora essere riavviato
scollegando e ricollegando energia, o premendo e rilasciando il pulsante Reset. Può
inoltre essere caricato entro il BASIC Stamp un nuovo programma, e ciò cancellerà il
programma con il ciclo infinito. Cicli di conteggio (con un determinato numero di
esecuzioni) possono essere fatti con FOR...NEXT, una variabile per tener conto di quante
ripetizioni il ciclo ha fatto, e numeri che specificano dove iniziare e terminare il
conteggio.
La direzione della corrente e la polarità del voltaggio sono stati introdotti usando un
LED bicolore. Se si applica un voltaggio ai capi di un circuito a LED, la corrente lo
attraverserà in una direzione, e il LED si illuminerà di un colore particolare. Se si
rovescia la polarità del voltaggio, la corrente viaggerà attraverso il circuito nella
direzione opposta ed esso si illumina di un colore diverso.
Domande
1. Qual’è il nome di questa lettera greca: , e a quale misura si riferisce ?
2. Quale resistenza permetterà di avere nel circuito una corrente maggiore, una
resistenza da 470  o una resistenza da 1000 ?
3. Come collegate due fili tra loro usando una breadboard? Potete usare una
breadboard per collegare tra loro quattro fili?
4. Cosa dovete fare sempre prima di modificare un circuito che avete costruito su
una breadboard?
5. Quanto a lungo dura un comando PAUSE 10000?
6. Come potete fare in modo che il BASIC Stamp non faccia nulla per un intero
minuto?
7. Quali sono i diversi tipi delle variabili?
8. Può un byte mantenere il valore 500?
9. Che cosa farà il comando HIGH 7?
Esercizi
1. Disegnate lo schema di un circuito a LED come quello sul quale avete lavorato
nell’attività #2, ma collegate il circuito a P13 invece di P14. Spiegate come
mofichereste LedAccesoSpento.bs2 a pagina 42 perché faccia lampeggiare il
vostro circuito a LED quattro volte al secondo.
2. Spiegate come modifichereste LedAccesoSpentoDieciVolte.bs2 perché faccia
lampeggiare il circuito a LED 5000 volte prima di fermarsi. Suggerimento:
dovrete modificare due sole righe di codice.
Progetto
1. Fate un conteggio da 10 secondi usando un LED giallo ed un LED bicolore.
Fate in modo che il LED bicolore inizi accendendosi di rosso per 3 secondi.
Dopo 3 secondi, cambiate il colore del LED bicolore a verde. Quando il LED
bicolore cambia in verde, fate lampeggiare il LED giallo acceso e spento una
volta al secondo per dieci secondi. Quando il LED giallo ha finito di
lampeggiare, il LED bicolore deve ritornare di color rosso e restare in tal modo.
Soluzioni
Q1. Omega si riferisce a ohm che misura quanto fortemente qualcosa resiste al
passaggio della corrente.
Q2. La resistenza da 470 Ω: valori più alti resistono di più dei valori più bassi,
perciò valori bassi permettono il fluire di una maggior corrente.
Q3. Per collegare 2 fili, inserite i 2 fili nello stesso gruppo di 5 zoccoli. Potete
collegare 4 fili inserendo tutti e 4 i fili nello stesso gruppo di 5 zoccoli.
Q4. Scollegate l’energia.
Q5. 10 secondi.
Q6. PAUSE 60000
Q7. Bit, Nib, Byte, e Word
Q8. No. Il valore più grande che un byte può contenere è 255. Il valore 500 è fuori
intervallo per un byte.
Q9. HIGH 7 farà sì che il BASIC Stamp colleghi internamente il pin I/O P7 a Vdd.
E1. La PAUSE Duration dev’essere ridotta a 500 ms / 4 = 125 ms. Per usare il pin I/O
P13, HIGH 14 e LOW 14 devono essere sostituiti con HIGH 13 e LOW 13.
P13
DO
HIGH 13
PAUSE 125
LOW 13
PAUSE 125
LOOP
470 
LED
Vss
E2. La variabile contatore dev’essere cambiata a dimensione Word, e l’istruzione
FOR dev’essere modificata per far contare da 1 a 5000.
contatore VAR Word
DEBUG ? contatore, CR
HIGH 14
PAUSE 500
LOW 14
PAUSE 500
NEXT
P1. Lo schema del LED bicolore, a sinistra, è invariato dalla Figura 2-19 a pagina
57. Lo schema del LED giallo si basa sulla Figura 2-11 a pagina 41. Per questo
progetto P14 è stato cambiato in P13, ed è stato usato un LED giallo invece di
quello verde. NOTATE: Quando il BASIC Stamp non esegue comandi, va in
una modalità a bassa energia che fa lampeggiare il LED bicolore brevemente
ogni 2,3 secondi. La stessa cosa avviene dopo che il programma ha eseguito un
comando END. C’è un altro comando chiamato STOP che potete aggiungere alla
fine del programma per fare sì che trattenga qualsiasi segnale alto/basso senza
entrare nel modo a bassa energia, e ciò a sua volta evita il lampeggiamento.
P13
470 
Yellow
LED
LED
giallo
Vss
' Che cosa è un microcontrollore - Cap02Pr01_Conteggio.bs2
' Conteggio di 10 secondi con LED Rosso, Giallo, Verde
' Rosso/Verde: LED bicolore in P15, P14. Giallo: P13
' {$STAMP BS2}
' {$PBASIC 2.5}
contatore VAR Byte
' Rosso per tre secondi
LOW 15
HIGH 14
PAUSE 3000
' Verde per 10 secondi...
HIGH 15
LOW 14
' LED bicolore Rosso
' LED bicolore Verde
' ...mentre il LED verde sta lampeggiando
HIGH 13
' LED giallo acceso
PAUSE 500
LOW 13
' LED giallo spento
PAUSE 500
NEXT
' Rosso resta acceso
LOW 15
HIGH 14
' LED Bi Colore Rosso
Capitolo 3: Ingresso Digitale – Pulsanti
LI TROVATE SU CALCOLATRICI, GIOCHI PALMARI ED ALTRE
APPLICAZIONI
Quati dispositivi a pulsanti utiizzate su base giornaliera? Ecco alcuni esempi che
potrebbero comparire sul vostro elenco: computer, mouse, calcolatrice, forno a
microonde, telecomando di TV, giochi palmari e telefoni cellulari. In ciascuno di questi
dispositivi, c’è un microcontrollore che esplora i pulsanti e aspetta per vedere se il
circuito cambia. Quando c’è una variazione di circuito, il microcontrollore rileva il
cambiamento e fa un’azione. Alla fine di questo capitolo, sarete diventati esperti nel
progetto di circuiti con pulsanti e nel programmare il BASIC Stamp perché li esplori e
compia azioni quando si verifica un cambiamento del loro stato.
RICEVERE O INVIARE SEGNALI ALTI E BASSI
Nel Capitolo 2, avete programmato il BASIC Stamp per inviare segnali alti e bassi, ed
avete utiizzato circuiti a LED per visualizzare questi segnali. Inviare segnali alti e bassi
sigifca che avete utilizzato un pin I/O del BASIC Stamp come sua uscita. In questo
capitolo, userete un pin I/O del BASIC Stamp come suo ingresso. Come ingresso, un pin
I/O ascolta se ci sono (aspetta l’arrivo di) segnali alti/bassi invece di inviarli. Invierete
questi segnali al BASIC Stamp usando un circuito con pulsante, e programmerete il
BASIC Stamp perché riconosca se il pulsante è premuto o no.
Altri sigificati di inviare, alto/basso, e ricevere: L’inviare segnali alto/basso può essere
descritto in diversi modi. Potrete intendere “inviare” nei significati di trasmettere, controllare,
o commutare. Invece di segnali alti/bassi, potreste trovare un riferimento a segnali binari,
TTL, CMOS, o Booleani. Un sinonimo di ricevere è sentire .
ATTIVITÀ #1: PROVA DI UN PULSANTE CON UN CIRCUITO A LED
Se potete usare un pulsante per inviare un segnale alto o basso al BASIC Stamp, potrete
anche controllare un LED con un pulsante? La risposta è si, e in questa attività lo
userete per provare un pulsante.
Introduzione del pulsante
La Figura 3-1 mostra il simbolo schematico e i disegni di parte di un pulsante, in
posizione di normalmente aperto. Due dei pin del pulsante sono collegati a ciascun
terminale. Ciò significa che collegare un filo o un terminale di parte al pin 1 del pulsante
è la stessa cosa che collegarlo al pin 4. La stessa regola vale per i pin 2 e 3. la ragione
per cui il pulsante non ha soltanto due pin è che gli occorre essere stabile. Se il pulsante
avesse soltanto due pin, questi pin potrebbero essere eventualente piegati o rotti per tutte
le pressioni che il pulsante riceve qundo le persone lo premono.
1, 4
2, 3
1
4
2
3
Figura 3-1
Pulsante normalmente aperto
Simbolo di schema (a sinistra) e
disegno di parte (a destra)
Il lato sinistro della Figura 3-2 mostra come appare un pulsante normalmente aperto
quando non è premuto. Quando il pulsante non è premuto, c’è una separazione tra i
terminali 1,4 e 2,3. Questa separazione fa in modo che il terminale 1,4 non possa
condurre corrente al terminale 2,3. Queta situazione è detta circuito aperto. Il termine
“normalmente aperto” sigifica che lo stato normale del pulsante (non premuto) forma un
circuito aperto. Quado il pulsante viene premuto, la separazione tra i terminali 1,4 e 2,3 è
scavalcata da una parte metallica conduttrice. Questa situazione è detta circuito chiuso, e
nel pulsante può fluire corrente.
1, 4
1, 4
2, 3
2, 3
Figura 3-2
Pusante normalmente aperto
Non premuto (a siistra) e premuto (a
destra)
Parti di prova per il pulsante
(1) LED – scegliete un colore
(1) Pulsante – normalmente aperto
Costruzione del circuito di prova del pulsante
La Figura 3-3 mostra un circuito che potete costruire per provare manualmente il
pulsante.
Scollegate sempre energia dalla vostra Board of Education o dalla BASIC Stamp
HomeWork Board prima di fare cambiamenti al vostro circuito di prova. Da qui in avanti, le
istruzioni non diranno più “Scollegate energia …” tra le varie modifiche del circuito. Sarà
vostra cura ricordarvi di farlo.
Ricollegate sempre energia alla vostra Board of Education o alla BASIC Stamp
HomeWork Board prima di scaricare un programmma sul BASIC Stamp.
 Costruite il circuito mostrato in Figura 3-3.
Vdd
Vdd
Vin
Vss
+
X3
1, 4
2, 3
470 
LED
Vss
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Figura 3-3
Circuito di prova del
pulsante
Prova del pulsante
Quando il pulsante non viene premuto, il LED sarà spento. Se il cablaggio è corretto,
quando il pulsante viene premuto, il LED dovrebbe accendersi (emettendo luce).
Segni di attenzione: Se il LED “Pwr” sulla Board of Education lampeggia, diventa meno
luminoso, o si spegne completamente quando ricollegate energia, può voler dire che c’è un
corto circuito da Vdd a Vss o da Vin a Vss. Se accade questo, scollegate energia
immediatamente e trovate e correggete l’errore nel vostro circuito.
Il LED incorporato nella HomeWork Board è diverso. Può essere contrassegnato
indifferentemente “Power” o “Running” e lampeggia soltanto mentre un programma è in
esecuzione. Se un programma termina, tanto se esegue una istruzione END quanto se
finisce di eseguire comandi, il LED si spegnerà.
 Verificate che il LED del vostro circuito sia spento.
 Premete e tenete premuto il pulsante, e verificate che il LED emetta luce mentre
tenete premuto il pulsante.
Come lavora il circuito del pulsante
Il lato sinistro della Figura 3-4 mostra che cosa accade quando il pulsante non è premuto.
Il circuito del LED non è collegato a Vdd. È un circuito aperto che non può condurre
corrente. Premendo il pulsante, come mostrato nel lato destro della figura, chiudete il
collegamento tra i terminali con metallo conduttivo. Ciò crea un sentiero per far fluire gli
elettroni attraverso il circuito e quindi, come risultato, il LED emette luce.
Vdd
Vdd
1, 4
1, 4
2, 3
2, 3
No
Current
470 
Figura 3-4
Pulsante non premuto e
premuto
470 
Current
LED
Vss
LED
Pulsante non premuto:
circuito aperto e luce
spenta (a sinistra)
Pulsante premuto:
circuito chiuso e luce
accesa (a destra)
Vss
Il vostro turno – Spegnere un LED con un pulsante
La Figura 3-5 mostra un circuito che produce un diverso comportamento del LED.
Quando il pulsante non è premuto, il LED resta acceso; quando il pulsante è premuto, il
LED si spegne. Poiché questo pulsante, quando è premuto, connette un conduttore tra i
terminali 1,4 e 2,3, ciò significa che l’elettricità sceglie la strada di minima resistenza
attraverso il pulsante invece di passare attraverso il LED. A differenza del potenziale di
corto circuito discusso nel riquadro Segni di Attenzione, il corto circuito che il pulsante
premuto crea tra i terminali del LED non danneggia alcun circuito e serve ad uno scopo
utile.
 Ripetete con questo nuovo circuito la prova che avete eseguito nel primo circuito
con pulsante che avete costruito.
Vdd
Vdd
1, 4
LED
2, 3
470 
Vss
Vin
Vss
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
+
Figura 3-5
LED che viene posto in
corto circuito dal pulsante
Potete realmente fare ciò con un LED? Fino a questo momento, il catodo del LED è stato
sempre collegato a Vss. Ora, il LED è in un posto diverso nel circuito, con il suo anodo
collegato a Vdd. Le persone chiedono spesso se questo rompe qualche regola di circuito, e
la risposta è no. La tensione elettrica fornita da Vdd e Vss è 5 volt. Il LED rosso userà
sempre circa 1.7 volt, e la resistenza userà i rimanenti 3.3 volt, indipendentemente dal loro
ordine.
ATTIVITÀ #2: LETTURA DI UN PULSANTE CON IL BASIC STAMP
In questa attività, collegherete un circuito con pulsante al BASIC Stamp e visualizzerete
se o meno il pulsante sia premuto. Farete questo scrivendo un programma PBASIC che
controlla lo stato del pulsante e lo visualizza nel terminale di Debug.
Parti del circuito con pulsante
(1) Resistenza – 220 Ω (rosso-rosso-marrone)
(1) Resistenza – 10 kΩ (marrone-nero-arancio)
(2) Cavallotti di filo
Costruire un circuito con pulsante per il BASIC Stamp
La Figura 3-6 mostra un circuito con pulsante collegato al pin I/O P3 del BASIC Stamp.
Vdd
X3
Vdd
P3
220 
10 k
Vss
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vin
Vss
Figura 3-6
Circuito con
pulsante collegato
al Pin I/O P3
Nel diagramma di
cablaggio,la
resistenza da
220 Ω è sul lato
sinistro e collega il
pulsante a P3
mentre la
resistenza da 10
kΩ e sulla destra,
e collega il circuito
del pulsante a
Vss.
La Figura 3-7 mostra che cosa vede il BASIC Stamp quando il pulsante viene premuto, e
quando non viene premuto. Quando il pulsante viene premuto, il BASIC Stamp sente che
Vdd è collegato a P3. Entro il BASIC Stamp, ciò produce il fatto di porre il numero 1 in
una parte della sua memoria che conserva informazioni sui suoi pin I/O. Quando il
pulsante non è premuto, il BASIC Stamp non può sentire Vdd, ma può sentire Vss
attraverso le resistenze da 10 kΩ e da 220 Ω. Ciò gli fa memorizzare il numero 0 in
quella stessa posizione di memoria che ha memorizzato un 1 quando il pulsante era stato
premuto.
Vdd
220 
10 k
SOUT
1
SIN
2
BS2
24
VIN
23
VSS
ATN
3
22
RES
VSS
4
21
VDD (+5V)
P0
5
20
P15
P1
6
19
P14
P2
7
P3
8
P4
9
P5
1
18
P13
17
P12
16
P11
10
15
P10
P6
11
14
P9
P7
12
13
P8
0
BS2-IC
Vss
Vdd
220 
10 k
24
VIN
23
VSS
22
RES
4
21
VDD (+5V)
P0
5
20
P15
P1
6
19
P14
P2
7
18
P13
P3
8
17
P12
SOUT
1
SIN
2
ATN
3
VSS
BS2
1
0
P4
9
16
P11
P5
10
15
P10
P6
11
14
P9
P7
12
13
P8
Figura 3-7
BASIC Stamp legge un
pulsante
Quando il pulsante è
premuto, il BASIC Stamp
legge un 1 (sopra). Quando
il pulsante non è premuto, il
BASIC Stamp legge uno 0
(sotto).
BS2-IC
Vss
Il Binario e i circuiti: Il sistema di numerazione in base-2 usa soltanto le cifre 1 e 0 per fare
i numeri, e questi valori binari possono essere trasmessi da un dispositivo ad un altro. Il
BASIC Stamp interpreta Vdd (5 V) come cifra binaria 1 e Vss (0 V) come cifra binaria 0.
Analogamente, quando il BASIC Stamp imposta un pin I/O a Vdd usando il comando HIGH,
invia un 1 binario. Quando imposta un pin I/O a Vss usando il comando LOW, invia uno 0
binario. Questo è un modo molto comune di comunicare numeri binari, usato da molti chip
di computer e da altri dispositivi.
Programmare il BASIC Stamp per sorvegliare il pulsante
Il BASIC Stamp memorizza l’uno o lo zero che sente sul pin I/O P3 in una posizione di
memoria chiamata IN3. Ecco un programma esempio che mostra come lavora questo
fatto:
Programma esempio: LeggiStatoPulsante.bs2
Il programma che segue fa controllare al BASIC Stamp il pulsante ogni ¼ di secondo e
invia il valore di IN3 al terminale di Debug.
La Figura 3-8 mostra il terminale di Debug mentre il programma è in esecuzione.
Quando il pulsante è premuto, il terminale di Debug visualizza il numero 1, e quando il
pulsante non è premuto, il terminale di Debug visualizza il numero 0.
Figura 3-8
Terminale di Debug che visualizza gli
stati di un pulsante
Il terminale di Debug visualizza 1
quando il pulsante è premuto e 0
quando non è premuto.
 Digitate il programma LeggiStatoPulsante.bs2 nell’Editor del BASIC Stamp.
 Eseguite il programma.
 Verificate che il terminale di Debug visualizzi il valore 0 quando il pulsante non
è premuto.
 Verificate che il terminale di Debug visualizzi il valore 1 quando il pulsante è
premuto e tenuto premuto.
' Che cosa è un microcontrollore - LeggiStatoPulsante.bs2
' Controlla e invia lo stato di un pulsante al terminale di Debug ogni 1/4
' secondo.
di
' {$STAMP BS2}
' {$PBASIC 2.5}
DO
DEBUG ? IN3
PAUSE 250
LOOP
Come lavora LeggiStatoPulsante.bs2
Il ciclo DO...LOOP nel programma si ripete ogni ¼ di secondo per la presenza del
comando PAUSE 250. Ogni volta che viene eseguito tramite il DO...LOOP, il comando
DEBUG ? IN3 invia il valore di IN3 al terminale di Debug. Il valore di IN3 è lo stato che
il pin I/O P3 sente al momento in cui viene eseguito il comando DEBUG.
Il vostro turno– Un pulsante con una resistenza di rinforzo
Il circuito con cui avete appena finito di lavorare ha una resistenza collegata a Vss.
Questa resistenza è chiamata resistenza di pull-down (indebolimento) perché essa abbassa
il voltaggio in P3 giù fino a Vss (0 volt) quando il pulsante non viene premuto. La Figura
3-9 mostra un circuito con pulsante che utilizza una resistenza di pull-up (rinforzo).
Questa resistenza tira su il voltaggio fino a Vdd (5 volt) quando il pulsante non viene
premuto. Le regole sono adesso rovesciate. Quando il pulsante non è premuto, IN3
memorizza il numero 1, e quando il pulsante è premuto, IN3 memorizza il numero 0.
La resistenza da 220  è usata nei circuiti esempio con pulsante per proteggere il pin I/O
del BASIC Stamp. Sebbene sia una buona pratica nel fare prototipi, in molti prodotti questa
resistenza è sostituita con un filo (per il fatto che i fili costano molto meno delle resistenze).
 Modificate il vostro circuito come mostrato in Figura 3-9.
 Rieseguite LeggiStatoPulsante.bs2.
 Usando il terminale di Debug, verificate che IN3 è 1 quando il pulsante non
viene premuto e 0 quando il pulsante è premuto.
Vdd
Vdd
10 k
P3
220 
Vss
Vin
Vss
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Figura 3-9
Circuito con pulsante
modificato
Attivo-basso e Attivo-alto: Il circuito del pulsante in Figura 3-9 è chiamato attivo-basso
perché invia al BASIC Stamp un segnale basso (Vss) quando il pulsante è attivo (premuto).
Il circuito del pulsante in Figura 3-6 è chiamato attivo-alto perché invia un segnale alto (Vdd)
quando il pulsante è attivo (premuto).
ATTIVITÀ #3: CONTROLLO A PULSANTE DI UN CIRCUITO A LED
La Figura 3-10 mostra una veduta a scala ingrandita di un pulsante e un LED usati per
regolare le impostazioni di un monitor per computer. Questo è soltanto uno dei tanti
dispositivi con un pulsante che potete premere per regolare il dispositivo e un LED che
mostra lo stato del dispositivo.
Figura 3-10
Pusante e LED su
un Monitor per
computer
Il BASIC Stamp può essere programmato per prendere decisioni in base a ciò che sente.
Per esempio, può essere programmato per decidere di far lampeggiare il LED
acceso/spento dieci volte al secondo quando il pulsant è premuto.
Parti del circuito pulsante e LED
(1) Pulsante – normalente aperto
(1) LED – di colore qualsiasi
Costruzione dei circuiti con pulsante e LED
La Figura 3-11 mostra il circuito a pulsante usato nell’attività che avete appena terminata
assieme al circuito a LED della Figura 2-11.
P14
470 
LED
Vdd
X3
Vss
Vdd
P3
220 
10 k
Vss
Vin
Vss
+
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Figura 3-11
Circuito con
pulsante e LED
Programmazione del controllo a pulsante
Il BASIC Stamp può essere programmato per prendere decisioni tramite una istruzioe
IF...THEN...ELSE. Il programma esempio che state per eseguire farà lampeggiare il
LED acceso/spento quando il pulsante viene premuto. In ciascuna esecuzione del ciclo
DO...LOOP, l’istruzione IF...THEN...ELSE controlla lo stato del pulsante e decide se il
LED debba lampeggiare o no.
Programma esempio: LedControllatoAPulsante.bs2
 Digitate LedControllatoAPulsante.bs2 nell’editor del BASIC Stamp ed
eseguitelo.
 Verificate che il LED lampeggi acceso/spento quado il pulsante è premuto e
mantenuto giù.
 Verificate che il LED non lampeggi quando il pulsante non è premuto.
' Che cosa è un microcontrollore - LedControllatoAPulsante.bs2
' Controlla lo stato del pulsante 10 volte al secondo e fa lampeggiare il LED
‘ quando il pulsante è premuto.
' {$STAMP BS2}
' {$PBASIC 2.5}
DO
DEBUG ? IN3
IF (IN3 = 1) THEN
HIGH 14
PAUSE 50
LOW 14
PAUSE 50
ELSE
PAUSE 100
ENDIF
LOOP
Come lavora LedControllatoAPulsante.bs2
Questo programma è un versione modificata di LeggiStatoPulsante.bs2 dell’attività
precedente. Le istruzioni DO...LOOP e DEBUG ? IN3 sono le stesse. La PAUSE 250 è
stata sostituita con una istruzione IF...THEN...ELSE. Quando la condizione dopo
l’istruzione IF è vera (IN3 = 1), vengono eseguite le istruzioni che seguono l’istruzione
THEN. Esse saranno eseguite fin quando si raggiunge l’istruzione ELSE, e in questo punto
il programma salta alla istruzione ENDIF e prosegue. Quando la condizione dopo
l’istruzione IF non è vera (IN3 = 0), sono eseguite le istruzioni dopo la frase ELSE
finché non si rggiunge l’istruzione ENDIF.
Potete fare un elenco dettagliato delle cose che un programma dovrebbe fare, sia per
agevolare la vostra pianificazione del programma, sia per descrivere cosa fa Questo tipo
di elenco è chiamato pseudo codice, e l’esempio riportato qui sotto usa lo pseudo codice
per descrivere come lavora LedControllatoAPulsante.bs2.


Esegui i comandi da qui fino all’istruzione Loop all’infinito
o Visualizza nel terminale di Debug il valore di IN3
o Se il valore di IN3 è 1, allora (If IN3=1 Then)
 Accendi il LED (LED on)
 Attendi per 1/20 di secondo
 Spegni il LED (LED off)
 Attendi per 1/20 di secondo
o Altrimenti, se il valore di IN3 è 0, (if IN3 = 0)
 non fare nulla, ma attendi la stessa durata di tempo che
sarebbe trscorsa per far lampeggiare brevemente il LED (1/10
di secondo).
Loop
Il vostro turno – Più veloce/Più lento
 Memorizzate il programma esempio sotto altro nome.
 Modificate il programma in modo che il LED lampeggi due volte pù
velocemente quando premete e rilasciate il pulsante.
 Modificate il programma in modo che il LED lampeggi due volte più lentamente
quando premete e rilasciate il pulsante.
ATTIVITÀ #4: DUE PULSANTI CHE CONTROLLANO DUE CIRCUITI A
LED
Aggiungete un secondo pulsante al progetto e guardate come lavora. Per rendere le cose
un pò più interessanti, aggiungete un secondo circuito a LED ed usate il secondo pulsante
per controllarlo.
Parti del pulsante e del circuito a LED
(2) Pulsanti – normalmente aperti
(2) Resistenze – 10 kΩ (marrone-nero-arancio)
(2) Resistenze – 470 Ω (giallo-viola-marrone)
(2) Resistenze – 220 Ω (rosso-rosso-marrone)
(2) LED – qualsiasi colore
Aggiungere un pulsante e un circuito a LED
La Figura 3-12 mostra un secondo circuito con LED e pulsante aggiuntivo al circuito chc
avete provato nell’attività precedente.
 Costruite il circuito mostrato in Figura 3-12. Se vi occorre aiuto nel costruire il
circuito mostrato nello schema, usate il diagramma di cablaggio di Figura 3-13
come guida.
 Modificate LeggiStatoPulsante.bs2 in modo che legga IN4 invece di IN3, ed
usatelo per provare il vostro secondo circuito a pulsante.
P15
470 
P14
470 
LED
Vss
LED
Vss
Vdd
P4
220 
P3
220 
10 k
Vss
10 k
Vss
Vdd
Figura 3-12
Schema per due
Pulsanti e LED
I punti indicano collegamenti: Ci sono tre posti dove le linee si intersecano in Figura
3-12, ma soltanto due di queste intersezioni hanno un punto. Quando due linee si
intersecano con un punto, vuol dire che sono elettricamente collegate. Per esempio, la
resistenza da 10 kΩ in basso a destra di Figura 3-12 ha uno dei suoi terminali connesso ad
uno dei terminali del pulsante del circuito P3 e ad uno dei terminali della resistenza da 220
Ω. Quando una linea ne incrocia un’altra, ma non c’è alcun punto, significa che i due fili
NON SONO elettricamente connessi. Ad esempio, la linea che collega il pulsante P4 alla
resistenza da 10 kΩ non si collega al circuito del pulsante P3 poiché in quell’intersezione
non c’è alcun punto.
Vdd
X3
Vin
Vss
++
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Figura 3-13
Diagramma di cablaggio dei due
pulsanti e due LED
Programmare il controllo dei pulsanti
Nell’attività precedente, avete sperimentato come prendere una decisione usando
un’istruzione IF...THEN...ELSE. Anche qui c’è di nuovo una cosa simile per una
istruzione IF...ELSEIF...ELSE. Essa opera molto bene per decidere quale dei LED far
lampeggiare. Il successivo programma esempio mostra come lavora.
Programma esempio: ControlloAPulsanteDiDueLed.bs2
 Digitate ed eseguite ControlloDiDueLed.bs2 nell’Editor del BASIC Stamp.
 Verificate che il LED nel circuito connesso a P14 lampeggi mentre si tiene
premuto il pulsante nel circuito connesso a P3.
 Accertatevi anche che il LED nel circuito connesso a P15 lampeggi mentre si
tiene premuto il pulsante nel circuito connesso a P4
' Che cosa è un microcontrollore - ControlloAPulsantiDiDueLed.bs2
' LED in P14 lampeggia se è premuto pulsante P3, e LED in P15 lampeggia se
' è premuto pulsante P4.
' {$STAMP BS2}
' {$PBASIC 2.5}
PAUSE 1000
DO
DEBUG HOME
DEBUG ? IN4
DEBUG ? IN3
IF (IN3 = 1) THEN
HIGH 14
PAUSE 50
ELSEIF (IN4 = 1) THEN
HIGH 15
PAUSE 50
ELSE
PAUSE 50
ENDIF
LOW 14
LOW 15
PAUSE 50
LOOP
Come opera ControlloAPulsantiDiDueLed.bs2
Se le visualizzazioni di IN3 e IN4 scorressero in basso sul terminale di Debug come
accadeva nell’esempio precedente, sarebbe difficile leggerle. Un modo per evitare questo
è mantenere il cursore sempre nella posizione in alto a sinistra nel terminale di Debug
tramite il carattere di controllo HOME:
DEBUG HOME
Inviando il cursore nella posizione detta “home” (solita) in ciascuna passata del ciclo
DO...LOOP, le istruzioni:
DEBUG ? IN4
DEBUG ? IN3
...viualizzano ogni volta i valori di IN4 e IN3 nella stessa zona del terminale di Debug. In
questo programma la parola DO inizia il ciclo:
DO
Queste istruzioni entro l’istruzione IF sono le stesse di quelle del programma esempio
dell’attività precedente:
IF (IN3 = 1) THEN
HIGH 14
PAUSE 50
Ecco dove la parola chiave ELSEIF interviene. Se IN3 non è 1, ma IN4 è 1, significa che
vogliamo accendere il LED connesso a P15 invece di quello connesso a P14.
HIGH 15
PAUSE 50
Se nessuna delle due condizioni è vera, vogliamo ancora fermarci per 50 ms senza
cambiare lo stato di qualsiasi dei circuiti LED.
ELSE
PAUSE 50
Quando avrete finito con tutte le decisioni, non dimenticate di inserire ENDIF.
ENDIF
E’ adesso il momento di spegnere i LED e fermarci di nuovo. Potreste provare a decidere
quale LED avete acceso e spegnerlo ancora. Le istruzioni PBASIC vengono eseguite
molto rapidamente, così perché non spegnere entrambi i LED e dimenticarci di prendere
altre decisioni?
LOW 14
LOW 15
PAUSE 50
L’istruzione LOOP riporta il programma indietro alla istruzione DO, e il processo di
controllare i pulsanti e cambiare lo stato dei LED si ripete all’infinito.
LOOP
Il vostro turno – Cosa succede se premiamo entrambi i pulsanti?
Il programma esempio ha una pecca. Provate a premere contemporaneamente entrambi i
pulsanti, e vedrete la pecca. Vi aspettereste che entrambi i LED lampeggino acceso –
spento, ma essi non lo fanno perché in una frase IF...ELSEIF...ELSE viene eseguito
soltanto un blocco di codice prima che la frase salti a ENDIF. Ecco come potete
correggere il problema:
 Memorizzate ControlloAPulsantiDiDueLed.bs2 sotto un altro nome.
 Sostituite questa frase IF e il suo blocco di codice:
IF (IN3 = 1) THEN
HIGH 14
PAUSE 50
...con questa frase IF...ELSEIF:
IF (IN3 = 1) AND (IN4 = 1) THEN
HIGH 14
HIGH 15
PAUSE 50
HIGH 14
PAUSE 50
Un blocco di codice è un gruppo di comandi (istruzioni). La frase IF riportata sopra ha un
blocco di codice con tre comandi (HIGH, HIGH, e PAUSE). La frase ELSEIF ha un blocco di
codice con due comandi (HIGH, PAUSE).
 Eseguite il vostro programma modificato e osservate se esso gestisce entrambi i
pulsanti e i circuiti LED come vi aspettereste.
La parola chiave AND può essere utilizzata entro una frase IF...THEN per controllare se
più di una condizione è vera. Tutte le condizioni legate da AND debbono risultare vere
perché sia vera la frase IF.
La parola chiave OR può essere utilizzata anch’essa per controllare se sia vera almeno una
delle condizioni.
Potete anche modificare il programma in modo che il LED che sta lampeggiando rimanga
acceso per durate di tempo differenti. Per esempio, potrete ridurre la Duration della
PAUSE a 10 per entrambi i pulsanti, aumentare la PAUSE per il LED su P14 a 100, ed
aumentare la PAUSE per il LED su P15 a 200.
 Modificate i comandi PAUSE nella frase IF e nelle due frasi ELSEIF come è stato
detto.
 Eseguite il programma modificato.
 Osservate la differenza di comportamento di ciascuna luce.
ATTIVITÀ #5: PROVA DI UN TEMPORIZZATORE DI REAZIONE
Siete l’ingegnere dei sistemi incorporati in una società di videogiochi. Il dipartimento
commerciale raccomanda di aggiungere al prossimo controllore di gioco palmare un
circuito che permetta di provare il tempo di reazione del giocatore. Il vostro prossimo
compito è di sviluppare una verifica concettuale per la prova del temporizzatore di
reazione.
La soluzione che costruirete e proverete in questa attività è un esempio di come risolvere
questo problema, ma non è definitivamente l’unica soluzione. Prima di continuare,
prendetevi un momento per pensare al modo in cui progetterete questo temporizzatore di
reazione.
Parti del gioco temporizzatore di reazioni
Costruzione del circuito temporizzatore di reazione
La Figura 3-14 mostra lo schema e i diagrammi di cablaggio per un circuito che può
essere utilizzato con il BASIC Stamp per fare un gioco temporizzatore di reazione.
 Costruite il circuito mostrato in Figura 3-14 a pagina 84.
 Eseguite ProvaLEDBiColore.bs2 da pagina 59 per provare il circuito del LED
bicolore ed essere certi che il vostro cablaggio sia corretto.
 Se ora ricostruite il circuito a pulsante per questa attività, eseguite il programma
LeggiStatoPulsante.bs2 dalla Attività #1 in questo capitolo per accertarvi che il
vostro pulsante stia lavorando correttamente.
P15
1
1
2
Vdd
P14

Vdd
P3
220 
10 k
Vin
Vss
X3
2
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Figura 3-14
Circuito per il
Gioco del
temporizzatore
di reazione
Vss
Programmazione del temporizzatore di reazione
Il programma esempio che segue lascerà il LED bicolore spento fino a quando il
giocatore preme e tiene premuto il pulsante. Quando il pulsante è mantenuto premuto in
giù, il LED si accenderà di colore rosso per un breve periodo di tempo. Quando diventa
di colore verde, il giocatore dovrà lasciare il pulsante quanto più in fretta riesce a fare. Il
programma misurerà allora il tempo che il giocatore impiega a lasciare il pulsante come
reazione alla luce che diventa verde.
Il programma esempio dimostra come lavorino l’esplorazione e il conteggio. L’
esplorazione (Polling) è il processo del controllare qualcosa, ripetendo il controllo
infinite volte molto rapidamente per vedere se è cambiata. Il conteggio (Counting) è il
processo di aggiungere un numero ad una variabile ogni volta che capita (o non capita)
un certo evento. In questo programma, il BASIC Stamp esplorerà dal momento in cui il
LED bicolore diventa verde fin quando viene rilasciato il pulsante. Il BASIC Stamp
aspetterà 1/1000 di secondo se si usa il comando PAUSE 1. Ciascuna volta che il BASIC
Stamp esplora e il pulsante non è stato ancora rilasciato, esso aggiungerà 1 alla variabile
di conteggio chiamata ContaTempo. Quando il pulsante viene rilasciato, il programma
smette di esplorare ed invia un messaggio al terminale di Debug, che visualizza il valore
della variabile ContaTempo.
Programma Esempio: TempoReazione.bs2
 Digitate ed eseguite TempoReazione.bs2.
 Seguite le domande sul terminale di Debug (vedi Figura 3-15).
Premi e tieni giù il pulsante
per accendere la luce rossa.
Quando la luce diventa verde,
lascia subito il pulsante!
Il vostro tempo è stato 96 ms.
Figura 3-15
Istruzioni del gioco Temporizzatore
di reazione nel terminale di Debug
Per giocare ancora, tieni giù
di nuovo il pulsante.
' Che cos’è un microcontrollore - TempoReazione.bs2
' Prova il tempo di reazione con un pulsante ed un LED bicolore.
' {$STAMP BS2}
' {$PBASIC 2.5}
PAUSE 1000
ContaTempo
' Aspetta 1 sec prima del 1° messaggio.
VAR
Word
' Dichiara la variabile conta tempo.
DEBUG "Premi e tieni giù il pulsante", CR, ' Visualizza istruz. di reazione.
"per accendere la luce rossa.", CR, CR,
"Quando la luce diventa verde, ", CR,
"lascia subito il pulsante!", CR, CR
DO
' Inizia ciclo principale.
DO
LOOP UNTIL IN3 = 1
' Il ciclo annidato si ripete...
' fin quando si preme il pulsante.
HIGH 14
LOW 15
' Il LED bicolore diventa rosso.
PAUSE 1000
' Ritardo di 1 secondo.
LOW 14
HIGH 15
' Il LED bicolore diventa verde.
ContaTempo = 0
' Azzera ContaTempo.
DO
' Ciclo annidato, conta il tempo...
PAUSE 1
ContaTempo = ContaTempo + 1
LOOP UNTIL IN3 = 0
LOW 15
' fin quando è rilasciato il pulsante.
' LED bicolore spento.
DEBUG "Il vostro tempo è stato ", DEC ContaTempo, ' Visualizza mis. tempo.
" ms.", CR, CR,
"Per giocare ancora, tieni giù ", CR, ‘ Istruzioni per giocare ancora.
"di nuovo il pulsante.", CR, CR
LOOP
' Indietro a “Inizia ciclo principale".
Come lavora TempoReazione.bs2
Poiché il programma dovrà tener conto del numero di volte in cui il pulsante viene
esplorato, è stata dichiarata una variabile chiamata ContaTempo.
ContaTempo VAR Word
' Dichiara variabile per cont. tempo.
Le variabili sono inizializzate a zero: Quando in PBASIC viene dichiarata una variabile, il
suo valore è automaticamente posto a zero fin quando un comando non la imposta ad un
nuovo valore.
Il comando DEBUG contiene istruzioni per chi esegue il gioco.
DEBUG "Premi e tieni giù il pulsante", CR,
"per accendere la luce rossa.", CR, CR,
"lascia subito il pulsante!", CR, CR
Le istruzioni DO...LOOP possono essere annidate. In altre parole, potete mettere una
DO...LOOP all’interno di un’altra.
DO
DO
' Ripete ciclo annidato...
LOOP UNTIL IN3 = 1
' fin quando si preme il pulsante.
' Qui era il resto del programma.
LOOP
' Indietro a "Inizia ciclo principale ".
La DO...LOOP più interna merita uno sguardo più attento. Una istruzione DO...LOOP
può usare una condizione per decidere se interrompere o meno il ciclo ed uscirne
muovendosi su ulteriori comandi che seguono il ciclo. Questa DO...LOOP ripeterà se
stessa fin quando il pulsante rimane non premuto (IN3 = 0). La DO...LOOP sarà
eseguita ripetutamente all’infinito, fin quando IN3 = 1. Poi, il programma passa al
comando successivo all’istruzione LOOP UNTIL. Questo è un esempio di esplorazione .
Il ciclo DO...LOOP UNTIL esplora fino a quando viene premuto il pulsante.
DO
LOOP UNTIL IN3 = 1
' Il ciclo annidato si ripete...
' fin quando viene premuto il pulsante.
I comandi che seguono immediatamente l’istruzione LOOP UNTIL accendono il LED
bicolore rosso, ritardano per un secondo, quindi lo accendono in verde.
HIGH 14
LOW 15
' LED bicolore rosso.
PAUSE 1000
' Ritardo di 1 secondo.
LOW 14
HIGH 15
' LED bicolore verde.
Non appena il LED bicolore passa a verde, è ora di iniziare il conteggio per tener conto di
quanto tempo passa fino a quando il giocatore rilascia il pulsante. La variabile
ContaTempo è impostata a zero, quindi inizia a ripetersi un altro ciclo DO...LOOP con
una condizione UNTIL. Questo ciclo si ripete fin quando il giocatore rilascia il pulsante
(IN3 = 0). In ciascuna ripetizione del ciclo, il BASIC Stamp ritarda per 1 ms tramite
l’istruzione PAUSE 1, e inoltre aggiunge 1 al valore della variabile ContaTempo.
ContaTempo = 0
' Imposta ContaTempo a zero.
DO
' Il ciclo annidato conta il tempo...
PAUSE 1
ContaTempo = ContaTempo + 1
LOOP UNTIL IN3 = 0
'fin quando il pulsante è rilasciato.
Dopo che il pulsante è stato rilasciato, il LED bicolore viene spento.
LOW 15
I risultati sono visualizzati nel terminale di Debug.
DEBUG "Il tuo tempo è stato ", DEC ContaTempo,
" ms.", CR, CR,
"Per giocare ancora, spingi il ", CR,
"pulsante giù di nuovo.", CR, CR
L’ultima istruzione nel programma è LOOP, che rimanda il programma indietro alla
primissima istruzione DO.
Il vostro turno – Rivedere il Progetto (Argomenti avanzati)
Il dipartimento commerciale ha dato il vostro prototipo ad alcuni sperimentatori di gioco.
Quando gli esperimenti di gioco sono stati fatti, il dipartimento commerciale torna da voi
con un elenco dettagliato di tre problemi che debbono essere risolti prima che il vostro
prototipo possa essere trasformato in controllore di gioco.
 Memorizzate TempoReazione.bs2
TempoReazioneVostroTurno.bs2).
con
un
nuovo
nome
(ad
esempio,
La “lista dettagliata” di problemi e le loro soluzioni sono discusse qui sotto.
Punto 1: Quando un giocatore tiene il pulsante premuto per 30 secondi, il suo
punteggio reale è di circa 14,000 ms, una misura di 14 secondi. Questo errore va
corretto!
Succede che l’eseguire il ciclo stesso assieme all’aggiunta di uno alla variabile
ContaTempo prende circa 1 ms senza il comando PAUSE 1. Questo fatto è chiamato
sovraccarico di codice (code overhead), ed è la quantità di tempo che il BASIC Stamp
impiega per eseguire i comandi. Una veloce correzione che migliorerà l’accuratezza è
semplicemente il trasformare in commento il comando PAUSE 1 aggiungendo un
apostrofo alla sua sinistra.
' PAUSE 1
 Provare a trasformare PAUSE 1 in commento e osservate quanto il programma
migliori in accuratezza.
Invece di commentare il ritardo, un altro modo di correggere il programma è moltiplicare
il vostro risultato per due. Ad esempio, proprio prima del comando DEBUG che visualizza
il numero di ms, potete inserire un comando che moltiplica il risultato per due:
ContaTempo = ContaTempo * 2
' <- Aggiungete questa
DEBUG "Il tuo tempo è stato ", DEC ContaTempo, " ms.", CR, CR
 Togliete il commento al comando PAUSE cancellando l’apostrofo, e provate al
suo posto la soluzione moltiplica-per-due.
Per la precisione, potete usare l’operatore */ che moltiplica per un valore frazionario
(decimale) . L’operatore */ non è difficile da usare; ecco come:
1)
Ponete il valore o la variabile che volete moltiplicare per un valore frazionario
prima dell’operatore */.
2)
Prendete il valore frazionario che volete usare e moltiplicatelo per 256.
3)
Arrotondatelo per togliere tutto quanto è a destra del punto decimale.
4)
Ponete il valore trovato dopo (a destra del) l’operatore */.
Esempio: Diciamo che volete moltiplicare la variabile ContaTempo per 3,69.
1)
Iniziate a porre ContaTempo dopo (a sinistra del) l’operatore */:
ContaTempo = ContaTempo */
2)
Moltiplicate il vostro valore frazionario per 256: 3,69 x 256 = 944,64.
3)
Arrotondate: 944,64 ≈ 945.
4)
Ponete quel valore a destra dell’operatore */:
ContaTempo = ContaTempo */ 945
' moltiplicate per 3,69
Moltiplicare per 2 riporterà in scala 14.000 a 28.000, che non è esattamente 30.000.
30.000 ÷ 14.000 ≈ 2,14. Per moltiplicare per 2,14 con l’operatore */ , per aumentare la
precisione, ci occorre immaginare quanti 256simi ci sono in 2,4. Quindi 2,14 × 256 =
547,84 ≈ 548. Potete usare questo valore e l’operatore */ per sostituire ContaTempo =
ContaTempo * 2.
 Sostituite ContaTempo = ContaTempo * 2 con ContaTempo = ContaTempo
*/ 548 e provate di nuovo il vostro programma.
La vostra prova dei 30-secondi con il programma originale, non modificato, può darvi un
valore leggermente diverso da 14.000. Se è così, potete usare lo stesso procedimento con
i risultati della vostra prova per calcolare un valore che, dato all’operatore */, renda i
vostri risultati anche più precisi.
 Provate a farlo!
Punto 2: I giocatori immaginano presto che il ritardo da rosso a verde è 1 secondo.
Dopo aver eseguito il gioco parecchie volte, essi migliorano nel predire quando
andar via, se il loro punteggio (tempo) non riflette più il loro vero tempo di reazione.
Il BASIC Stamp ha un comando RANDOM . Ecco come modificare il vostro codice per
ottenere un numero random:
 All’inizio del vostro codice, aggiungete una dichiarazione di una nuova variabile
chiamata valore, e impostatela a 23. Il valore 23 è chiamato il seme poiché
causa l’avvio di una sequenza di numeri pseudo random.
ContaTempo VAR Word
valore VAR Byte
valore = 23
 Proprio prima del comando PAUSE 1000 interno al ciclo DO...LOOP, usate il
comando RANDOM per dare a valore un nuovo valore “random” dalla sequenza
pseudo random che è stata iniziata con 23.
RANDOM valore
DEBUG "Ritardo ", ? 1000 + valore, CR ' <- Aggiung. questa
 Modificate il comando PAUSE 1000 in modo che il valore “random” sia
aggiunto al suo argomento Durata.
PAUSE 1000 + valore
' <- Modificate questa
LOW 14
HIGH 15
 Poiché il valore più grande che un byte può memorizzare è 255, il comando
PAUSE varia soltanto di ¼ di secondo. Potete moltiplicare la variabile valore
per 4 per fare in modo che il ritardo della luce rossa varii da 1 ad appena sopra 2
secondi.
DEBUG "Ritardo ", ? 1000 + (valore*4), CR ' <- Modificate
PAUSE 1000 + (valore * 4)
' <- Modificate ancora questa
Che cos’è un algoritmo? Un algoritmo è una sequenza di operazioni matematiche.
Che cos’è pseudo random? Pseudo random significa che sembra random, ma non lo è
realmente. Ciascuna volta che iniziate di nuovo il programma, otterrete la stessa sequenza
di valori.
Che cos’è un seme? Un seme è un valore usato per iniziare la sequenza pseudo random.
Se usate un valore diverso del seme (cambiate valore da 23 a qualche altro numero),
avrete una diversa sequenza pseudo random.
Punto 3: Un giocatore che abbandona il pulsante prima che la luce diventi verde
ottiene un punteggio irrazionalmente buono (1 ms). Il vostro microcontrollore deve
immaginare se un giocatore sta imbrogliando.
Lo pseudo-codice è stato introdotto verso la fine della Attività #3 in questo capitolo.
Ecco un po’ di pseudo-codice che vi aiuta ad applicare una istruzione
IF...THEN...ELSE per risolvere il problema. Supponendo che abbiate fatto gli altri
cambiamenti descritti nei punti 1 e 2, ContaTempo sarà ora 2 invece di 1 se il giocatore
rilascia il pulsante prima che la luce diventi verde. I cambiamenti descritti qui sotto
lavoreranno sia nel caso che ContaTempo sia 1, sia che sia 2.




Se il valore di ContaTempo è minore o uguale a 2 (ContaTempo <= 2 )
o Visualizza un messaggio che dica al giocatore se debba aspettare
fino a dopo che la luce si accenda in verde per lasciare il pulsante.
Altrimenti, (se il valore di ContaTempo è maggiore di 1)
o Visualizza il valore del tempo in ContaTempo (proprio come in
TempoReazione.bs2) in ms.
Fine If
Visualizza un messaggio “Per giocare di nuovo...”.
 Modificate il vostro programma implementando questo pseudo-codice in
PBASIC per correggere il problema del giocatore che imbroglia.
SOMMARIO
Questo capitolo ha introdotto il pulsante e alcuni comuni circuiti a pulsante. Questo
capitolo ha anche introdotto come costruire e provare un circuito a pulsante e come usare
il BASIC Stamp per leggere lo stato di uno o più pulsanti. Il BASIC Stamp era stato
programmato per assumere decisioni basate sullo stato (sugli stati) del pulsante (dei
pulsanti) e questa informazione è stata utilizzata per controllare LED (uno o più).
Utilizzando questi concetti è stato costruito un gioco sul tempo di reazione. In aggiunta
al controllo di LED, il BASIC Stamp era stato programmato per esplorare un pulsante e
prendere misure di tempo.
Sono stati introdotti alcuni concetti di programmazione, inclusi conteggio, pseudo-codice
per pianificare il flusso del programma, il sovraccarico di codice in applicazioni sensibili
al tempo, e i valori del seme per eventi pseudo random.
E’ stato introdotto il modo in cui leggere circuiti a pulsante singolo tramite le speciali
variabili I/O incorporate nel BASIC Stamp (IN3, IN4, ecc.). Sono stati introdotti anche il
prendere decisioni basate su questi valori usando frasi IF...THEN...ELSE, frasi
IF...ELSEIF...ELSE, e blocchi di codice. Per valutare più di una condizione, sono
stati introdotti gli operatori AND ed OR. E’ stata introdotta l’aggiunta di una condizione ad
un ciclo DO...LOOP usando la parola-chiave UNTIL assieme ai blocchi DO...LOOP
annidati. È stato introdotto il comando RANDOM per aggiungere un elemento di
imprevedibilità ad una applicazione, il gioco del Temporizzatore di Reazione.
Domande
1. Qual’è la differenza tra inviare e ricevere segnali HIGH e LOW usando il BASIC
Stamp?
2. Cosa significa “normalmente aperto” riguardo ad un pulsante?
3. Che cosa accade tra i terminali di un pulsante normalmente aperto quando lo
premete?
4. Qual’è il valore di IN3 quando un pulsante si connette a Vdd? Qual è il valore di
IN3 quando un pulsante si connette a Vss?
5. Casa fa il comando DEBUG ? IN3?
6. Che tipo di blocchi di codice può essere utilizzato per assumere decisioni basate
sul valore di uno o più pulsanti?
7. Che cosa fa il carattere di controllo HOME nella istruzione DEBUG HOME?
Esercizi
1. Spiegare come modificare LeggiStatoPulsante.bs2 a pagina 72 perché legga il
pulsante ogni secondo invece che ogni ¼ di secondo.
2. Spiegare come modificare LeggiStatoPulsante.bs2 in modo che legga il circuito
di un pulsante normalmente aperto con una resistenza di pull-up (rinforzo)
connessa al pin di I/O P6.
Progetto
1. Modificare TempoReazione.bs2 in modo che sia un gioco per due giocatori.
Aggiungere un secondo pulsante collegato a P4 per il secondo giocatore.
Soluzioni
D1. Inviare usa il pin I/O del BASIC Stamp come un’uscita, mentre ricevere usa il
pin I/O del BASIC Stamp come un ingresso.
D2. Normalmente aperto significa che lo stato normale del pulsante (non premuto)
forma un circuito aperto.
D3. Quando è premuto, l’intervallo tra i terminali è ponticellato da un materiale
metallico conduttore. La corrente può quindi fluire attraverso il pulsante.
D4. IN3 = 1 quando il pulsante lo collega a Vdd. IN3 = 0 quando il pulsante lo
collega a Vss.
D5.DEBUG ? IN3 visualizza il testo “IN3 = ” seguito dal valore memorizzato entro
IN3 (è uno 0 oppure un 1 a seconda dello stato del pin di I/O P3), seguito da un
ritorno carrello.
D6. IF...THEN...ELSE ed IF...ELSEIF...ELSE.
D7. Il carattere di controllo HOME manda il cursore nella posizione in alto a sinistra
del terminale di Debug.
E1. Il ciclo DO...LOOP nel programma si ripete ogni ¼ di secondo per effetto del
comando PAUSE 250. Per ripeterlo ogni secondo, modificate l’istruzione PAUSE
250 (250 ms = 0.25 s = ¼ s), in PAUSE 1000 (1000ms = 1 s).
DO
DEBUG ? IN3
PAUSE 1000
LOOP
E2. Sostituite IN3 con IN6, per leggere il pin I/O P6. Il programma visualizza
soltanto lo stato del pulsante, e non fa uso del valore per prendere decisioni; non
importa se la resistenza è di pull-up (rinforzo) o di pull-down (indebolimento). Il
comando DEBUG visualizzerà lo stato del pulsante in entrambi i modi.
DO
DEBUG ? IN6
PAUSE 250
LOOP
P1. Prima di tutto, è stato aggiunto un pulsante per il secondo giocatore, collegato al
pin I/O P4 del BASIC Stamp. Lo schema circuitale si basa sulla Figura 3-14 a
pagina 84.
Vdd
P15
Vdd
1
P4
P3
220 
220 
10 k
2
P14
470
Vss
10 k
Vss
Frammenti del programma soluzione sono riportati qui sotto, ma tenete a mente
che le soluzioni possono essere codificate in molti modi diversi. Però, la
maggior parte delle soluzioni includeranno le modifiche seguenti:
Usare due variabili per tener traccia dei tempi dei due giocatori:
ContaTempoA VAR
ContaTempoB VAR
Word
Word
' Punteggio (tempo) giocatore A
' Punteggio (tempo) giocatore B
Cambiate le istruzioni per tener conto di due pulsanti:
DEBUG "Premi e tieni giù i pulsanti ", CR,
DEBUG "pulsanti giù di nuovo.", CR, CR
Aspettare che entrambi i pulsanti siano premuti prima di accendere il LED rosso,
usando l’operatore AND:
LOOP UNTIL (IN3 = 1) AND (IN4 = 1)
Aspettare fin quando entrambi i pulsanti siano rilasciati per terminare la
temporizzazione, usando ancora l’operatore AND:
Aggiungere logica per decidere di quale giocatore incrementare il tempo:
IF (IN3 = 1) THEN
ContaTempoA = ContaTempoA + 1
ENDIF
IF (IN4 = 1) THEN
ContaTempoB = ContaTempoB + 1
ENDIF
Modificare la visualizzazione del tempo per mostrare i tempi di entrambi i
giocatori:
DEBUG "Tempo giocatore A:
DEBUG "Tempo giocatore B:
", DEC ContaTempoA, " ms. ", CR
", DEC ContaTempoB, " ms. ", CR, CR
Aggiungere logica per mostrare quale giocatore ha avuto il tempo di reazione più
breve:
IF (ContaTempoA < ContaTempoB) THEN
DEBUG "Vince il giocatore A!", CR
ELSEIF (ContaTempoB < ContaTempoA) THEN
DEBUG "Vince il giocatore B!", CR
ELSE
DEBUG "Hanno pareggiato!", CR
ENDIF
Qui sotto è mostrata la soluzione completa.
'
'
'
'
'
'
Che cos’è un microcontrollore - Cap03Pr01_TempoReazione2Giocatori.bs2
Prova il tempo di reazione con un pulsante e un LED bicolore.
Aggiunge un secondo giocatore con un secondo pulsante. Entrambi i gio
catori giocano una volta usando lo stesso LED. Vince il più veloce.
Pin P3: Pulsante giocatore A, attivo alto
Pin P4: Pulsante giocatore B, attivo alto
' {$STAMP BS2}
' {$PBASIC 2.5}
ContaTempoA VAR
ContaTempoB VAR
PAUSE 1000
Word
Word
' Punteggio (tempo) giocatore A
' Punteggio (tempo) giocatore B
' 1 s prima 1.mo messaggio
DEBUG "Premi e tieni giù i pulsanti ", CR,
' Visualizza le istru"per accendere la luce rossa.", CR, CR, ' zioni di reazione.
"lascia quanto più presto puoi.", CR, CR
DO
DO
' Cicla fin quando premono entrambi
' Niente
HIGH 14
' LED bicolore rosso.
LOW 15
PAUSE 1000
' Ritardo 1 secondo.
LOW 14
HIGH 15
' LED bicolore verde.
ContaTempoA = 0
ContaTempoB = 0
' Pone ContaTempo a zero
' per entrambi
DO
PAUSE 1
IF (IN3 = 1) THEN
ContaTempoA = ContaTempoA + 1
ENDIF
IF (IN4 = 1) THEN
ContaTempoB = ContaTempoB + 1
ENDIF
' Se pulsante ancora giù,
' incrementa contatore
' Cicla finché entrambi i
' pulsanti sono rilasciati.
LOW 15
' LED bicolore spento.
DEBUG "Tempo giocatore A: ", DEC ContaTempoA, " ms. ", CR
DEBUG "Tempo giocatore B: ", DEC ContaTempoB, " ms. ", CR, CR
IF (ContaTempoA < ContaTempoB) THEN
DEBUG "Vince il giocaotre A!", CR
ELSEIF (ContaTempoB < ContaTempoA) THEN
DEBUG "Vince il giocatore B!", CR
ELSE
' tempi di A & B uguali
DEBUG "Hanno pareggiato!", CR
ENDIF
DEBUG CR
DEBUG "Per giocare di nuovo, premere ", CR
DEBUG "ancora i pulsanti.", CR, CR
LOOP
' Istruz. nuovo gioco.
' Torna a inizio ciclo principale.
Controllo del Movimento · Pagina 99
Capitolo 4: Controllo del Movimento
MOVIMENTO MICROCONTROLLATO
I microcontrollori si accertano che le cose si muovono nel posto giusto tutto intorno a voi
ogni giorno. Se avete una stampante a getto di inchiostro, la teastina di stampa che va
avanti e indietro attraverso la pagina mentre sta stampando è mossa da un motore passopasso controllato da un microcontrollore. Le porte automatiche del negozio di alimentari
attraverso cui passate sono controllate da microcontrollori, e il dispositivo di espulsione
automatica del vostro riproduttore DVD è controllato anch’esso da un microcontrollore.
SEGNALI ACCESO/SPENTO (ON/OFF) E MOVIMENTO DI UN MOTORE
Quasi tutti i motori microcontrollati ricevono sequenze di segnali alto e basso simili a
quelli che avete mandato ai LED. La differenza è che il microcontrollore deve inviare
questi segnali a tassi per solito molto più veloci degli esempi di LED lampeggianti del
capitolo 3. Se doveste usare un circuito a LED per monitorare i segnali di controllo,
alcuni farebbero lampeggiare il LED acceso/spento così rapidamente che l’occhio umano
non potrebbe rilevarne la commutazione. Il LED apparirebbe soltanto debolmente
risplendente. Alcuni apparirebbero come lampeggianti rapidamente e altri sarebbero
percepibili più facilmente.
Alcuni motori richiedono una abbondante circuiteria per aiutare il microcontrollore a farli
funzionare. Altri motori richiedono l’aggiunta di parti meccaniche per farli lavorare
all’interno di macchine. Di tutti i tipi diversi di motori da cui iniziare a parlare, il servo
motore hobby con cui farete esperimenti in questo capitolo è probabilmente il più
semplice. Come vedrete presto, è facile controllarlo con il BASIC Stamp, poiché
richiede poca o nessuna circuiteria aggiuntiva, ed ha una uscita meccanica che è facile
collegare ad oggetti per farli muovere.
INTRODUZIONE AL SERVO
Un servo hobby è un dispositivo che controlla la posizione, e potrete trovarlo in quasi
tutti i modelli di automobili, barche o aeroplani radio-controllati (RC). Nelle automobili
RC, il servo gestisce lo sterzo per controllare con quanta precisione l’automobile fa una
curva. In una barca RC, esso mantiene il timone in posizione per le virate. Gli aeroplani
RC hanno per solito diversi servo che posizionano i diversi flap che controllano il
movimento dell’aeroplano. Nei veicoli RC con motori a carburante, un altro servo
muove la leva dell’acceleratore per controllare la velocità di rotazione (i “giri”) del
motore. Un esemppio di aeroplano RC e del suo controllore radio sono mostrati nella
Figura 4-1. L’hobbista “fa volare” l’aeroplano tramite joystick manuali sul controllore
radio, che provocano l’azione dei servo sull’aeroplano per controllare la posizione dei
piani elevatori (alettoni, flap e piani di coda) e del timone di direzione dell’aeroplano RC.
Figura 4-1
Areomodello e
Controllore Radio
Pertanto, come fa il joystick del radio-comando, mantenuto in certe posizioni, a causare il
mantenimento di un flap sull’aeroplano RC in una certa posizione? Il controllore radio
converte la posizione dei joystick in impulsi di attività radio che durano determinati
periodi di tempo. Il tempo per cui dura ciascun impulso indica la posizione di uno dei
joystick. Sull’aereo RC, un ricevitore radio converte questi impulsi di attività radio in
impulsi digitali (segnali alto/basso) e li invia ai servo dell’aereo. Ciascun servo ha al suo
interno la circuiteria che converte questi impulsi digitali in una posizione, che il servo
mantiene. La quantità di tempo per cui dura ciascun impulso è ciò che dice al servo quale
posizione deve mantenere. Questi impulsi di controllo durano soltanto pochi millesimi di
secondo, e si ripetono all’incirca da 40 a 50 volte al secondo per fare in modo che il servo
mantenga la posizione che tiene.
La Figura 4-2 mostra un disegno di un Servo Standard Parallax. Lo spinotto (1) è
utilizzato per connettere il servo ad una sorgente di energia (Vdd e Vss) e ad una sorgente
di segnale (un pin I/O del BASIC Stamp). Il cavo (2) ha tre fili, e conduce le linee di
Vdd, Vss e del segnale dallo spinotto entro il servo. Il quadrilatero (3) è la parte del
servo che somiglia ad una stella a quattro punte. Quando il servo sta in movimento, il
quadrilatero è la parte mobile che il servo mantiene in posizioni diverse. La vite Phillips
(4) mantiene il quadrilatero fissato all’alberino di uscita del servo. L’involucro (5)
contiene i cirsuiti sensori di posizione e di controllo del servo, un motore DC, e gli
ingranaggi. Queste parti lavorano assieme per prendere i segnali alto/basso dal BASIC
Stamp e tradurli in posizioni mantenute dal quadrilatero del servo.
2
Figura 4-2
Il Servo Standard
Parallax
3
1
(1) Spinotto
(2) Cavo
(3) Quadrilatero
(4) Vite che fissa il
quadrilatero al’alberino di
uscita del servo
(5) Involucro
4
5
In questo capitolo, programmerete il BASIC Stamp perché invii segnali ad un servo che
controllino la posizione del suo quadrilatero. Facendo inviare al BASIC Stamp segnali
che dicano al servo di mantenere diverse posizioni, i vostri programmi possono anche
orchestrare il movimento del servo. I vostri programmi possono perfino controllare
pulsanti e utilizzare le informazioni sul fatto che i pulsanti sono premuti o meno per
regolare la posizione che un servo mantiene (controllo della posizione di un servo a
pulsante). Il BASIC Stamp può essere anche programmato per ricevere messaggi che voi
digitate nel terminale di Debug, ed usare quei messaggi per controllare la posizione del
servo (controllo della posizione del servo da terminale).
ATTIVITÀ #1: CONNESSIONE E PROVA DI UN SERVO
In questa attività, seguirete istruzioni per connettere un servo all’alimentazione della
vostra particolare scheda e al BASIC Stamp.
Parti del Servo e del circuito a LED
(1) Servo Standard Parallax
(1) LED – di qualsiasi colore
Il circuito a LED sarà utilizzato per tener d’occhio il segnale di controllo che il BASIC
Stamp invia al servo. Tenete a mente che il circuito a LED non è richiesto per aiutare il
servo a funzionare. È lì proprio per aiutarvi a “vedere” i segnali di controllo.
PRECAUZIONE: per le attività di questo testo usare soltanto un Servo Standard
Parallax ! Altri servo possono esser stati progettati con specifiche differenti, che potrebbero
non essere compatibili con queste attività.
Costruzione dei circuiti del Servo e del LED
Nel Capitolo 1, avete identificato la vostra scheda e relativa revisione tramite l’aiuto
dell’Editor del BASIC Stamp. Qui vi occorrerà sapere quale scheda, e relativa revisione,
avete in modo che possiate trovare le istruzioni di costruzione del circuito del servo per la
vostra scheda.
 Se non sapete in anticipo quale scheda e sua revisione avete, aprite l’aiuto
dell’Editor del BASIC Stamp e cliccate sul link Getting Started with Stamps in
Class sulla home page. Poi seguite le istruzioni per determinare quale scheda
avete.
 Se avete una Board of Education USB (qualsiasi Rev) o Seriale (Rev C o
successiva), andate al paragrafo Circuito Servo per la Board of Education qui
sotto.
 Se avte una HomeWork Board BASIC Stamp (Rev C o successiva), andate al
paragrafo Circuito Servo per la HomeWork Board BASIC Stamp a pagina 106.
 Se la vostra scheda non è elencata qui sopra, andate al sito
www.parallax.com/Go/WAM → Servo Circuit Connections per trovare le
istruzioni circuitali per la vostra scheda. Quando avete letto le itruzioni del
circuito del servo per la vostra scheda, andate all’ Attività #2: Programma per la
prova del controllo di un servo a pagina 109.
Circuito Servo per la Board of Education
Queste istruzioni sono per tutte le Revisioni della Board of Education USB e anche per la
Rev C o successive della Board of Education Seriale.
 Togliete energia come mostrato in Figura 4-3.
Figura 4-3
Scollegate Energia
Reset
0
1
2
Ponete a 0 l’interruttore a 3-posizioni
La Figura 4-4 mostra i connettori per i servo sulla Board of Education. Questo è il posto
ove va connesso lo spinotto dei vostri servo. Questa scheda è provvista di un ponticello
(jumper) che potrete usare per collegare l’alimentazione dei servo sia a Vin, sia a Vdd. Il
ponticello è il pezzo rettangolare nero rimovibile indicato dalla freccia tra i due
connettori per i servo.
 Verificate che il ponticello sia posto in Vdd come mostrato nella Figura 4-4. Se
invece è posto su Vin, sollevate ed estraete il ponticello rettangolare fuori dai pin
su cui è inserito attualmente, e reinseritelo sui due pin più vicini all’etichetta
Vdd.
15 14 Vdd 13 12
Red
Rosso
Black
X4
X5
Vin
Nero
Figura 4-4
Ponticello tra i connettori dei Servo
impostato su Vdd
Il ponticello vi permette di scegliere l’alimentazione (Vin or Vdd) per i Servo Standard
Parallax.

Se state utilizzando una batteria da 9 V, impostatelo a Vdd. NON USATE i
“sostituti” di batterie da 9 V montati a parete (prese di alimentazione equivalenti).

Se state utilizzando un pacco portapile da 6 V con 4 batterie AA, potrete usare
entrambe le posizioni del ponticello.

Se state utilizzando un alimentatore DC connesso alla rete elettrica (a parete),
usate soltanto Vdd. Prima di collegare un alimentatore DC connesso a parete alla
Board of Education, assicuratevi di controllare le specifiche per gli alimentatori DC
accettabili, elencate nell’aiuto dell’Editor del BASIC Stamp.
La Figura 4-5 mostra lo schema circuitale che costruirete sulla vostra Board of Education.
 Costruite il circuito mostrato in Figura 4-5 e Figura 4-6.
 Accertatevi di non aver inserito il servo in verso opposto a quello giusto
(connettore a testa in giù). I fili bianco, rosso e nero dovranno allinearsi come
mostrato in Figura 4-6.
P14
470 
LED
Figura 4-5
Schema di Servo e
Indicatore a LED
per la Board of
Education
Vss
Vdd
P14
Bianco
White
Red
Rosso
Black
Nero
Vss
Servo
Per la Rev C o
successive della
Board of Education
Seriale, o per
qualsiasi Board of
Education USB
15 14 Vdd 13 12
White
Bianco
RossoRed
NeroBlack
Red
Rosso
Black
Nero
X4
Vdd
X3
X5
Vin
Vss
+
Figura 4-6
Servo e
Indicatore
LED sulla
Board of
Education
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
standard servo
www.parallax.com
Fino ad ora, avete utilizzato l’interruttore a 3-posizioni in posizione 1. Adesso, lo
muoverete alla posizione 2 per dare energia ai connettori dei servo.
 Alimentate i connettori dei servo regolando l’interruttore a 3-posizioni come
mostrato in Figura 4-7. Il vostro servo inizierà appena a muoversi quando date
energia.
Reset
0
1
2
Figura 4-7
Energia della Board of Education
connessa alla scheda e ai connettori
Servo
Se vedete istruzioni di questo capitolo col titolo “Dare energia alla vostra scheda”
muovete l’interruttore a 3-posizioni alla posizione-2. Analogamente, se vedete istruzioni
di questo capitolo col titolo “Scollegate energia dalla vostra scheda” muovete
l’interruttore a 3 posizioni alla posizione 0.
 Scollegate energia dalla vostra scheda.
 Andate all’Attività #2 a pagina 109.
Circuito Servo per la HomeWork Board BASIC Stamp
Se state collegando il vostro servo ad una scheda HomeWork Board (Rev C o successiva)
BASIC Stamp, vi occorreranno queste parti aggiuntive al vostro kit:
(1) capocorda maschio/maschio a 3-pin (mostrato in Figura 4-8).
(4) cavallotti di filo
Figura 4-8
Parte Extra per circuito Servo della
HomeWork Board BASIC Stamp
Capocorda maschio/maschio a 3-pin
La Figura 4-9 mostra lo schema dei circuiti del servo e dell’indicatore LED sulla scheda
HomeWork Board BASIC Stamp. Le istruzioni che seguono questa figura vi
mostreranno come costruire con sicurezza questo circuito.
 Scollegate la vostra batteria a 9 V dalla vostra HomeWork Board.
 Costruite il circuito dell’indicatore LED e del connettore del servo mostrati dallo
schema in Figura 4-9 e dallo schema di cablaggio in Figura 4-10.
P14
470 
LED
Vss
Vdd
P14
Figura 4-9
Schema per Servo e
Indicatore LED sulla
HomeWork Board
Bianco
White
Red
Rosso
Servo
Black
Nero
Vss
Figura 4-10
Circuiti dell’Indicatore
LED e del connettore del
Servo sulla HomeWork
Board
 Collegate il servo al connettore del servo come mostrato in Figura 4-11.
 Assicuratevi che i colori sul cavo del servo si allineino correttamente con i colori
disegnati nella figura.
 Controllate due volte il vostro cablaggio.
ATTENZIONE
Usate soltanto una batteria da 9 V quando il vostro Servo Standard Parallax viene
collegato ad una HomeWork Board BASIC Stamp. Non usate qualsiasi altro tipo di
alimentatore DC o “sostituto di batteria” che si colleghi ad una presa di corrente AC.
Per otttenere migliori risultati, assicuratevi che la vostra batteria sia nuova. Se state
utilizzando una batteria ricaricabile, assicuratevi che sia stata caricata di recente. Dovrebbe
anche avere una capacità di 100 mAh (milliamp per ora) o superiore.
 Ricollegate la vostra batteria da 9 V alla vostra HomeWork Board. Mentre fate
la connessione il servo può girare leggermente.
Bianco
Rosso
Nero
Figura 4-11
Servo collegato ad
una HomeWork
Board
ATTIVITÀ #2: PROGRAMMA PER LA PROVA DEL CONTROLLO DI UN
SERVO
Un grado è una misura di angolo denotata dal simbolo °. Esempi di misure di angolo in
gradi sono mostrati in Figura 4-12, e comprendono 30°, 45°, 90°, 135° e 180°. Ciascun
grado in una misura di angolo rappresenta 1/360mo di un cerchio, quindi la misura di 90°
è ¼ di un cerchio dato che 90 ÷ 360 = ¼. Analogamente, 180° è ½ di un cerchio dato che
180 ÷ 360 = ½, e potete calcolare frazioni simili per le altre misure in gradi mostrate in
figura.
Figura 4-12
Esempi di
misure di
angolo in gradi
Il Servo Standard Parallax può fare in modo che il suo quadrilatero mantenga posizioni
qualsiasi entro una gamma di 180°, quindi le misure in gradi possono essere utili per
descrivere le posizioni mantenute dal servo. La Figura 4-13 mostra esempi di un servo
con un anello di filo che è stato passato attraverso due dei fori del suo quadrilatero e
quindi annodato a treccia. La direzione che la treccia punta indica l’angolo del
quadrilatero del servo, e la figura mostra gli esempi di 0°, 45°, 90°, 135°, e 180°.
Figura 4-13: Esempi della posizione del quadrilatero del Servo
L’intervallo di movimento del quadrilatero del vostro servo e i limiti meccanici saranno
probabilmente diversi da quanto mostrato qui. Dopo il primo programma esempio, ci sono
istruzioni su come regolare il quadrilatero per andare d’accordo con questa figura.
Il montaggio di fabbrica del quadrilatero sul servo è casuale, per cui le posizioni del
quadrilatero del vostro servo saranno probabilmente diverse da quelle della Figura 4-13.
Infatti, a confronto con la Figura 4-13, il quadrilatero del vostro servo può essere montato
in qualsiasi posto in un intervallo di +/- 45°. Il servo in Figura 4-14 mostra un esempio di
un servo il cui quadrilatero era montato 20° in senso orario da quello in Figura 4-13.
Dopo che avete trovato il centro dell’intervallo di movimento del quadrilatero del servo,
potete usarlo come riferimento dei 90° oppure regolare meccanicamente il quadrilatero
del servo in modo che corrisponda alla Figura 4-13, seguendo le istruzioni date più avanti
in questa attività.
Figura 4-14: Esempi di posizione del quadrilatero del Servo prima della regolazione
meccanica
Questo è un esempio di quadrilatero montato sull’alberino di uscita del servo a 20° circa in
senso antiorario rispetto a come è stato impostato il quadrilatero nella Figura 4-13.
Potete trovare il centro dell’intervallo di movimento del servo ruotando gentilmente il
quadrilatero per trovare i suoi limiti meccanici in senso orario e antiorario. La posizione
a metà strada tra questi due limiti è il centro ovvero la posizione a 90°. La posizione
centrale del servo potrebbe cadere in qualsiasi posto nella regione mostrata in Figura
4-15.
Il centro dell’intervallo di movimento del quadrilatero
del vostro servo dovrebbe cadere in qualche posto
entro questa regione
Figura 4-15
Intervallo delle
posizioni possibili del
centro
In questi passaggi successivi, girate lentamente il quadrilatero del servo e non
forzatelo! Il servo ha limiti meccanici preimpostati al suo interno per evitare che il
quadrilatero possa ruotare fuori dal suo intervallo di movimento di 180°.
Girate
delicatamente il quadrilatero, e riuscirete a sentire quando raggiunge uno dei suoi limiti
meccanici. Non provate a forzarlo oltre questi limiti poiché gli ingranaggi interni al servo si
possono strappare.
 Verificate che l’energia della vostra scheda sia ancora scollegata.
 Ruotate delicatamente il quadrilatero del servo per trovare i limiti meccanici in
senso orario ed antiorario del servo. Il quadrilatero dei servo ruoterà con
pochissima forza di rotazione fin quando raggiungete questi limiti. NON
PROVATE A RUOTARE IL QUADRILATERO OLTRE QUESTI LIMITI;
ruotatelo soltanto abbastanza per trovarli.
 Ruotate il quadrilatero del servo in modo che sia a metà strada tra i due limiti.
Questa è all’incirca la posizione “centrale” del servo.
 Con il quadrilatero del servo nella sua posizione centrale, avvolgete un cavallotto
di filo attraverso il quadrilatero e arrotolatelo stretto in modo che punti verso
l’alto entro la regione mostrata in Figura 4-15.
Tenete a mente che la direzione in cui il filo arrotolato sta puntando nella figura è solo un
esempio; la vostra estremità arrotolata punta in un posto qualsiasi nella regione.
Dovunque essa punti quando è nel centro del suo intervallo di movimento dovrebbe
essere molto vicino alla posizione a 90° del servo. Ancora, questa posizione può variare
da un servo all’altro per il modo in cui il quadrilatero viene attaccato al servo.
Programmazione delle Posizioni del Servo
Il grafico in Figura 4-16 è chiamato diagramma di temporizzazione, e mostra esempi di
segnali alto/basso che il BASIC Stamp deve inviare ad un servo per fargli mantenere la
sua posizione di 90°.
Figura 4-16
Diagramma di
temporizzazione di
un segnale del
Servo
Impulsi di 1.5 ms
fanno mantenere al
servo una posizione
“centrale” di 90°.
Il diagramma di temporizzazione mostra segnali alti di durata 1.5 ms, separati da segnali
bassi di durata 20 ms. I ... alla destra del segnale sono un modo per indicare che i
segnali alti da 1.5 ms e i segnali bassi da 20 ms debbono essere ripetuti all’infinito perché
il servo mantenga la posizione. Il simbolo “~” nella scrittura “~20 ms” indica che il
tempo basso può essere approssimato, e può realmente variare di pochi millisecondi
sopra o sotto 20 ms con poco o nessun effetto su dove il servo posiziona il suo
quadrilatero. La ragione di ciò è che la durata di tempo del segnale alto è quello che dice
al servo quale posizione tenere, quindi questa durata deve essere precisa.
C’è un comando speciale detto PULSOUT che dà al vostro programma un controllo preciso
sulla durata di questi brevissimi segnali alti, comunemente detti impulsi. Ecco la sintassi
del comando PULSOUT:
PULSOUT Pin, Durata
Con il comando PULSOUT, potete scrivere codice PBASIC per far impostare al BASIC
Stamp la posizione del servo a 90° usando il diagramma di temporizzazione della Figura
4-16 come guida. L’argomento Pin del comando PULSOUT dev’essere un numero che
dice al BASIC Stamp quale pin I/O deve trasmettere l’impulso. L’argomento Durata del
comando PULSOUT è il numero di incrementi temporali in 2-milionesimi-di-secondo che
l’impulso dovrà durare. 2 milionesimi di un secondo è uguale a 2 microsecondi, che si
abbrevia con 2 μs.
Un milionesimo di secondo è detto un microsecondo. La lettera greca  è usata al posto
della parola micro e la lettera s è usata al posto di secondo. Questa scrittura è più comoda
per scrivere e prendere appunti, poiché, invece di scrivere 2 microsecondi, potete scrivere 2
s.
Ricordate: un millesimo di secondo è detto un millisecondo, e si abbrvia ms.
Infatti: 1 ms = 1000 s. In altre parole, potete far entrare mille milionesimi di un secondo in
un millesimo di secondo.
Adesso che sappiamo come usare il comando PULSOUT, CentraServo.bs2 invia
ripetutamente impulsi di controllo per far mantenere al servo la sua posizione di 90°. Il
comando PULSOUT 14, 750 invierà un impulso da 1.5 ms al servo. Ciò avviene perché
l’argomento Durata del comando PULSOUT specifica il numero di unità da 2 μs per cui
deve durare l’impulso. Poiché l’argomento Durata è 750, il comando PULSOUT farà
durare l’impulso per 750 × 2 μs = 1500 μs, che è uguale a 1,5 ms, dato che ci sono 1000
μs in 1 ms. Dopo aver spedito l’impulso alto, il comando PULSOUT lascia che il pin I/O
invii un segnale basso. Quindi, un comando PAUSE 20 dopo il PULSOUT fa inviare al
BASIC Stamp un segnale basso per 20 ms. Con entrambi questi comandi entro un ciclo
DO...LOOP, il segnale alto da 1.5 ms seguito dal segnale basso da 20 ms si ripeterà di
nuovo all’infinito per far mantenere al servo la sua posizione.
Programma esempio: CentraServo.bs2
' Che cos’è un microcontrollore - CentraServo.bs2
' Mantiene il servo nella sua posizione centrale di 90 gradi.
' {$STAMP BS2}
' {$PBASIC 2.5}
DEBUG "Programma in esecuzione!", CR
DO
PULSOUT 14, 750
PAUSE 20
LOOP
Prova della posizione “centrale” a 90° di un servo
La posizione a 90° di un servo è chiamata la sua posizione centrale poiché il punto a 90°
è nel “centro” dell’intervallo di movimento di 180° di un servo. Gli impulsi da 1,5 ms
fanno mantenere al servo il suo quadrilatero in questa posizione centrale, che dovrebbe
essere vicina al punto medio che avete determinato trovando i limiti meccanici del servo.
Per i 90°, potete anche usare qualsiasi posizione centrale il servo mantiene, come vostro
riferimento, oppure rimuovere con un cacciavite e riposizionare il quadrilatero in modo
che i 90° facciano puntare dritto in avanti il cavallotto di filo arrotolato. Le istruzioni per
far questo verranno date nel paragrafo intitolato: Opzionale – Regolazione del
quadrilatero di un servo ai 90° centr. Se usate la posizione centrale come riferimento
senza regolarla, qualsiasi altra posizione che il servo mantiene sarà relativa (riferita) a
quella posizione a 90°. Ad esempio, la posizione a 45° sarebbe 1/8 di un giro in senso
orario a partire da essa, e la posizione a 135° sarebbe 1/8 di un giro in senso antiorario.
Esempi di questo sono stati mostrati nella Figura 4-14 a pagina 110.
Troviamo la posizione centrale effettiva del vostro servo:
 Girate delicatamente il quadrilatero del servo fino ad uno dei suoi limiti
meccanici.
 Ricollegate energia alla vostra scheda. Se avete una Board of Education,
assicuratevi di far scorrere l’interruttore a 3-posizioni completamente a destra
(sulla posizione-2).
 Eseguite CentraServo.bs2.
Non appena il programma è caricato ed eseguito, il quadrilatero del servo dovrebbe
ruotare nella sua posizione centrale e rimanere là. Il servo “mantiene” questa posizione,
poiché i servo standard sono progettati per resistere alle forze esterne che premono contro
di loro. E’ questo il motivo per cui il servo mantiene la sterzata di una automobile RC, il
timone di una barca, o i piani di controllo di un aeroplano in posizione.
 Annotate la posizione centrale del vostro servo.
 Applicate una leggera pressione di rotazione al quadrilatero come avete fatto
mentre ruotavate il servo per trovarne i limiti meccanici. Il servo dovrebbe
resistere e mantenere il suo quadrilatero nella posizione centrale.
Se scollegate energia, potete ruotare il servo lontano dalla sua posizione centrale.
Quando ricollegate energia, il programma ripartirà, e il servo muoverà immediatamente il
quadrilatero indietro alla sua posizione centrale e lo manterrà in quella posizione.
 Provate!
Opzionale – Regolazione del quadrilatero di un servo ai 90° centrali
Potete opzionalmente regolare il quadrilatero del vostro servo in modo che faccia puntare
il cavallotto di filo arrotolato dritto in alto quando state eseguendo il programma
CentraServo.bs2, come fa nel lato destro della Figura 4-17. Se fate questa regolazione
meccanica, ciò agevolerà il tracciamento degli angoli del servo poiché ciascun angolo
somiglierà a quelli riportati in Figura 4-13 a pagina 109.
Per questa regolazione opzionale avrete bisogno di un cacciavite Phillips #2.
Alberino
di uscita
Vite
Phillips
Figura 4-17
Cantraggio
meccanico del
servo
Potete rimuovere e
riposizionare il
quadrilatero del
servo sull’alberino di
uscita con un
piccolo cacciavite.
Quadrilatero
 Rimuovete la vite che serra il quadrilatero del servo al suo alberino di uscita, poi
estraete, tirandolo delicatamente, il quadrilatero dal suo supporto per liberarlo.
Le vostre parti dovrebbero apparire come nel lato sinistro della Figura 4-17.
 Ricollegate energia alla vostra scheda. Il programma dovrebbe far mantenere al
servo il suo alberino di uscita in posizione centrale.
 Fate scorrere il quadrilatero di nuovo sull’alberino di uscita del servo in modo
che il pezzo di filo arrotolato punti dritto in alto come fa nel lato destro della
Figura 4-17.
Offset dell’allineamento: Potrebbe non essere possibile ottenere un allineamento perfetto
per il modo in cui il quadrilatero si caletta sull’alberino di uscita, ma dovrebbe essere
abbastanza prossimo alla perfezione. Potrete allora regolare il loop di filo per compensare
questo piccolo offset e fare in modo che lo spezzone di filo punti proprio in alto.
 Stringete nuovamente la vite Phillips.
 Ricollegate energia in modo che il programma faccia mantenere al servo ancora
una volta la sua posizione centrale. Lo spezzone di filo arrotolato dovrebbe ora
puntare dritto verso l’alto (o quasi dritto) indicando così la posizione a 90°.
Il vostro turno – Programmi per far puntare il servo in diverse direzioni
La Figura 4-18 mostra pochi comandi PULSOUT che dicono al servo di mantenere alcune
posizioni principali, come 0°, 45°, 90°, 135°, e 180°. Questi comandi PULSOUT sono
approssimati, e potrete dover regolare leggermente i valori per ottenere posizioni angolari
più precise. Potete modificare l’argomento Durata del comando PULSOUT per mantenere
qualsiasi posizione di quest’intervallo. Per esempio, se volete che il servo mantenga la
posizione 30°, l’argomento Durata del vostro comando PULSOUT dovrebbe essere 417, che
è 2/3 dell’intervallo di argomenti Durata tra 250 (0°) e 500 (45°).
Le durate di impulso in Figura 4-18 porteranno il quadrilatero del servo vicino agli
angoli indicati, ma questi non sono necessariamente esatti. Potete fare esperimenti
con diversi valori di Durata del comando PULSOUT per un posizionamento più
preciso.
 Memorizzate una copia di CentraServo.bs2 col nome ProvaPosizioneServo.bs2
 Cambiate l’argomento Durata del comando PULSOUT nel programma da 750 a
500, ed eseguite il programma modificato per verificare che fa mantenere al
servo la sua posizione a 45°.
 Ripetete questa prova degli argomenti Durata del PULSOUT con 1000 (135°), e
417 (30°).
 Provate a predire quale Durata vi occorre nel comando PULSOUT per una
posizione non elencata in Figura 4-18, e fate la prova per assicurarvi che il servo
faccia girare il quadrilatero e mantenga la posizione che desiderate ottenere.
Esempi di posizioni possono essere 60°, 120°, ecc.
Mantenete gli argomenti Durata del PULSOUT del vostro programma nell’intervallo tra
350 e 1150. L’intervallo tra 250 e 1250 è “teorico” ma in pratica il servo potrebbe tentare di
spingersi oltre i suoi limiti meccanici. Ciò può ridurre la vita utile del servo. Se volete
massimizzare l’intervaqllo di movimento del vostro servo, provate accuratamente valori che
siano gradatamente sempre più vicini ai limiti meccanici. Man mano che utilizzate valori di
PULSOUT Durata che fanno posizionare al servo il suo quadrilatero proprio entro i suoi limiti
meccanici, l’usura e il logorio saranno normali piuttosto che eccessivi.
Figura 4-18: Posizioni quadrilatero del Servo, comandi PULSOUT, e durate di impulso in ms
Fate i conti
Per ciascun comando PULSOUT in Figura 4-18, c’è un numero corrispondente di
millisecondi di durata di ciascun impulso. Ad esempio, l’impulso inviato da PULSOUT
14, 417 dura 0.834 ms, e l’impulso inviato da PULSOUT 14, 500 dura 1.0 ms. Se avete
un BASIC Stamp 2 e volete convertire il tempo da millisecondi a Durata per il vostro
comando PULSOUT, usate questa equazione:
Durata
=numero
di msofx 500
D uration
 number
m s  500
Ad esempio, se non conoscete già che l’argomento Durata del PULSOUT per 1.5 ms è 750,
ecco come potete calcolarlo:
Duration  1 .5  500
Durata
 750
La ragione per cui dobbiamo moltiplicare il numero di millisecondi in un impulso per
500, per ottenere un argomento Durata in un PULSOUT, è che Durata è espresso in termini
di unità di 2 μs per un BS2. Quante unità da 2 μs ci sono in 1 ms? Per trovarlo, dividete
semplicemente 1 millesimo per 2 milionesimi.
1
2
11,000  1,000 ,000 2500
——————— ÷ ———————————
1.000
1.000.000
= 500
Se il vostro comando è PULSOUT 14, 500, l’impulso durerà per 500 × 2 μs = 1000 μs =
1.0 ms. (Ricordate, 1000 μs = 1 ms.)
Potete anche prevedere la Durata di un comando PULSOUT sconosciuto con questa
equazione:
DurationDurata
number
of ms
ms
numero
di ms = ————————
ms
500 500
Per esempio, se vedete il comando PULSOUT 14, 850, quanto dura realmente l’impulso
inviato?
numero number
di msof ms  850 ms
500
 1 .7 ms
Scrivere il codice per i diagrammi di temporizzazione
La Figura 4-19 mostra un diagramma di temporizzazione del segnale che il BASIC
Stamp può inviare ad un servo in modo che il suo quadrilatero mantenga una posizione di
135°. Dal momento che il diagramma di temporizzazione produce impulsi ripetuti
separati da segnali bassi di 20 ms, il ciclo DO...LOOP del programma CentraServo.bs2
fornisce un buon punto di partenza, e tutto quello che occorre regolare è la durata degli
impulsi alti. Per calcolare l’argomento Durata di un comando PULSOUT per gli impulsi di
2 ms nel diagramma di temporizzazione, potete usare l’equazione Durata del precedente
paragrafo Fate i conti:
Durata = numero di ms x 500
Duration  number of ms  500
 2.0  500
 1000
Quando si sostituisce 1000 all’argomento Durata del comando PULSOUT, il ciclo di
controlloo del servo dovrebbe somigliare a questo:
DO
PULSOUT 14, 1000
PAUSE 20
LOOP
 Provate questo ciclo DO...LOOP in una copia di CentraServo.bs2 e verificate che
posiziona il quadrilatero del servo a circa 135°.
 Ripetete questo esercizio per il diagramma di temporizzazione in Figura 4-20.
Figura 4-19
Diagramma di
temporizzazione per
la posizione135°
Impulsi da 2 ms
separati da 20 ms
Figura 4-20
Diagramma di
temporizzazione
per la posizione 45°
Impulsi da 1 ms
separati da 20 ms
ATTIVITÀ #3: CONTROLLO DEL TEMPO DI MANTENIMENTO DI UN
SERVO
L’animazione elettronica usa l’elettronica per animare propulsori ed effetti speciali, e in
questo settore i servo sono uno strumento molto comune. La Figura 4-21 mostra un
esempio di progetto di mano robotica animata elettronicamente, con servo che
controllano ciascun dito. Il programma PBASIC che controlla i gesti della mano deve
fare in modo che i servo mantengano le loro posizioni determinate quantità di tempo per
ciascun gesto. Nell’attività precedente, i nostri programmi fanno in modo che il servo
mantenga alcune posizioni indefinitamente. Questa attività introduce il modo per
scrivere codice che fa mantenere al servo alcune posizioni per determinate quantità di
tempo.
Figura 4-21
Mano con animazione elettronica
Ci sono cinque servo nella parte in
basso a destra della figura che
spingono parti di raggi di ruota di
bicicletta avvitati con filettatura entro
le dita e il pollice per farle flettere.
Questo fornisce al BASIC Stamp il
controllo su ciascun dito.
Cicli FOR...NEXT per controllare il tempo per cui un servo mantiene una
posizione
Se scrivete del codice per far lampeggiare un LED una volta al secondo, potete annidare
il codice in un ciclo FOR...NEXT che si ripete tre volte per far lampeggiare la luce per tre
secondi. Se il vostro LED lampeggia cinque volte per secondo, dovete aver fatto sì che il
ciclo FOR...NEXT si ripeta per quindici volte, per ottenere che il LED lampeggi per tre
secondi. Visto che i comandi PULSOUT e PAUSE che controllano il vostro servo sono
responsabili dell’invio di segnali alto/basso, questi comandi fanno anche lampeggiare il
LED. I segnali che abbiamo inviato al servo nell’attività precedente facevano accendere
debolmente il LED, forse con qualche lampeggio apparente, poiché i segnali on/off sono
così veloci, e le durate dei segnali alti così brevi. Rallentiamo i segnali portandoli a
1/10mo della velocità per un lampeggio a luce visibile dell’indicatore LED.
Programma esempio: RallentaSegnaliServoPerLed.bs2
Confrontato con il segnale centra servo, questo programma esempio aumenta di un
fattore dieci le durate di PULSOUT e PAUSE, cosicché li possiamo vedere come luce
lampeggiante dell’indicatore LED. Il ciclo FOR...NEXT del programma si ripete quasi 5
volte al secondo, cosicché 15 ripetizioni producono il risultato di far lampeggiare la luce
per tre secondi.
 Scollegate energia al vostro servo:
o Se avete una scheda Board of Education, ponete l’interruttore a 3
posizioni in posizione 1 per scollegare energia al servo. La posizione 1
fornirà ancora energia al resto del sistema.
o Se avete una scheda BASIC Stamp Homework Board, staccate
temporaneamente l’estremità del filo connesso a Vdd e lasciatelo
volante. Questo toglierà energia al vostro servo.
 Digitate ed eseguite RallentaSegnaliServoPerLed.bs2.
 Verificate che il LED lampeggi rapidamente per circa tre secondi.
 Cambiate il valore finale (EndValue) del ciclo FOR...NEXT da 15 a 30 e
rieseguite il programma. Poiché il ciclo si era ripetuto due volte per ogni
ripetizione, la luce dovrebbe lampeggiare per due volte di più – sei secondi.
 Ricollegate energia al vostro servo:
o Se avete una scheda Board of Education, ponete l’interruttore a 3posizioni di nuovo in posizione-2 per ricollegare energia al servo.
o Se avete una scheda BASIC Stamp Homework Board, reinserite il
terminale del filo che avete scollegato nello zoccolo Vdd.
' Che cos’è un microcontrollore – RallentaSegnaliServoPerLed.bs2
' Rallenta i segnali del servo a 1/10 della velocità che hanno in modo
' che possiamo vedere l’indicatore LED lampeggiare acceso/spento.
' {$STAMP BS2}
' {$PBASIC 2.5}
DEBUG "Programma in esecuzione!", CR
contatore
VAR
Word
PULSOUT 14, 7500
PAUSE 200
NEXT
Programma esempio: TrePosizioniServo.bs2
Se cambiate PULSOUT 14, 7500 in PULSOUT 14, 750 e PAUSE 200 in PAUSE 20,
avrete un ciclo FOR...NEXT che invia brevemente il segnale per la posizione centrale al
servo. Poiché i segnali ora durano 1/10mo della loro durata nel programma
RallentaSegnaliServoPerLed.bs2, l’intero ciclo FOR...NEXT prenderà 1/10mo del tempo
per essere eseguito. Se l’obiettivo è far mantenere al servo una particolare posizione per
tre secondi, rilasciate semplicemente dieci volte gli impulsi di prima
l’argomento ValoreFinale del ciclo FOR...NEXT da 15 a 150.
PULSOUT 14, 750
PAUSE 20
LOOP
aumentando
' Centrale per circa 3 sec.
Il programma esempio TrePosizioniServo.bs2 fa mantenere al servo le tre posizioni
diverse mostrate in Figura 4-22, ciascuna per circa 3 secondi.
Figura 4-22
TrePosizioniServo.bs2
Il programma fa
mantenere al servo
ciascuna posizione
per circa tre secondi.
 Digitate ed eseguite TrePosizioniServo.bs2.
 Verificate che il servo mantiene ciascuna posizione nella sequenza di Figura
4-22 per circa tre secondi.
L’ultima posizione che il servo manterrà per 3 secondi è 135° e poi il programma si
arresta. Il quadrilatero del servo rimarrà nella stessa posizione anche quando il BASIC
Stamp ha finito di inviare impulsi di controllo. La differenza è che durante i tre secondi
nei quali il BASIC Stamp mantiene la posizine di 135°, il servo resiste a qualsiasi forza
che tenta di allontanare il quadrilatero da quella posizione. Dopo che sono passati i 3
secondi, il quadrilatero del servo può essere ruotato a mano.
Un modo in cui potete dire se il servo sta ricevendo segnali di controllo è osservando
l’indicatore LED collegato a P14. Se l’indicatore LED si illumina, significa che il servo
sta ricevendo segnali di controllo e sta mantenendo la sua posizione. Quando il segnale si
ferma vedrete che l’indicatore LED non è più illuminato.
 Rieseguite il programma (o premete e rilasciate solo il pulsante di Reset della
vostra scheda).
 Non appena il servo si porta in posizione 135°, date un’occhiata all’ìindicatore di
segnale a LED mentre applicate una leggera forza di torsione al quadrilatero.
Dovreste riuscire a sentire il servo che resiste, mentre il LED si illumina debolmente
indicando che il servo sta ricevendo ancora un segnale di controllo. Non appena il LED
si spegne indicando che il segnale di controllo si è fermato, il servo smetterà di mantenere
la sua posizione, e riuscirete a ruotare il quadrilatero.
 Quando il segnale dei 135° si arresta, verificate che il LED indica che il segnale
si è arrestato e che il servo vi permette di ruotare il quadrilatero allontanandolo
dalla posizione a 135°.
' Che cos’è un microcontrollore – TrePosizioniServo.bs2
' Il servo mantiene le posizioni di 45, 90, e 135 gradi ciascuna
' per circa 3 secondi.
' {$STAMP BS2}
' {$PBASIC 2.5}
contatore
VAR
Word
PAUSE 1000
DEBUG "Posizione = 45 gradi...", CR
PULSOUT 14, 500
PAUSE 20
NEXT
' 45 gradi per circa 3 sec.
PULSOUT 14, 750
PAUSE 20
NEXT
PULSOUT 14, 1000
PAUSE 20
NEXT
DEBUG "Tutto fatto.", CR, CR
END
Il vostro turno – Regolare posizione vs. regolare tempo di mantenimento
TrePosizioniServo.bs2 fa l’ipotesi che eseguire 50 impulsi del servo in un ciclo
FOR...NEXT impieghi circa 1 secondo. Potete usare questa caratteristica anche per
regolare l’argomento ValoreFinale del ciclo FOR...NEXT. Ad esempio, se volete che il
servo mantenga soltanto la sua posizione all’incirca per due secondi, cambiate
l’argomento ValoreFinale da 150 a 100. Per cinque secondi, cambiatelo da 150 a 250, e
così via…
 Memorizzate una copia di TrePosizioniServo.bs2.
 Modificate l’argomento ValoreFinale di ciascun ciclo FOR...NEXT e sperimentate
con valori diversi per avere diversi tempi di mantenimento.
 Opzionale: Personalizzate il mantenimento delle posizioni variando l’argomento
Durata di ciascun comando PULSOUT.
Tempo di ripetizione del ciclo FOR...NEXT – In realtà è 1/44mo di secondo, non
1/50mo
1/50mo di secondo è una approssimazione grezza della ripetizione del ciclo. 1/44mo di
secondo è un’approssimazione molto più precisa. Considerate quanto tempo in più
ciascun elemento del ciclo FOR...NEXT impiega per la sua esecuzione. Il comando
PULSOUT 14, 750 è al centro dell’intervallo delle possibili durate di impulso, cosicché
può essere il punto di riferimento per la durata media dell’impulso. Questo comando
invia un impulso che dura 750 × 2 μs = 1500 μs = 1,5 ms. Il comando PAUSE 20 fa
ritardare il programma di 20 ms. Un ciclo FOR...NEXT con una coppia di comandi
PULSOUT e PAUSE impiega circa 1,3 ms per elaborare tutti i numeri e i comandi. Sebbene
ciò significhi che il segnale basso tra gli impulsi dura in realtà 21,3 ms invece di 20 ms,
questo fatto non influenza la prestazione del servo. I tempi per i quali il segnale è basso
possono durare pochi ms di meno, sono invece le durate degli impulsi alti che devono
essere precise, e il comando PULSOUT è molto preciso.
Quindi, il tempo totale che impiega il ciclo FOR...NEXT per ripetersi è 1,5 ms + 20 ms +
1,3 ms = 22,8 ms, che significa 22,8 millesimi di un secondo. Quindi, quanti 22,8millesimi-di-secondo entrano in 1 secondo? Dividiamo 1 per 0,0228 e troviamo:
11 second
secondo ÷ 0.0228
0,00228seconds/re
secondi/ripetizione
petition ≈ 43,86
43.86ripetizioni
repetition s
≈ 44 ripetizioni
 44 repetition s
È per questa ragione che il ciclo si ripete ad una velocità di circa 44 ripetizioni al
secondo. Il numero di ripetizioni in 1 secondo è chiamato hertz, abbreviato in Hz.
Possiamo, quindi, dire che il segnale del servo si ripete o cicla a circa 44 Hz.
Cicli ed hertz (Hz): Quando un segnale si ripete un certo numero di volte, ciascuna
ripetizione è chiamata un ciclo. Il numero di cicli in un secondo è misurato in hertz. Hertz si
abbrevia con Hz.
Un maggiore o minor valore di Durata nel comando PULSOUT fa in modo che il ciclo
FOR...NEXT impieghi un po’ più o un po’ meno tempo a ripetersi. Una Durata del
comando PULSOUT di 750 è proprio a metà dell’intervallo delle durate degli impulsi di
controllo del servo mostrati prima in Figura 4-18 a pagina 117. Quindi, potete usare 44
Hz come punto di riferimento del numero di impulsi al servo in un secondo per il vostro
codice. Se vi occorre essere più precisi, ripetete esattamente la matematica per il
comando PULSOUT che state usando. Per esempio, se il ciclo ha un comando PULSOUT
con una Durata di 1000 invece di 750, prende 2 ms per l’impulso invece di 1,5 ms. Il
ciclo ha ancora una pausa di 20 ms e 1,3 ms di tempo di elaborazione. Quindi questo
fatto aggiunge 2 + 20 + 1,3 ms = 23,3 ms. Dividete 1 secondo per questo valore per
trovare la velocità del ciclo FOR...NEXT, e otterrete 1 ÷ 0,0233 ≈ 42,9 ≈ 43 Hz.
Sommario del ciclo FOR...NEXT di controllo del servo
La Figura 4-23 mostra il ruolo che ciascun numero ha in un ciclo FOR...NEXT per il
controllo del servo. Il valore ValoreFinale del ciclo FOR...NEXT determina il numero di
44mi di secondo che il servo impiega a mantenere una posizione. L’argomento Durata del
comando PULSOUT dice al servo quale posizione deve mantenere. Il valore 750 invia un
impulso di 1,5 ms, che impone al servo di mantenere una posizione di 90°, secondo la
Figura 4-18 a pagina 117. L’argomento Pin del comando PULSOUT sceglie il pin I/O per
inviare segnali di controllo al servo. Quindi, 14 fa sì che il comando PULSOUT invii il suo
breve segnale alto (impulso) al servo collegato al pin I/O P14. Quando l’impulso
termina, lascia che il pin I/O invii un segnale basso. Poi, il comando PAUSE 20 assicura
che il segnale basso duri per circa 20 ms prima dell’impulso successivo.
Pin I/O
Servo
I/O pin
del
servo
Numero
di 44.mi
diof a
Number
of 44ths
secondo
per
mantenere
second to hold the
la posizione
position
PULSOUT 14, 750
PAUSE 20
Position to hold
NEXT
Posizione
da mantenere
Figura 4-23
Ciclo For…Next di
controllo del servo
Required 20 ms
20 ms richiesti tra
between each pulse
ciascuna coppia di
impulsi
In media, un ciclo FOR...NEXT che invia un solo comando PULSOUT ad un servo, seguito
da un comando PAUSE 20, si ripete circa 44 volte al secondo. Poiché questo ciclo si
ripete 132 volte, fa in modo che il servo mantenga la posizione 135° per circa 3 secondi.
Ciò avviene perché:
132132
ripetizioni
÷ 44 sripetizioni/secondo
= 3 secondi
repetition
 44 repetition s/second
 3 seconds
Se la vostra applicazione o progetto deve far si che il BASIC Stamp invii un segnale al
servo per un certo numero di secondi, moltiplicate il numero di secondi per 44, e usate il
risultato come argomento ValoreFinale del vostro ciclo FOR...NEXT. Per esempio, se il
vostro segnale deve durare cinque secondi:
5 secondi
x 44 ripetizioni/secondo
= 220 ripetizioni
5 seconds
44 repetitions/second
220 repetition s
ATTIVITÀ #4: CONTROLLO DI POSIZIONE CON IL VOSTRO COMPUTER
L’automazione industriale spesso implica una comunicazione di microcontrollori con
computer più grandi. I microcontrollori leggono i sensori e trasmettono quei dati al
computer principale. Il computer principale interpreta e analizza i dati del sensore, e
quindi legge le informazioni di posizione restituendole al microcontrollore. Il
microcontrollore potrebbe allora aggiornare la velocità della cinghia di un convogliatore,
o la posizione di una ordinatrice, o alcuni altri compiti meccanici con controllo
motorizzato.
Potete usare il terminale di Debug per inviare messaggi dal vostro computer al BASIC
Stamp come mostrato in Figura 4-24. Il BASIC Stamp dave essere programmato per
ascoltare i messaggi che inviate tramite il terminale di Debug, e deve anche memorizzare
i dati che inviate in una o più variabili.
Tempo esecuzione servo:
44 impulsi in 1 secondo
Posizione servo:
350 <= Durata PULSOUT <= 1150
Digitate il tempo di esecuzione
come numero di impulsi: 132
Digitate la posizione come
Durata PULSOUT: 1000
Il servo è in esecuzione…
FATTO
Figura 4-24
Invio di messaggi al
BASIC Stamp
Cliccate il campo vuoto
sopra la finestrella di
visualizzazione del
messaggio e digitate il
vostro messaggio. Una
copia del messaggio che
avete introdotto appare nella
finestrella inferiore. Questa
copia è detta echo.
In questa attività, programmerete il BASIC Stamp per ricevere due valori dal terminale di
Debug, e poi usare questi valori per controllare il servo:
1. Il numero di impulsi da inviare al servo
2. Il valore Durata usato dal comando PULSOUT
Programmerete anche il BASIC Stamp perché usi questi valori per controllare il servo.
Parti e circuito
Gli stessi della attività #2.
Programmazione del BASIC Stamp per ricevere messaggi da Debug
La programmazione del BASIC Stamp per inviare messaggi al terminale di Debug si
effettua tramite il comando DEBUG. La programmazione del BASIC Stamp per ricevere
messaggi dal terminale di Debug si fa tramite il comando DEBUGIN. Quando usate il
DEBUGIN, dovretre dichiarare anche una o più variabili per far memorizzare al BASIC
Stamp le informazioni che riceve.
Ecco un esempio di variabile che potete dichiarare perché il BASIC Stamp memorizzi un
valore:
impulsi VAR Word
Più avanti nel programma, potete usare questa variabile per memorizzare un numero
ricevuto dal comando DEBUGIN:
DEBUGIN DEC impulsi
Quando il BASIC Stamp riceve un valore numerico dal terminale di Debug, lo
memorizzerà nella variabile impulsi. Il formattatore DEC dice al comando DEBUGIN che
i caratteri che state inviando saranno cifre che formano un numero decimale. Non appena
premete il tasto Enter, il BASIC Stamp memorizzerà le cifre che ha ricevuto nella
variabile impulsi come numero decimale, quindi andrà avanti.
Sebbene non sia incluso nel programma esempio, potete aggiungere una riga per
verificare che il messaggio è stato elaborato dal BASIC Stamp.
DEBUG CR, "Avete inviato il valore: ", DEC impulsi
Programma esempio: ControlloServoConDebug.bs2
La Figura 4-25 mostra dove sono la finestrella di Trasmissione e quella di Ricezione nel
terminale di Debug. La finestrella di Ricezione è quella che abbiamo usato fin qui per
visualizzare messaggi che il terminale di Debug “riceve” dal BASIC Stamp. La
finestrella di Trasmissione vi consente di digitare caratteri e numeri e “trasmetterli” al
BASIC Stamp.
Figura 4-25
Finestrelle del terminale di Debug
← Finestrella di Trasmissione
← Finestrella di Ricezione
In Figura 4-25, il numero 264 è digitato nella finestrella di Trasmissione del terminale di
Debug. Sotto, nella finestrella di Ricezione, è mostrata una copia del valore 264 dopo il
messaggio “Digitate il tempo di esecuzione …”. Questa copia è detta eco, e visualizza
nella finestrella di ricezione soltanto se la casella di spunta Echo Off del terminale di
Debug è lasciata non marcata.
Eco è quando inviate un messaggio tramite la finestrella di Trasmissione del terminale di
Debug, e una copia di quel messaggio appare nella finestrella di Ricezione del terminale di
Debug. Nell’angolo inferiore destro del terminale di Debug c’è una casella di spunta Echo
Off, e potete cliccarvi sopra per alterarne il suo contrassegno. Per questa attività, vogliamo
visualizzare gli echi nella finestrella di ricezione, quindi la casella di spunta Echo Off deve
essere lasciata non marcata.
 Digitare ControlloServoConDebug.bs2 nell’Editor del BASIC Stamp ed
eseguitelo.
 Se la finestrella di trasmissione è troppo piccola, ridimensionatela usando il
mouse: cliccate trattenete e trascinate il separatore verso il basso. Il separatore è
mostrato proprio sopra il messaggio di testo “Digitate il tempo di esecuzione” in
Figura 4-25.
 Assicuratevi che la casella di spunta Echo Off nell’angolo in basso a destra sia
non marcata.
 Cliccate la parte superiore della finestrella di Trasmissione per porvi il vostro
cursore e digitare i messaggi.
 Quando il terminale di Debug vi chiederà di “Digitare il tempo di esecuzione
come numero di impulsi:”, digitate il numero 132, poi premete il tasto Enter sulla
tastiera del vostro computer. Per la tastiera italiana Enter è Invio.
 Quando il terminale di Debug vi chiederà di “Digitare la posizione come durata
PULSOUT:”, digitate il numero 1000, quindi premete Enter.
La Durata di PULSOUT deve essere un numero tra 350 e 1150. Se inserite numeri fuori
da quell’intervallo, il programma li cambierà con il numero più vicino entro quell’intervallo, o
350 o 1150. Se il programma non avesse questa caratteristica di sicurezza, potrebbero
venir inseriti numeri che tenterebbero di far ruotare il servo ad una posizione oltre i suoi
limiti meccanici. Sebbene questo non danneggerebbe il servo, potrebbe accorciare la vita
del dispositivo.
Il BASIC Stamp visualizzerà il messaggio “Servo in esecuzione …” mentre sta inviando
impulsi al servo. Quando ha completato l’invio di impulsi al servo, visualizzerà il
messaggio “FATTO” per un secondo. Quindi, vi chiederà di digitare di nuovo il numero
di impulsi. Divertitevi con questo programma, ma accertatevi di seguire la direttiva nel
riquadro Avvertenze sul fatto che il valore del vostro PULSOUT sia tra 350 e 1150.
 Sperimentate digitando valori diversi tra 350 e 1150 per la Durata di PULSOUT e
valori tra 1 e 65534 per il numero di impulsi.
Ci vogliono circa 44 impulsi per far mantenere al servo una posizione per 1 secondo.
Quindi, per far mantenere al servo una posizione per circa 5 minuti, potete digitare 13200
alla domanda “numero di impulsi”. Cioè 44 impulsi/secondo × 60 secondi/minuto × 5 minuti
= 13.200 impulsi.
Perché usare valori da 1 a 64434? Se volete realmente saperlo, leggete completamente il
capitolo su FOR...NEXT nel Manuale BASIC Stamp per imparare cosa sia l’errore di
rollover a 16-bit, o errore di intervallo di variabile Può causare un problema durante la
costruzione dei vostri programmi!
' Che cos’è un microcontrollore - ControlloServoConDebug.bs2
' Invia messaggi al BASIC Stamp per controllare un servo usando
' il terminale di Debug.
' {$STAMP BS2}
' {$PBASIC 2.5}
contatore
impulsi
durata
VAR
VAR
VAR
Word
Word
Word
PAUSE 1000
DEBUG CLS, "Tempo esecuzione Servo:", CR,
" ~44 impulsi in 1 secondo", CR,
" Posizione Servo:", CR,
" 350 <= Durata PULSOUT <= 1150", CR, CR
DO
DEBUG "Digitate il tempo di esecuzione ", CR,
"come numero di impulsi: "
DEBUGIN DEC impulsi
DEBUG "Digitate la posizione come ", CR,
"Durata PULSOUT: "
DEBUGIN DEC durata
durata = durata MIN 350 MAX 1150
DEBUG "Servo in esecuzione...", CR
FOR contatore = 1 TO impulsi
PULSOUT 14, durata
PAUSE 20
NEXT
DEBUG "FATTO", CR, CR
PAUSE 1000
LOOP
Come lavora ControlloServoConDebug.bs2 Works
In questo programma sono state dichiarate tre variabili:
contatore
impulsi
durata
Var
Var
Var
WORD
WORD
WORD
La variabile contatore è dichiarata per usarla in un ciclo FOR...NEXT. (Vedi pagina
46 per i dettagli.) Le variabili impulsi e durata sono usate in due modi diversi. Sono
usate sia per ricevere che per conservare valori inviati dal terminale di Debug. La
variabile impulsi è usata anche per impostare il numero di ripetizioni nel ciclo
FOR...NEXT che invia impulsi al servo, e la variabile durata è usata per impostare la
durata di ciascun impulso nel comando PULSOUT.
Un comando DEBUG fornisce un promemoria per ricordare che ci sono circa 44 impulsi in
1 secondo nel ciclo FOR...NEXT, e che l’argomento Durata del PULSOUT che controlla la
posizione del servo può essere un valore tra 350 e 1150.
DEBUG CLS, "Tempo esecuzione servo:", CR,
" Positione Servo:", CR,
Il resto del programma è annidato entro un DO...LOOP senza argomento WHILE o UNTIL
Condizione, per cui i comandi sono eseguiti ripetutamente all’infinito.
DO
' Resto del programma non mostrato.
LOOP
Il comando DEBUG è usato per inviare a voi (che siete gli “utenti” del software) un
messaggio per farvi inserire il numero di impulsi. Poi, il comando DEBUGIN aspetta
l’inserimento delle cifre del numero e la pressione del tasto Enter sulla vostra tastiera. Le
cifre che inserite sono convertite in un valore memorizzato nella variabile impulsi.
Questo processo è ripetuto con una seconda coppia di comandi DEBUG e DEBUGIN che
caricano un altro valore da inserire anche nella variabile durata.
DEBUG "Digitate tempo di esecuzione ", CR,
DEBUGIN DEC impulsi
DEBUG "Digitate la posizione come ", CR,
"Durata PULSOUT: "
DEBUGIN DEC durata
Dopo aver inserito il secondo valore, è utile visualizzare un messaggio mentre il servo è
in esecuzione perché non tentiate di inserire un secondo valore durante quel tempo:
Mentre il servo è in esecuzione, potete provare a muovere gentilmente il quadrilatero del
servo allontanandolo dalla posizione che sta mantenendo. Il servo resiste alla leggera
pressione applicata al suo quadrilatero.
FOR Contatore = ValoreIniz TO Valore Finale {STEP ValorePasso}...NEXT
Questa è la sintassi del ciclo FOR...NEXT dal Manuale BASIC Stamp. Essa mostra che vi
occorrono un Contatore, un ValoreIniz e un ValoreFinale per controllare quante volte il
ciclo ripete se stesso. C’è anche un opzionale ValorePasso se volete aggiungere un
numero diverso da 1 al valore di Contatore ciascuna volta che il ciclo è ripetuto.
Come negli esempi precedenti, la variabile contatore è stata usata per tener conto delle
ripetizioni del ciclo FOR...NEXT. A parte la variabile contatore, questo ciclo
FOR...NEXT introduce alcune nuove tecniche che utilizzano le variabili per definire come
si comporta il programma (e il servo). Fino a questo esempio, i cicli FOR...NEXT hanno
usato, come argomento ValoreFinale (EndValue) del ciclo, costanti come 10 o 132. In
questo ciclo FOR...NEXT, per controllare l’argomento EndValue del ciclo FOR...NEXT è
usato il valore della variabile impulsi. Quindi impostate il valore di impulsi
introducendo un numero nel terminale di Debug, e questo controlla il numero delle
ripetizioni fatte dal ciclo FOR...NEXT, che a sua volta controlla il tempo per il quale il
servo mantiene una determinata posizione.
FOR contatore = 1 to impulsi
PULSOUT 14, durata
PAUSE 20
NEXT
Inoltre, negli esempi precedenti, come argomento Durata del comando PULSOUT erano
stati usati valori costanti come 500, 750, e 1000. In questo ciclo, una variabile chiamata
durata, che impostate introducendo i valori nella finestrella di Trasmissione del
terminale di Debug, definisce ora la durata di impulso del comando PULSOUT, che a sua
volta controlla la posizione mantenuta dal servo.
Prendete del tempo per comprendere
ControlloServoConDebug.bs2.
il
ciclo
FOR…NEXT
nel
programma
E’ uno dei primi esempi delle meravigliose cose che potrete fare con le variabili negli
argomenti e nei cicli dei comandi PBASIC, ed inoltre evidenzia quanto possa essere utile un
modulo microcontrollore programmabile come il BASIC Stamp.
Il vostro turno – Impostare i limiti nel software
Immaginate che questo sistema computerizzato di controllo del servo sia stato sviluppato
per il controllo a distanza. Forse un agente della sicurezza lo utilizzerà per aprire una
porta di imbarco che sta controllando su una telecamera remota. Forse uno studente di un
college lo userà per controllare le porte di un labirinto nel quale un topo naviga in cerca
di cibo. Forse un artigliere militare lo userà per puntare il cannone su un determinato
bersaglio. Se state progettando un prodotto per farlo usare a qualcun altro, l’ultima cosa
che vorrete è dare all’utente (agente della sicurezza, studente di college, artigliere
militare) la capacità di inserire un numero sbagliato che potrebbe danneggiare
l’apparecchiatura.
Mentre eseguite ControlloServoConDebug.bs2, è possible che facciate un errore
digitando il valore di Durata nel terminale di Debug. Diciamo che avete digitato per caso
100 invece di 1000 e avete premuto Enter. Il valore 100 potrebbe far in modo che il servo
tenti di girare ad una posizione che è oltre i suoi limiti meccanici. Sebbene ciò non
produce un danno istantaneo al servo, è certamente non buono per il servo o per la sua
vita utile. Quindi il programma ha una riga che previene qualsiasi danno prodotto da
questo errore:
durata = durata MIN 350 MAX 1150
Questo comando correggerà il valore 100 introdotto per caso cambiando il valore della
variabile durata a 350. Analogamente, se avete digitato per caso 10000, il programma
ridurrebbe la variabile durata a 1150. Potreste fare quaolcosa di equivalente con un paio
di istruzioni IF...THEN:
IF durata < 350 THEN durata = 350
IF durata > 1150 THEN durata = 1150
Ci sono alcune machine dove perfino la correzione automatica al valore più vicino
potrebbe avere risultati non desiderabili. Ad esempio, se siete su un computer che sta
controllando una macchina che taglia alcuni tipi di materiale molto costoso, potreste non
volere necessariamente che la macchina assuma proprio 350 quando avete tentato di
digitare 1000, ma per caso avete digitato 100. Se essa taglia il materiale proprio alla
posizione impostata al valore 350, ciò potrebbe rivelarsi un errore molto costoso. Quindi,
un altro approccio che il programma può assumere è di dire semplicemente che il vostro
valore è fuori dall’intervallo, e di riprovare a digitarlo. Ecco un esempio di come potete
modificare il codice per far questo:
 Memorizzate il programma esempio ControllaServoConDebug.bs2 sotto il
nuovo nome ControllaServoConDebugVostroTurno.bs2.
 Sostituite queste due istruzioni:
DEBUG "Digita posizione come ", CR,
" Durata PULSOUT: "
DEBUGIN DEC durata
…con questo blocco di codice:
DO
DEBUG "Digita posizione come ", CR,
" Durata PULSOUT: "
DEBUGIN DEC durata
IF durata < 350 THEN
DEBUG "Valore di durata dev’essere almeno 350", CR
PAUSE 1000
ENDIF
IF durata > 1150 THEN
DEBUG "Valore di durata non può superare 1150", CR
PAUSE 1000
ENDIF
LOOP UNTIL durata >= 350 AND durata <= 1150
 Memorizzate il programma.
 Eseguitelo e verificate che si ripete fin quando non digitate un valore
nell’intervallo corretto da 350 a 1150.
ATTIVITÀ #5: CONVERSIONE DA POSIZIONE A MOVIMENTO
In questra attività, programmerete il servo perché cambi posizione a diverse velocità.
Cambiando la posizione a velocità diverse, farete in modo che il quadrilatero del vostro
servo ruoti a diverse velocità. Potete usare questa tecnica per fare in modo che il servo
controlli il movimento invece che la posizione.
Programmazione di velocità di cambio della posizione
Potrete usare un ciclo FOR...NEXT per far variare al servo il movimento entro un
intervallo, come questo:
PULSOUT 14, contatore
PAUSE 20
NEXT
Il ciclo FOR...NEXT fa in modo che il quadrilatero del servo parta a circa 45° e poi ruoti
lentamente in senso antiorario fino a raggiungere 135°. Poiché contatore è l’indice del
ciclo FOR...NEXT, questo aumenta di uno per ogni ripetizione. Il valore di contatore è
usato anche nell’argomento Durata del comando PULSOUT, il ché vuol dire che la durata
di ciascun impulso diventa un po’ più grande ad ogni ripetizione del ciclo. Poiché il
valore della variabile contatore cambia, lo stesso avviene per la posizione del
quadrilatero del servo.
I cicli FOR...NEXT hanno un argomento opzionale STEP ValorePasso. L’argomento
ValorePasso può essere utilizzato per far ruotare il servo più rapidamente. Per esempio,
potete usare l’argomento ValorePasso per aggiungere 8 a contatore ad ogni ripetizione
del ciclo (invece di 1) modificando l’istruzione FOR in questo modo:
FOR contatore = 500 TO 1000 STEP 8
Potete anche far ruotare il servo nella direzione opposta contando all’indietro invece di
contare in avanti. In PBASIC, i cicli FOR...NEXT conteranno all’indietro (in senso
decrescente) se l’argomento ValoreInizio è maggiore dell’argomento ValoreFine. Ecco un
esempio di come far contare un ciclo FOR...NEXT da 1000 fino a 500:
Potete combinare il conteggio all’indietro con un argomento ValorePasso per far ruotare
il servo più rapidamente in senso antiorario in questo modo:
Il trucco per far ruotare il servo a diverse velocità è utilizzare questi cicli FOR...NEXT per
contare in avanti e indietro con differenti misure del passo. Il programma esempio che
segue usa queste tecniche per far ruotare il quadrilatero del servo all’indietro e in avanti
con diverse velocità.
Programma Esempio: VelocitàServo.bs2
 Digitate ed eseguite VelocitàServo.bs2.
 Mentre il programma è in esecuzione, osservate come cambia il valore di
contatore nel terminale di Debug.
 Inoltre, osservate come il servo si comporta differentemente nei due diversi cicli
FOR...NEXT. Sia la direzione che la velocità del quadrilatero del servo
cambiano.
' Che cos’è un microcontrollore - VelocitàServo.bs2
' Ruota il servo lentamente in senso antiorario, poi rapidamente in senso
' orario.
' {$STAMP BS2}
' {$PBASIC 2.5}
contatore
VAR
Word
PAUSE 1000
DO
DEBUG "Larghezza impulso aumentata di 8", CR
PAUSE 7
DEBUG DEC5 contatore, CR, CRSRUP
NEXT
DEBUG CR, "Larghezza impulso diminuita di 20", CR
PAUSE 7
NEXT
DEBUG CR, "Ripeti", CR
LOOP
Come lavora VelocitàServo.bs2
Il primo ciclo FOR...NEXT conta in avanti da 500 a 1000 in passi di 8. Poiché la
variabile contatore è usata come argomento Durata del comando PULSOUT, la posizione
del quadrilatero del servo ruota in senso antiorario in passi che sono otto volte maggiori
del passo più piccolo possibile.
PAUSE 7
NEXT
Perché PAUSE 7 invece di PAUSE 20? Il comando DEBUG DEC5 contatore, CR,
CRSRUP impiega circa 8 ms per essere eseguito. Ciò significa che PAUSE 12 manterrà il
ritardo di 20 ms tra gli impulsi. Alcune prove ed esperimenti hanno mostrato che PAUSE 7
aveva dato al servo il movimento più dolce. Poiché il basso tempo di 20 ms tra gli impulse
del servo non occorreva fosse più preciso, va bene per la messa a punto e la regolazione.
Un maggior numero di formattatori DEBUG e caratteri di controllo sono stati inseriti nel
comando DEBUG che visualizza il valore della variabile contatore. Questo valore è
stampato usando il formato decimale a 5 cifre (DEC5). Dopo aver stampato il valore, c’è un
ritorno carrello (CR). Dopo di questo, il carattere di controllo CRSRUP (“cursor up”, cursore in
alto) manda il cursore indietro alla riga precedente. Ciò fa in modo che il nuovo valore di
contatore sia stampato sopra il valore vecchio ad ogni ripetizione del ciclo.
Il secondo ciclo FOR...NEXT conta all’indietro da 1000 fino a 500 in passi di 20. In
questo esempio, la variabile contatore è utilizzata anche come argomento del comando
PULSOUT, quindi il quadrilatero del servo ruota in senso orario.
PAUSE 7
NEXT
Il vostro turno – Regolazione delle velocità
 Provate valori diversi di STEP per far ruotare il servo a diverse velocità.
 Dopo ciascuna modifica rieseguite il programma.
 Osservate l’effetto di ciascun nuovo valore di ValorePasso su quanto
velocemente ruoti il quadrilatero del servo.
 Sperimentate con valori diversi di Durata nel comando PAUSE (tra 3 e 12) per
trovare il valore che dà al servo il movimento più dolce per ciascun nuovo valore
di ValorePasso.
ATTIVITÀ #6: SERVO CONTROLLATO DA UN PULSANTE
In questo capitolo, avete scritto programmi che fanno eseguire al servo un insieme di
movimenti pre-registrati, ed avete controllato il servo tramite il terminale di Debug.
Potete anche programmare il BASIC Stamp perché controlli il servo basandosi su ingressi
provenienti da un pulsante. In questa attività:

Costruirete un circuito per controllare il servo con un pulsante.

Programmerete il BASIC Stamp perché controlli il servo basandosi sugli ingressi
di un pulsante.
Quando avete finito, sarete capaci di ottenere dal BASIC Stamp che ruoti il servo in una
direzione premendo e tenendo premuto uno dei pulsanti, e che ruoti il servo nell’altra
direzione premendo e tenendo premuto l’altro pulsante. Quando invece non si preme
alcun pulsante, il servo manterrà qualsiasi posizione abbia raggiunto per ultima.
Parti extra per il controllo del servo con pulsanti
Sono ancora utilizzate le stesse parti che abbiamo impiegato nelle precedenti attività di
questo capitolo. In aggiunta, per i circuiti a pulsante vi occorreranno le seguenti parti:
(2) Pulsanti – normalmente aperti
(2) Resistenze – 10 kΩ (marrone – nero – arancio)
(2) Resistenze – 220 Ω (rosso – rosso – marrone)
Aggiunta del circuito di controllo a pulsante
La Figura 4-26 mostra i circuiti a pulsante che userete per controllare il servo.
 Aggiungete questo circuito al circuito servo+LED che avete utilizzato fino a
questo punto. Quando lo avrete fatto il vostro circuito dovrebbe assomigliare:
o
o
alla Figura 4-27 se state utilizzando una scheda Board of Education
USB (qualsiasi rev) o Seriale (Rev C o più recente).
alla Figura 4-28 se state utilizzando una scheda BASIC Stamp
HomeWork Board (Rev C o più recente).
 Se la vostra scheda non è elencata qui sopra, fate riferimento a Servo Circuit
Connections scaricato dal sito www.parallax.com/Go/WAM per trovare le
istruzioni di circuito per la vostra scheda.
Vdd
P4
220 
P3
220 
10 k
Vss
10 k
Vdd
Figura 4-26
Circuito a
Pulsanti per il
controllo del
servo
Vss
15 14 Vdd 13 12
White
Red
Black
Red
Black
X4
Vdd
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Figura 4-27
Circuito servo
della Board of
Education con
l’aggiunta dei
circuiti a pulsante
X5
Vin
Vss
+
standard servo
www.parallax.com
Per la Board of
Education Seriale
Rev C o più
recente, o USB di
qualsiasi
revisione
Figura 4-28
Circuito servo
della HomeWork
Board con
l’aggiunta dei
circuiti a pulsante
Per la
HomeWork
Board Rev C o
più recente
 Provate il pulsante connesso a P3 usando la versione originale di
LeggiStatoPulsante.bs2. Il capitolo che contiene questo programma e le
istruzioni su come usarlo inizia a pagina 71.
 Modificate il programma in modo che legga P4.
 Eseguite il programma modificato per provare il pulsante connesso a P4.
Programmare il controllo a pulsante del servo
Si possono usare i blocchi di codice IF...THEN per controllare lo stato dei pulsanti
oppure per aggiungere o sottrarre valori da una variabile chiamata durata. Questa
variabile è usata come argomento Durata del comando PULSOUT. Se viene premuto uno
dei pulsanti, il valore di durata aumenta. Se viene premuto l’altro pulsante, il valore di
durata diminuisce. Per decidere se la variabile durata è troppo grande (maggiore di
1000) o troppo piccola (inferiore a 500) si utilizza una istruzione IF...THEN annidata.
Programma esempio: ControlloServoAPulsanti.bs2
Questo programma esempio fa ruotare il quadrilatero del servo in senso antiorario quando
viene premuto il pulsante connesso a P4. Il quadrilatero del servo sarà mantenuto in
rotazione fino a quando il pulsante è tenuto premuto e il valore di durata è inferiore a
1000. Quando invece si preme il pulsante connesso a P3, il quadrilatero del servo ruota
in senso orario. Il servo è inoltre limitato nel suo movimento in senso orario perché la
variabile durata non può scendere al di sotto di 500. Mentre il programma è in
esecuzione il terminale di Debug visualizza il valore di durata.
 Digitate il programma ControlloServoAPulsanti.bs2 nell’Editor del BASIC
Stamp ed eseguitelo.
 Verificate che il servo ruoti in senso antiorario quando premete e tenete premuto
il pulsante connesso a P4.
 Verificate che appena viene raggiunto o superato il limite di durata > 1000, il
servo interrompe qualsiasi ulteriore rotazione in direzione antioraria.
 Verificate che il servo ruoti in senso orario quando premete e tenete premuto il
pulsante connesso a P3.
 Verificate che appena viene raggiunto o superato il limite di durata < 500, il
servo interrompe qualsiasi ulteriore rotazione in direzione oraria.
'
'
'
'
Che cos’è un microcontrollore - ControlloServoAPulsanti.bs2
Premere e tenere premuto il pulsante P4 per ruotare il servo in senso
orario, o premere e tenere premuto il pulsante connesso a P3 per ruotare
il servo in senso orario.
' {$STAMP BS2}
' {$PBASIC 2.5}
durata
VAR
durata = 750
PAUSE 1000
Word
DO
IF IN3 = 1 THEN
IF durata > 500 THEN
durata = durata - 25
ENDIF
ENDIF
IF IN4 = 1 THEN
IF durata < 1000 THEN
durata = durata + 25
ENDIF
ENDIF
PULSOUT 14, durata
PAUSE 10
DEBUG HOME, DEC4 durata, " = durata"
LOOP
Il vostro turno – Limiti meccanici e limiti di software
I blocchi meccanici del servo evitano che il servo ruoti oltre angoli di circa 0° e 180°, il
che corrisponde ad argomenti di PULSOUT Durata vicini a 250 e 1250.
ControllaServoAPulsanti.bs2 ha inoltre dei limiti software, imposti dalle istruzioni
IF...THEN che vi impediscono di usare un pulsante per ruotare il servo oltre un
determinato punto. A differenza dei limiti meccanici, i limiti software si possono
regolare molto facilmente. Ad esempio, potete consentire al vostro servo con controllo a
pulsanti un intervallo di movimenti molto più largo sostituendo semplicemente qualsiasi
occorrenza di 500 con 350, e qualsiasi occorrenza di 1000 con 1150. Oppure, potrete
dare al vostro servo un intervallo di movimenti molto più stretto sostituendo le
occorrenze di 500 con 650 e le occorrenze di 1000 con 850. Non è necessario che i limiti
software siano simmetrici.
Ad esempio, potreste cambiare i limiti software
dall’intervallo 500–1000 all’intervallo 350–750.
 Sperimentate con diversi limiti software del servo, inclusi gli intervalli da 350 a
1150, da 650 a 850, e da 350 a 750.
 Provate ciascun intervallo di limiti software per essere certi che essi si
comportano come ci si aspetta.
Potete anche cambiare la velocità di rotazione del servo mentre tenete premuto un
pulsante. Ad esempio, se cambiate i due valori 25 nel programma portandoli a 50, il
servo risponderà due volte più velocemente. Alternativamente, potrete cambiarli a 30 per
far rispondere il servo solo poco più velocemente, o a 20 per farlo rispondere poco più
lentamente, o a 10 per farlo rispondere molto più lentamente.
 Provate!
SOMMARIO
Questo capitolo ha introdotto il movimento microcontrollato utilizzando un Servo
Standard Parallax. Un servo è un dispositivo che si muove a una determinata posizione e
la mantiene basandosi su segnali elettronici che riceve. Questi segnali hanno la forma di
impulsi che durano un tempo qualsiasi tra 0,5 e 2,5 ms, e debbono essere inviati
all’incirca ogni 20 ms perché il servo mantenga la sua posizione.
Un programmatore può usare il comando PULSOUT per fare in modo che il BASIC Stamp
invii questi segnali. Poiché, per far mantenere al servo la sua posizione, gli impulsi
debbono essere rilasciati ogni 20 ms, i comandi PULSOUT e PAUSE sono posti di solito in
un certo tipo di ciclo. Per determinare sia il numero di ripetizioni del ciclo, sia
l’argomento Durata del comando PULSOUT, si possono usare variabili o costanti.
In questo capitolo, sono stati presentati molti modi diversi per porre valori entro le
variabili. La variabile può ricevere il valore dal vostro terminale di Debug tramite il
comando DEBUGIN. Il valore della variabile può passare per una sequenza di valori se è
usato come argomento Contatore di un ciclo FOR...NEXT. Questa tecnica può essere
impiegata per far compiere al servo movimenti oscillanti. Si possono usare istruzioni
IF...THEN per controllare pulsanti e aggiungere o sottrarre un valore a/da la variabile
usata come argomento Durata del comando PULSOUT quando viene premuto un
determinato pulsante. Questo permette sia il controllo della posizione sia movimenti
oscillanti a seconda di come viene costruito il programma e come vengono fatti
funzionare i pulsanti.
Domande
1. Quali sono le cinque parti esterne di un servo? Per cosa sono usate?
2. Per far lavorare un servo è richiesto un circuito a LED?
3. Quale comando controlla il tempo in cui è basso il segnale inviato ad un servo?
Quale comando controlla il tempo in cui il segnale è alto?
4. Quali elementi di programma potete usare per controllare la quantità di tempo
per cui un servo mantiene una particolare posizione?
5. Come potete utilizzare il terminale di Debug per inviare messaggi al BASIC
Stamp? Quale comando di programmazione si usa per far ricevere al BASIC
Stamp messaggi dal terminale di Debug?
6. Quale tipo di blocco di codice potete scrivere per limitare l’intervallo di
movimento di un servo?
Esercizi
1. Scrivere un blocco di codice che faccia variare il valore del PULSOUT che
controlla un servo da una Durata di 700 a 800, poi di nuovo a 700, in incrementi
di (a) 1, (b) 4.
2. Aggiungere alla vostra risposta all’esercizio 1b un ciclo annidato FOR...NEXT
in modo che invii dieci impulsi prima di incrementare l’argomento Durata del
comando PULSOUT di 4.
Progetto
1. Modificate ControlloServoConDebug.bs2 in modo che controlli un iterruttore di
blocco. Se l’interruttore di blocco (pulsante P3) è premuto, il terminale di Debug
non deve accettare alcun comando, e deve visualizzare: “Premere il pulsante di
Avvio per avviare l’apparecchiatura.” Quando viene premuto l’interruttore di
avvio (pulsante P4), il programma deve funzionare normalmente. Se si collega e
ricollega energia, il programma si deve comportare come se fosse stato premuto
l’interruttore di blocco.
Soluzioni
D1. 1) Spinotto – connette il servo alle sorgenti di energia e segnale; 2) Cavo –
conduce energia e segnali dallo spinotto entro il servo; 3) Quadrilatero – la parte
mobile del servo; 4) Vite – collega il quadrilatero del servo all’alberino di uscita;
5) Involucro – contiene il motore DC, gli ingranaggi, e i circuiti di controllo.
D2. No, il LED ci aiuta soltanto a vedere cosa sta succedendo con i segnali di
controllo.
D3. Il tempo per cui il segnale è basso è controllato dal comando PAUSE. Il tempo
per cui è alto è controllato dal comando PULSOUT.
D4. Un ciclo FOR...NEXT.
D5. Digitate i messaggi entro la finestrella di trasmissione del terminale di Debug.
Usate il comando DEBUGIN e una variabile per far ricevere i caratteri al BASIC
Stamp.
D6. Sia un’istruzione annidata IF...THEN, sia un comando che usi gli operatori MAX
e MIN per mantenere la variabile in un certo intervallo.
E1.
a) Incrementi di 1
FOR contatore
PULSOUT 14,
PAUSE 20
NEXT
FOR contatore
PULSOUT 14,
PAUSE 20
NEXT
b) Aggiungere STEP 4 ad entrambi i cicli
FOR...NEXT.
= 700 TO 800
contatore
= 800 TO 700
contatore
FOR contatore =
PULSOUT 14,
PAUSE 20
NEXT
FOR contatore =
PULSOUT 14,
PAUSE 20
NEXT
700 TO 800 STEP 4
contatore
800 TO 700 STEP 4
contatore
E2. Supponete di aver dichiarato una variabile impulsi:
FOR contatore =
FOR impulsi =
PULSOUT 14,
PAUSE 20
NEXT
NEXT
FOR contatore =
FOR impulsi =
PULSOUT 14,
PAUSE 20
NEXT
NEXT
700 TO 800 STEP 4
1 TO 10
contatore
800 TO 700 STEP 4
1 TO 10
contatore
P1. Ci sono molte soluzioni possibili, qui ne diamo due.
' Che cos’è un microcontrollore - Cap04Pr01Sol1__IntBlocco.bs2
' Invia messaggi al BASIC Stamp per controllare un servo usando il
' terminale di Debug mentre non è premuto l’interruttore di blocco.
' Contributo di: Professor Clark J. Radcliffe, Department
' of Mechanical Engineering, Michigan State University
' {$STAMP BS2}
' {$PBASIC 2.5}
contatore
impulsi
durata
VAR Word
VAR Word
VAR Word
DO
PAUSE 2000
IF (IN3 = 1) AND (IN4 = 0) THEN
DEBUG "Premi l’interruttore di avvio per avviare il macchinario. ",
CR ,CRSRUP
ELSEIF (IN3 = 0) AND (IN4 = 1) THEN
DEBUG CLS, "Digita il numero di impulsi:", CR
DEBUGIN DEC impulsi
DEBUG "Digita la durata di PULSOUT:", CR
DEBUGIN DEC durata
PULSOUT 14, durata
PAUSE 20
NEXT
DEBUG "FATTO"
PAUSE 2000
ENDIF
LOOP
Qui sotto è riportata una versione che può perfino rilevare se si preme il pulsante
mentre sta inviando un segnale al servo.
Questo è importante per
l’apparecchiatura cui occorra un ARRESTO IMMEDIATO quando si preme
l’interruttore di blocco. Questa versione utilizza la tecnica di attesa che è stata
introdotta nel gioco dei Tempi di Reazione in cap. 3, Attività #53 in tre posti
diversi nel programma. Potrete verificare che il programma smette di inviare un
segnale di controllo al servo rilevando la luce indicatrice di segnale del LED
connesso a P14.
'
'
'
'
Che cos’è un microcontrollore - Cap04Pr01Sol2__IntBlocco.bs2
Invia messaggi al BASIC Stamp per controllare un servo usando
il terminale di Debug fin quando l’interruttore di blocco non è
premuto.
' {$STAMP BS2}
' {$PBASIC 2.5}
contatore
impulsi
durata
PAUSE 1000
VAR
VAR
VAR
Word
Word
Word
DEBUG "Premere l’interruttore di avvio (P4) per avviare
l’apparecchiatura.", CR
DO:LOOP UNTIL IN4 = 1
DEBUG "Premere l’interruttore di blocco (P3) per arrewstare
l’apparecchiatura.", CR
DEBUG CR, CR, "Tempo di esecuzione Servo:", CR,
"Posizione Servo:", CR,
DO
IF IN3 = 1 THEN
DEBUG "Premere Avvio (P4) per avviare l’apparecchiatura.", CR
DEBUG "Press Blocco (P3) per arrestare l’apparecchiatura.", CR
ENDIF
DEBUG "Digitare tempo di esecuzione ", CR,
DEBUGIN DEC impulsi
DEBUG "Digitare posizione ", CR,
"come durata PULSOUT: "
DEBUGIN DEC durata
duration = durata MIN 350 MAX 1150
PULSOUT 14, durata
PAUSE 20
IF IN3 = 1 THEN
DEBUG "Premere Avvio (P4) per avviare l’apparecchiatura.", CR
DEBUG "Premere Blocco (P3) per arrestare l’apparecchiatura.", CR
ENDIF
NEXT
DEBUG "FATTO", CR, CR
PAUSE 1000
LOOP
Misure di rotazione · Pagina 151
Capitolo 5: Misure di rotazione
DISCHI DI REGOLAZIONE E APPARECCHI DI RILEVAMENTO
Molte famiglie hanno manopole a disco (o a quadrante) per controllare l’illuminazione di
una stanza. Ruotate il disco in una direzione, e la luce diventa più intensa; ruotatelo
nell’altra direzione, e la luce si abbassa. I modelli di trenini elettrici usano dischi per
controllare velocità dei motori e direzione. Molte macchine hanno dischi o manopole
rotanti usate per affinare la posizione di lame da taglio e superfici di guida.
Si possono trovare dischi anche nelle apparecchiature audio, dove vengono impiegati per
regolare l’intensità sonora di musica e voci. La Figura 5-1 mostra un semplice esempio
di quadrante-disco con manopola che può essere ruotata per regolare il volume di un
altoparlante. Ruotando la manopola, un circuito interno all’altoparlante cambia, e il
volume della musica che l’altoparlante sta riproducendo cambia. Circuiti analoghi si
trovano all’interno di joystick, e perfino all’interno del servo usato nel Capitolo 4:
Controllo del Movimento.
Figura 5-1
Regolazione di volume in
un altoparlante
LA RESISTENZA VARIABILE SOTTO IL DISCO – UN POTENZIOMETRO
Il dispositivo all’interno di molti dischi-quadranti dei sistemi sonori, di joystick e di servo
è detto potenziometro, che spesso si abbrevia con “pot.” La Figura 5-2 mostra le
immagini di alcuni potenziometri di uso comune. Notate che hanno tutti tre piedini (pin).
Figura 5-2
Alcuni esempi di
potenziometri
La Figura 5-3 mostra il simbolo schematico e il disegno di parte del potenziometro che
userete in questo capitolo. I terminali A e B sono connessi a un elemento resistivo da 10
kΩ. Il terminale W è chiamato terminale mobile, ed è collegato ad un filo che tocca
l’elemento resistivo in qualche zona tra le sue estremità.
Figura 5-3
Simbolo schematico e disegno di
parte del potenziometro
La Figura 5-4 mostra come lavora il terminale mobile (spazzola, dal tipo di movimento)
di un potenziometro. Quando regolate la manopola posta in cima al potenziometro, il
terminale mobile contatta l’elemento resistivo in posti diversi. Quando girate la manopola
in senso orario, la spazzola si avvicina al terminale A, e quando girate la manopola in
senso antiorario, la spazzola si avvicina al terminale B.
Figura 5-4
Regolazione della spazzola
(terminale mobile) del potenziometro
ATTIVITÀ #1: COSTRUZIONE E PROVA DEL CIRCUITO DI UN
POTENZIOMETRO
Ponendo resistenze di valori diversi in serie ad un LED, nel circuito fluirà corrente di
differenti valori. Resistenze più grandi nel circuito LED faranno passare nel circuito
piccole quantità di corrente, e il LED farà luce bassa. Resistenze più picole nel circuito
LED faranno passare maggior corrente nel circuito, e il LED farà più luce. Connettendo i
terminali W ed A del potenziometro, in serie con un circuito LED, potrete usare il
potenziometro per regolare la resistenza del circuito. Questa a sua volta regolerà la
luminosità del LED. In questa attività, userete il potenziometro come resistenza variabile
che userete per cambiare la luminosità del LED.
Parti del circuito a disco
(1) Potenziometro – 10 kΩ
(1) LED – rosso
Costruzione del circuito di prova del potenziometro
La Figura 5-5 mostra un circuito che può servire per regolare la luminosità di un LED
con un potenziometro.
Suggerimento: Se avete problemi nel tenere il potenziometro in posizione sugli zoccoli
della breadboard, controllate le estremità di filo. Se ciascuna ha una piccola piegatura, usate
una pinza con becchi ad ago per stringere i fili e provate poi ad infilare di nuovo il
potenziometro nella breadboard. Quando le gambette del pot sono dritte, possono
mantenere un miglior contatto con gli zoccoli della breadboard.
Figura 5-5
Circuito-prova
PotenzometroLED
Prova del circuito a potenziometro
 Ruotate il potenziometro in senso orario fin quando raggiunge il suo limite
meccanico mostrato in Figura 5-6 (a).
Premere leggermente il pot contro la breadboard mentre ruotate la sua manopola.
Per queste attività, il potenziometro deve essere calettato in modo stabile negli zoccoli della
breadboard. Se non state attenti quando ruotate la manopola, il pot può scollegarsi dagli
zoccoli della breadboard, e questo può produrre misure errate. Quindi, mentre ruotate la
manopola del potenziometro, applicate una piccola pressione verso il basso per mantenerlo
in sede nella breadboard.
Maneggiate con attenzione: Se il vostro potenziometro non continua a ruotare, non
provate a forzarlo. Ruotatelo solo fin quando raggiunge il suo limite meccanico; altrimenti
potrebbe rompersi.
 Ruotate gradualmente il potenziometro in senso antiorario fino alla posizione
mostrata in Figura 5-6 (b), (c), (d), (e), ed (f) notando quanto la luce del LED sia
brillante in ciascuna posizione.
(a)
(c)
(e)
(b)
(d)
(f)
Figura 5-6
Manopola del
potenziometro
Da (a) fino ad (f) è mostrata
la spazzola mobile del
potenziometro (wiper) in
posizioni diverse.
Come lavora il circuito del potenziometro
La resistenza totale del vostro circuito di prova è 220 Ω più la resistenza tra i terminali A
e W del potenziometro. La resistenza tra i terminali A e W aumenta quando la manopola
è regolata ulteriormente in senso orario, e questo fatto riduce di conseguenza la corrente
che attraversa il LED, rendendolo meno luminoso.
ATTIVITÀ #2: MISURA DI UNA RESISTENZA TRAMITE MISURA DEL
TEMPO
Questa attività introduce una nuova parte (componente) chiamata condensatore (o
capacità). Un condensatore si comporta come una batteria ricaricabile che mantiene la
sua carica soltanto per brevi periodi di tempo. Questa attività introduce anche il tempo
RC, che è una abbreviazione di tempo-resistenza-capacità. Il tempo RC è una misura del
tempo che un condensatore impiega a perdere una certa quantità della carica che ha
immagazzinato quando eroga corrente ad una resistenza. Misurando il tempo che un
condensatore impiega a scaricarsi con diversi valori della resistenza e della capacità,
prenderete maggior familiarità con il tempo RC. In questa attività, programmerete il
BASIC Stamp perché carichi un condensatore e quindi misurerete il tempo che il
condensatore impiega a scaricarsi attraverso una resistenza.
Introduzione del condensatore
La Figura 5-7 mostra il simbolo di schema e il disegno di parte per il tipo di condensatore
usato in questa attivitrà. Il valore di capacità è misurato in microfarad (µF), e la loro
misura è di solito stampata sui condensatori.
L’involucro cilindrico di questo particolare condensatore è detto bossolo. Questo tipo di
condensatore, chiamato condensatore elettrolitico, deve essere gestito con attenzione.
 Leggere il riquadro PRECAUZIONE sulla pagina che segue.
PRECAUZIONE: Questo condensatore ha un terminale positivo (+) e uno negativo (-).
Il terminale negativo è il filo che fuoriesce dal bossolo metallico più vicino alla striscia con un
segno negativo (–). Accertatevi sempre di collegare questi terminali come indicato nei
diagrammi circuitali.
Connettere uno di questi condensatori in modo errato può
danneggiarlo. In alcuni circuiti, connettere questo tipo di condensatore in modo errato e poi
dare energia può farlo rompere o persino esplodere.
PRECAUZIONE: Non dare ad un condensatore elettrolitico una tensione maggiore di
quella che può sopportare. La tensione massima sopportabile è stampata su un lato del
bossolo.
PRECAUZIONe: Si raccomanda l’uso di visiere od occhiali di sicurezza.
3300 µ
F
3300 µF
+
Figura 5-7
parte di un condensatore da 3300 µF
-
Prestate molta attenzione ai fili e a
come questi si collegano ai terminali
Positivo e Negativo.
Parti del circuito resistenza e tempo
(1) Condensatore – 3300 µF
(1) Condensatore – 1000 µF
(1) Resistenza – 1 kΩ (marrone-nero-rosso)
(1) Resistenza – 2 kΩ (rosso-nero-rosso)
Costruzione e prova del circuito tempo Resistenza-Capacità (RC)
La Figura 5-8 mostra lo schema del circuito e la Figura 5-9 mostra lo schema di
cablaggio per questa attività. Prenderete misure di tempo utilizzando diversi valori di
resistenza al posto della resistenza marcata Ri.
 Leggete attentamente il riquadro SICUREZZA.
SICUREZZA
Quando collegate il condensatore da 3300 o quello da 1000 F osservate sempre la
polarità. Ricordate, il terminale negativo è il filo che fuoriesce dal contenitore metallico ed è
più vicino alla striscia con stampato un segno negativo (–). Usate la Figura 5-7 per
identificare i terminali (+) e (-).
Il vostro condensatore da 3300 F lavorerà bene in questo esperimento soltanto se vi siete
accertati che i terminali positivo (+) e negativo (-) sono connessi ESATTAMENTE come
mostrato in Figura 5-8 e in Figura 5-9.
Non invertite mai le polarità di alimentazione sul condensatore da 3300 F o su qualsiasi
altro condensatore polarizzato. La tensione sul terminale (+) del condensatore dev’essere
sempre più alta di quella al suo terminale (-). Vss è la tensione più bassa (0 V) sulle schede
Board of Education e BASIC Stamp HomeWork. Collegando il terminale negativo del
condensatore a Vss, siete certi che la polarità attraverso i terminali del condensatore sarà
sempre corretta.
Non applicate mai una tensione al condensatore che superi la tensione massima
indicata sul contenitore.
Indossate visiere protettive oppure occhiali di sicurezza durante questa attività.
Scollegate sempre energia prima di costruire o modificare i circuiti.
Tenete mani e viso lontani da questo condensatore quando l’energia è connessa.
 Con l’energia scollegata, costruite il circuito come indicato iniziando con una
resistenza da 470 Ω nella posizione contrassegnata con Ri.
P7
220 
Ri
3300 µF
Vss
R1 = 470 
R2 = 1 k
R3 = 2 k
R4 = 10 k
Figura 5-8
Schema per la prova
della caduta di tensione
nel tempo-RC
Le quattro diverse
resistenze saranno
utilizzate una alla volta al
posto della Ri nello
schema.
Quattro diverse resistenze saranno utilizzate come la Ri mostrata nello schema. La prima
volta, lo schema sarà costruito e provato con Ri = 470 Ω, e poi, le altre volte, con Ri = 1
kΩ, ecc.
R3
Vdd
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
R2
R1
Vin
Vss
-
33
00
µF
+
R4
+
Figura 5-9
Diagramma di cablaggio
per vedere la caduta di
tensione nel tempo-RC
Accertatevi che il filo
negativo del
condensatore sia
connesso sulla vostra
scheda nello stesso
modo mostrato in questa
figura, con il filo negativo
connesso a Vss.
 Assicuratevi che il filo negativo del condensatore sia connesso alla vostra scheda
proprio nel modo mostrato in questa figura, col filo negativo connesso a Vss.
Esplorando il circuito del tempo-RC con il BASIC Stamp
Sebbene per registrare quanto tempo impieghi la carica del condensatore a scendere ad un
certo livello si possa usare un contasecondi a pulsante (cronometro), il BASIC Stamp può
essere anche programmato per sorvegliare il circuito e darvi una misura di tempo più
consistente.
Programma esempio: RcTimerEsplorato.bs2
 Digitate ed eseguite RcTimerEsplorato.bs2.
 Oservate come il BASIC Stamp carica il condensatore e poi misura il suo tempo
di scarica.
 Registrate il tempo misurato (il tempo di scarica del condensatore) nella riga per
470 Ω della Tabella 5-1.
 Scollegate energia dalla vostra Board of Education o HomeWork Board BASIC
Stamp.
 Rimuovete la resistenza da 470 Ω etichettata Ri in Figura 5-8 e in Figura 5-9 a
pagina 158, e sostituitela con la resistenza da 1 kΩ.
 Ricollegate energia sulla vostra scheda.
 Registrate la vostra successiva misura di tempo (per la resistenza da 1 kΩ).
 Ripetete questi passi per ciascun valore di resistenza che è in Tabella 5-1.
Tabella 5-1: Resistenza e tempo-RC per C = 3300 F
Resistenza ()
Tempo misurato (s)
470
1k
2k
10 k
' Che cos’è un microcontrollore - RcTimerEsplorato.bs2
' Programma temporizzatore di reazione modificato per registrare
' una caduta di tensione per tempo-RC.
' {$STAMP BS2}
' {$PBASIC 2.5}
Contatempo
contatore
PAUSE 1000
VAR
VAR
Word
Nib
DEBUG CLS
HIGH 7
DEBUG " Condensatore in carica...", CR
PAUSE 1000
NEXT
DEBUG CR, CR, "Ora sto misurando il tempo di scarica!", CR, CR
INPUT 7
DO
PAUSE 100
Contatempo = Contatempo + 1
DEBUG ? IN7
DEBUG DEC5 Contatempo, CR, CRSRUP, CRSRUP
LOOP UNTIL IN7 = 0
DEBUG CR, CR, CR, "Il tempo-RC di scarica è stato",
DEC Contatempo, CR,
"decimi di secondo.", CR, CR
END
Come lavora RcTimerEsplorato.bs2
Sono dichiarate due variabili. La variabile Contatempo è usata per tener traccia di
quanto tempo impiega il condensatore a scaricarsi attraverso Ri. La variabile contatore
è usata per contare all’indietro mentre il condensatore si carica.
Contatempo
contatore
VAR
VAR
Word
Nib
Il comando DEBUG CLS cancella il terminale di Debug in modo che non sia ingombrato
da misure successive. HIGH 7 imposta P7 alto e inizia la carica del condensatore, quindi
viene visualizzato il messaggio “Condensatore in carica…”. Dopo di questo, un ciclo
FOR...NEXT conta all’indietro mentre il condensatore si carica. Man mano che il
condensatore si carica, la tensione ai capi dei suoi terminali aumenta verso un valore
qualsiasi tra 3,4 e 4,9 V (a seconda del valore di Ri).
DEBUG CLS
HIGH 7
DEBUG "Condensatore in carica...", CR
PAUSE 1000
NEXT
Un messaggio annuncia quando la caduta inizia ad essere esplorata.
DEBUG CR, CR, "Ora sto misurando il tempo di caduta!", CR, CR
Per consentire che il condensatore si scarichi attraverso la resistenza Ri, il pin I/O è
cambiato da HIGH a INPUT. Come input, il pin I/O non ha alcun effetto sul circuito, ma
può sentire segnali alti o bassi. Non appena il pin I/O rilascia il circuito, il condensatore
si scarica e invia corrente attraverso la resistenza. Mentre il condensatore si scarica, la
tensione ai capi dei suoi terminali diventa sempre più piccola (cade).
INPUT 7
Nel capitolo sui pulsanti, avete usato il BASIC Stamp per rilevare un segnale alto o basso
usando le variabili IN3 e IN4. In quel contesto, un segnale alto era considerato Vdd, e un
segnale basso era considerato Vss. Per il BASIC Stamp, in realtà un segnale alto è una
qualsiasi tensione sopra circa 1,4 V. Naturalmente, potrebbe essere fino a 5 V.
Analogamente, un segnale basso è qualsiasi cosa tra 1,4 V e 0 V. Questo ciclo
DO...LOOP controlla P7 ogni 100 ms fin quando il valore di IN7 cambia da 1 a 0, il ché
indica che la tensione del condensatore cade a 1,4 V.
DO
PAUSE 100
Contatempo = Contatempo + 1
DEBUG ? IN7
DEBUG DEC5 Contatempo, CR, CRSRUP, CRSRUP
LOOP UNTIL IN7 = 0
Quindi è visualizzato il risultato e il programma termina.
DEBUG CR, CR, CR, "Il tempo-RC di caduta è stato ",
DEC Contatempo, CR,
"decimi di secondo.", CR, CR
END
Il vostro turno – Un circuito più veloce
Se per mantenere la carica si usa un condensatore che ha all’incirca un terzo (1/3) della
capacità, la misura del tempo per ciascun valore di resistenza usato nel circuito sarà
ridotta a 1/3. Più avanti, nella successiva attività, userete un condensatore che ha
1/33,000 della capacità! Il BASIC Stamp prenderà ancora le misure di tempo per voi,
usando un comando chiamato RCTIME.
 Togliete energia alla vostra scheda Board of Education o HomeWork Board.
 Sostituite il condensatore da 3300 µF con un condensatore da 1000 µF.
 Accertatevi che la polarità del vostro condensatore sia corretta. Il terminale
negativo dovrebbe essere connesso a Vss.
 Ricollegate energia.
 Ripetete i passi nel capitolo del programma esempio: RcTimerEsplorato.bs2, e
registrate le vostre misure di tempo nella Tabella 5-2.
 Confrontate le vostre misure di tempo con quelle che avete prese
precedentemente in Tabella 5-1. Quanto sono vicine ad 1/3 dei valori delle
misure prese con il condensatore da 3300 µF ?
Tabella 5-2: Resistenza e tempo-RC per C = 1000 F
Resistenza ()
Tempo misurato (s)
470
1k
2k
10 k
ATTIVITÀ #3: LETTURA DI UN QUADRANTE CIRCOLARE CON IL BASIC
STAMP
Nell’Attività #1, come resistenza variabile è stato usato un potenziometro. La resistenza
del circuito variava a seconda della posizione della manopola di regolazione del
potenziometro. Nell’attività #2, è stato usato un cicuito a tempo RC per misurare diverse
resistenze. In questa attività, costruirete un circuito a tempo RC per leggere il
potenziometro, ed usare il BASIC Stamp per prendere le misure dei tempi. Il
condensatore che userai sarà molto piccolo, e le misure di tempo saranno nella gamma
dei microsecondi. Anche se le misure prenderanno durate di tempo molto piccole, il
BASIC Stamp vi darà indicazioni eccellenti della resistenza tra i terminali A e W del
potenziometro che – a loro volta – indicano la posizione della manopola.
Parti occorrenti per leggere il tempo RC con il BASIC Stamp
(1) Condensatore – 0,1 µF
Questi condensatori non hanno terminali + e –. Essi non sono polarizzati. Così, potete
collegarle con sicurezza questi condensatori ad un circuito senza dovervi preoccupare dei
terminali positivo e negativo.
104
0.1 µF
0.01 µF
103
Figura 5-10
Condensatori ceramici
Condensatore da 0.1 µF
(sinistra)
Condensatore da 0.01
µF (destra)
Costruzione di un circuito a tempo RC per il BASIC Stamp
La Figura 5-11 mostra lo schema e il diagramma di cablaggio per il circuito a tempo RC
veloce. Questo è il circuito che userete per controllare la posizione della manopola del
potenziometro con l’aiuto del BASIC Stamp e di un programma PBASIC.
Figura 5-11
Schema e diagramma
di cablaggio per il
circuito a TEMPO RC
con potenziometro del
BASIC Stamp
Programmazione delle misure ti tempo RC
Il programma esempio nell’attività #2 ha misurato il tempo di discesa RC controllando se
IN7 = 0 ogni 100 ms, e ha mantenuto traccia del numero di controlli che ha dovuto fare.
Quando IN7 è cambiato da 1 a 0, il cambiamento ha indicato che la tensione ai capi del
condensatore è scesa a 1,4 V. Il risultato al momento in cui il programma aveva fatto
l’esplorazione era stato che la variabile Contatempo ha memorizzato il numero di decimi
di secondo che ci sono voluti perché il voltaggio del condensatore cadesse ad 1,4 V.
Il successivo programma esempio usa un comando PBASIC chiamato RCTIME che fa
misurare al BASIC Stamp il tempo di scarica RC in termini di unità di 2 μs. Quindi,
invece di decimi di secondo, il risultato che RCTIME 7, 1, tempo memorizza nella
variabile tempo è il numero di unità di due milionesimi di secondo che ci vogliono
perché il voltaggio del condensatore scenda sotto 1,4 V. Poiché il comando RCTIME ha
unità di misura così precise, potete ridurre la dimensione del condensatore da 3300 μF a
0,1 o perfino a 0,01 μF, ed avrete ancora misure di tempo che indicano il valore della
resistenza. Poiché la resistenza tra i terminali A e W del potenziometro cambia mentre
ruotate la manopola, la misura di RCTIME vi fornirà una misura di tempo, che corrisponde
alla posizione della manopola del potenziometro.
Programma esempio: LeggiPotConRcTime.bs2
 Digitate ed eseguite LeggiPotConRcTime.bs2
 Provate a ruotare la manopola del potenziometro mentre controllate il valore
della variabile tempo usando il terminale di Debug.
Ricordatevi di esercitare una piccola pressione verso il basso per mantenere il
potenziometro fermo nella breadboard mentre ruotate la sua manopola. Se il vostro servo
inizia ad andare inaspettatamente indietro e avanti invece di mantenere la sua posizione, la
colpa può essere di un pot non ben fermato.
' Che cos’è un microcontrollore - LeggiPotConRcTime.bs2
' Legge il potenziometro in un circuito a tempo RC usando il comando RCTIME.
' {$STAMP BS2}
' {$PBASIC 2.5}
tempo VAR Word
PAUSE 1000
DO
HIGH 7
PAUSE 100
RCTIME 7, 1, tempo
DEBUG HOME, "tempo = ", DEC5 tempo
LOOP
Il vostro turno – Cambiare il tempo cambiando il condensatore
 Sostituite il condensatore da 0,1 µF con un condensatore da 0,01 µF.
 Provate le stesse posizioni del potenziometro che avete impostato nell’attività
principale e confrontate il valore visualizzato dal terminale di Debug con i valori
ottenuti per il condensatore da 0,1 µF. Le misure di RCTIME sono circa un
decimo del valore per una data posizione del potenziometro?
 Tornate indietro al condensatore da 0,1 µF.
 Con il condensatore da 0,1 µF di nuovo nel circuito e il condensatore da 0,01 µF
rimosso, ruotate la manopola del pot ai suoi limiti in entrambe le direzioni e
prendete nota del valore più alto e di quello più basso per la successiva attività.
Valore più alto:_________ valore più basso:_________
Come lavora LeggiPotConRcTime.bs2
La Figura 5-12 mostra come i comandi HIGH, PAUSE ed
LeggiPotConRcTime.bs2 interagiscono con il circuito in Figura 5-11.
RCTIME
del
Figura 5-12: Voltaggio in P7 tramite HIGH, PAUSE, ed RCTIME
Invisibile al circuito RC
tempo
75 x 2 µs nella
variabile tempo
A sinistra, il comando HIGH 7 produce il collegamento, interno al BASIC Stamp, del suo
pin I/O P7 alla alimentazione di 5 V (Vdd). La corrente dell’alimentatore fluisce
attraverso la resistenza del potenziometro e inoltre carica il condensatore. Quanto più il
condensatore si avvicina alla sua carica finale (quasi 5 V), tanta minor corrente fluirà
entro di esso. Il comando PAUSE 100 ha il compito primario di far visualizzare al
terminale di Debug gli aggiornamenti a circa 10 volte al secondo; il comando PAUSE 1 di
solito basta a caricare il condensatore. A destra, il comando RCTIME 7, 1, tempo
cambia la direzione del pin I/O da uscita a ingresso ed avvia il conteggio del tempo in
incrementi di 2 μs. Come ingresso il pin I/O non fornisce più l’alimentazione di 5 V al
circuito. Infatti, come ingresso, è completamente invisibile al circuito RC. Così, il
condensatore comincia a perdere la sua carica attraverso il potenziometro. Man mano che
il condensatore perde carica, il suo voltaggio scende. Il comando RCTIME mantiene il
conteggio del tempo fin quando P7 intercetta un segnale basso, il ché significa che il
voltaggio attraverso il condensatore è sceso fino ad 1,4 V, punto al quale esso memorizza
la sua misura nella variabile tempo.
La Figura 5-12 mostra anche un grafico del voltaggio attraverso il condensatore durante i
comandi HIGH, PAUSE, ed RCTIME. In risposta al comando HIGH 7, che connette il
circuito ai 5 V, il condensatore si carica rapidamente. Poi, rimane livellato al suo
voltaggio finale durante quasi l’intero comando PAUSE 100. Quando il programma
raggiunge ed esegue il comando RCTIME 7, 1, tempo, cambia la direzione del pin I/O a
ingresso, in modo che il condensatore inizia a scaricarsi attraverso il potenziometro.
Mentre il condensatore si scarica, il voltaggio in P7 scende. Quando il voltaggio scende
ad 1,4 V (al segno 150 μs in questo esempio), il comando RCTIME smette di contare
tempo e memorizza il risultato della misura nella variabile tempo. Dal momento che il
comando RCTIME conta il tempo in unità di 2 μs, il risultato che sarà memorizzato per
150 μs nella variabile tempo è 75.
Soglia logica Pin I/O: 1,4 V è una soglia logica per il pin I/O del BASIC Stamp 2. Quando il
pin I/O è impostato a ingresso, memorizza un 1 nel suo registro di ingresso se il voltaggio
applicato è sopra 1,4 V o uno 0 se il voltaggio di ingresso è uguale o inferiore ad 1,4 V. Il
primo esempio con pulsante nella precedente attività #6 del capitolo 4 applicava sia 5 V che
0 V a P3. Poiché 5 V è sopra 1,4 V, IN3 ha memorizzato un 1, e poiché 0 V è sotto 1,4 V,
IN3 ha memorizzato uno 0.
Argomento Stato di RCTIME: In LeggiPotConRcTime.bs2, il voltaggio attraverso il
condensatore scende da quasi 5 V, e quando raggiunge 1,4 V, il valore nel registro IN7
cambia da 1 a 0. A quel punto, il comando RCTIME memorizza la sua misura nell’argomento Durata, che è la variabile tempo nel programma esempio. L’argomento State
del comando RCTIME è 1 in RCTIME 7, 1, tempo, e dice al comando RCTIME che il
registro IN7 memorizzerà un 1 quando ha inizio la misura. Il comando RCTIME misura
quanto tempo si impiega perché il registro IN7 cambi allo stato opposto, cosa che accade
quando il voltaggio scende sotto la soglia logica di 1.4 V del pin I/O.
Per maggiori informazioni: Guardafe il comando RCTIME sia nel Manuale BASIC Stamp
sia nell’aiuto dell’Editor del BASIC Stamp.
La Figura 5-13 mostra come cambia il tempo di discesa con la resistenza del
potenziometro per il circuito di Figura 5-11. Ciascuna posizione dellla manopola del
potenziometro lo imposta ad una certa resistenza. Giratelo ulteriormente in una direzione
e la resistenza aumenta, e nell’altra direzione la resistenza dminuisce. Quando la
resistenza è maggiore, la discesa prende un tempo più lungo, e il comando RCTIME
memorizza un valore più grande nella variabile tempo. Quando la resistenza è minore, la
discesa impiega un tempo minore, e il comando RCTIME memorizza un valore più piccolo
nella variabile tempo. Il comando DEBUG in LeggiPotConRcTime.bs2 visualizza la
misura di questo tempo nel terminale di Debug, e dal momento che il tempo di discesa
cambia con la resistenza del potenziometro, che a sua volta cambia con la posizione della
manopola del potenziometro, il numero nel terminale di Debug indica la posizione della
manopola.
Meno
resistenza.
Tempo d. più
corto
Più resistenza. Tempo discesa più lungo
Figura 5-13
Come la resistenza del
potenziometro agisce sul
tempo di discesa
Perché il condensatore si carica ad un voltaggio più basso quando il potenziometro
ha resistenza minore?
Date un’occhiata allo schema nell’angolo superiore sinistro della Figura 5-12 a pagina 166.
Senza la resistenza da 220 Ω, il pin I/O riuscirebbe a caricare il condensatore a 5 V, ma la
resistenza da 220 Ω è necessaria per evitare un possibile danno al pin I/O da un afflusso di
corrente quando il condensatore inizia a caricarsi. Essa evita anche al potenziometro di
assorbire troppa corrente se è portato a 0 Ω mentre il pin I/O invia il suo segnale alto di 5 V.
Con i 5 V applicati sulla resistenza da 220 Ω in serie al potenziometro, il voltaggio ai suoi
capi dovrebbe essere una frazione di 5 V. Quando due resistenze che conducono corrente
sono poste in serie, e da questo risulta un voltaggio intermedio, il circuito è chiamato
divisore (o partitore) di tensione. Quindi la resistenza da 220 Ω e il potenziometro formano
un circuito divisore di tensione, e per ciascun valore di resistenza del potenziometro (Rpot),
per calcolare il voltaggio (tensione) ai capi del potenziometro (Vpot), potete usare questa
equazione:
Vpot = 5 V × Rpot ÷ (Rpot + 220 Ω)
Il valore di Vpot pone il limite superiore al voltaggio sul condensatore. In altri termini,
qualsiasi valore abbia il voltaggio ai capi del potenziometro se il condensatore non fosse
collegato, questo sarebbe il voltaggio al quale il condensatore si caricherebbe, e non di più.
Per la maggior parte degli intervalli della manopola del potenziometro, i valori di resistenza
sono nella gamma dei kΩ, e quando calcolate Vpot per valori di Rpot in kΩ, i risultati sono
molto vicini ai 5 V. La resistenza da 220 Ω non evita che Vpot si carichi sopra 1,4 V fin
quando il valore del potenziometro è al di sotto di 85,6 Ω, che è meno del 1% della gamma
di movimento del potenziometro. Questo 1% avrebbe avuto il risultato delle misure
comunque più basse, quindi non è difficile dire che una misura di 1 in questa gamma sia
qualcosa fuori dall’ordinario. Perfino con l’aggiunta di resistenze da 220 Ω incorporate nelle
connessioni dei pin I/O sulla scheda BASIC Stamp HomeWork, è influenzato soltanto il
minimo 1,7% della gamma del potenziometro, quindi è ancora virtualmente trascurabile.
Pertanto la resistenza da 220 Ω protegge il pin I/O, con impatto minimo sulla capacità di
misurare la discesa RC per dirvi dove avrete posizionato la manopola del potenziometro.
ATTIVITÀ #4: CONTROLLO DI UN SERVO CON UN POTENZIOMETRO
Joystick a pollice simili a quello di Figura 5-14 si trovano comunemente nei controllori di
video giochi. Ciascuna manopola ha – di solito – due potenziometri che permettono
all’elettronica interna al controllore del gioco di riportare la posizione del joystick sulla
console del video gioco. Un potenziometro ruota con il movimento orizzontale
(sinistra/destra) del joystick, e l’altro ruota con il movimento verticale (Avanti/indietro)
del joystick.
Potenziometro
Horizontal
potentiometer
orizzontale
Figura 5-14
Potenziometri interni al
modulo Parallax Thumb
Joystick (Joystick a
pollice)
Potenziometro
Vertical
verticale
potentiometer
Un’altra applicazione del joystick a pollice che usa i potenziometri è il controllore radio
RC e l’aero-modello in Figura 4-1 a pagina 100. Il controllore ha due joystick, e
ciascuno ha due potenziometri. La posizione di ciascun potenziometro è responsabile del
controllo di un diverso servo sull’aereo RadioComandato.
In questa attività, userete un potenziometro simile a quelli che si trovano nei joystick a
pollice per controllare la posizione di un servo. Quando ruotate la manopola del
potenziometro, il quadrilatero del servo rispecchierà questo movimento. Questa attività
utilizza due circuiti, il circuito potenziometrico della figura 5-5 a pagina 100 in questo
capitolo, e il circuito del servo dalla attività #6, pagina 100, Capitolo 4. Il programma
PBASIC descritto in questo capitolo misura ripetutamente la posizione del potenziometro
con un comando RCTIME, ed usa poi la misura e un po’ di matematica per controllare la
posizione del servo con un comando PULSOUT.
Il BASIC Stamp può misurare la posizione del joystick. Dato che in ciascuno dei joystick
a pollice ci sono due potenziometri, ciascuno di essi può sostituire il potenziometro isolato
nei circuiti in Figura 5-11 a pagina 163. Un comando RCTIME può quindi misurare la
posizione del potenziometro verticale, ed un altro comando può misurare la posizione del
potenziometro orizzontale.
Parti del Servo controllato da potenziometro
(1) Servo Standard Parallax
Agli utenti di scheda HomeWork Board occorreranno anche:
(1) Capicorda maschio-maschio a 3-pin
Costruzione dei circuiti del Quadrante e del Servo
Questa attività userà due circuiti che avete già costruito singolarmente: il circuito del
potenziometro dall’attività che avete appena completato e il circuito del servo dal
capitolo precedente.
 Lasciate nella vostra area prototipi il vostro circuito del potenziometro a tempo
RC dalla attività #3. Se occorre ricostruirlo, usate la Figura 5-11 a pagina 163.
Assicuratevi di usare il condensatore da 0,1 µF, non il condensatore da 0,01 µF.
 Aggiungete al progetto il vostro circuito servo dall’attività #1 del cap. 4.
Ricordate che il vostro circuito servo sarà diverso a seconda della scheda che
uitilizzate. Qui sotto ci sono i capitoli dove vi serve di saltare:
o Pagina 103: Circuito Servo per la Board of Education
o Pagina 106: Circuito Servo per la HomeWork Board BASIC Stamp
Programmazione del controllo del Servo con un potenziometro
Vi occorreranno il valore minimo e massimo della variabile tempo che avete registrato
dal vostro circuito a tempo RC mentre usavate il condensatore da 0,1 µF.
 Se non avete ancora completato il capitolo “Il vostro turno” dell’attività
precedente, tornate indietro e completatela adesso.
Per questo esempio che segue, ecco i valori di tempo che sono stati misurati da un tecnico
Parallax; i vostri valori saranno probabilmente leggermente diversi:


Tutto in senso orario:
Tutto in senso antiorario:
1
691
Adesso, come potranno essere regolati questi valori di ingresso in modo che si adattino
all’intervallo 500–1000 per controllare il servo con un comando PULSOUT? La risposta è
utilizzando moltiplicazione e addizione. Prima di tutto, moltiplicate i valori di ingresso
per qualcosa per rendere la differenza tra il valore in senso orario (minimo) e quello in
senso antiorario (massimo) uguale a 500 invece di circa 700. Quindi, sommate un valore
costante al risultato in modo che il suo intervallo sia tra 500 e 1000 invece che tra 1 e
500. In elettronica, queste operazioni si chiamano scalatura o riduzione in scala
(scaling) e offset.
Ecco come si opera matematicamente per la moltiplicazione (riduzione in scala):
500
 691 0,724  500
691
500
 0.,724
tempo (minimo )  1
691
tempo ( massimo)  691
Dopo che i valori sono stati scalati, ecco il passo dell’addizione (offset).
tempo (massimo )  500  500  1000

tempo (minimo )  .0 ,724 +500  500
L’operatore */ , che era stato introdotto a pagina 90, è incorporato nel PBASIC per la
riduzione in scala di valori frazionari, come 0,724. Qui sono riportati di nuovo i passi per
usare */ applicato a 0,724:
1. Porre il valore o la variabile che volete moltiplicare per un valore frazionario
prima dell’operatore */.
tempo = tempo */
2. Prendete il valore frazionario che volete usare e moltiplicatelo per 256.
nuovo valore frazionario. =0,724
  256 . 185 344
3. Arrotondatelo per eliminare le cifre a destra della virgola.
nuovo valore frazionario 
185
4. Porre quel valore dopo l’operatore */.
tempo = tempo */ 185
Questo effettua la scalatura, ora tutto quello che ci occorre fare è aggiungere l’offset di
500. Ciò può essere fatto con un secondo comando che aggiunge 500 a tempo:
tempo = tempo + 500
Adesso, tempo è pronto ad essere reinserito nell’argomento Durata del comando
PULSOUT.
tempo = tempo + 500
PULSOUT 14, tempo
' Scalatura per 0,724.
' Offset per 500.
' Invia impulso al servo.
Programma esempio: ControlloServoConPot.bs2
 Digitate ed eseguite questo programma, quindi ruotate la manopola del
potenziometro e assicuratevi che i movimenti del servo facciano eco ai
movimenti del potenziometro.
' Che cos’è un microcontrollore - ControlloServoConPot.bs2
' Legge il potenziometro nel circuito tempo RC usando il comando RCTIME.
' Scala il tempo di 0,724 e aggiunge un offset di 500 per il servo.
' {$STAMP BS2}
' {$PBASIC 2.5}
PAUSE 1000
tempo
VAR
Word
DO
HIGH 7
PAUSE 10
RCTIME 7, 1, tempo
tempo = tempo + 500
PULSOUT 14, tempo
' Scala per 0,724 (X 256 per */).
' Offset di 500.
' Manda impulso al servo.
LOOP
Il vostro turno – Scalatura della relazione tra Servo e Quadrante
Il vostro potenziometro e il condensatore vi daranno probabilmente valori di tempo che
sono un po’ diversi da quelli citati in questa attività. Questi sono i valori che avete
raccolto nel capitolo “Il vostro turno” dell’attività precedente.
 Ripetete i calcoli discussi nel capitolo Programmazione del controllo del Servo
con un potenziometro a pagina 171 usando i vostri valori massimo e minimo.
 Sostituite i vostri valori di scalatura ed offset in ControlloServoConPot.bs2.
 Cambiate in commento la DEBUG "Il programma è in esecuzione!"
aggiungendo un apostrofo all’inizio di quella riga.
 Aggiungete questa linea di codice tra i comandi PULSOUT e LOOP in modo da
poter vedere il vostro risultato:
DEBUG HOME, DEC5 tempo
'Visualizza valore regolato di tempo.
 Eseguite il programma modificato e controllate il vostro lavoro. Poiché i valori
sono arrotondati per difetto, i limiti possono non coincidere esattamente con 500
e 1000, ma dovrebbero esservi molto vicini.
Dichiarazione di costanti e direttive di Pin
In programmi più grossi, potrete usare i valori del fattore di scala (che era 185) e
dell’offset (che era 500) molte volte nel corso del programma. Numeri come 185 e 500
nel vostro programma sono chiamati costanti perché, a differenza delle variabili, i loro
valori non possono essere cambiati mentre il programma viene eseguito. In altri termini,
il valore rimane “costante.” Potete creare nomi per queste costanti con direttive CON:
FattoreScala
Offset
ritardo
CON
CON
CON
185
500
10
Queste direttive CON sono quasi sempre dichiarate vicino all’inizio del programma in
modo che sia facile trovarle.
Non appena i valori delle vostre costanti hanno ricevuto un nome tramite le direttive CON,
nel vostro programma potrete usare FattoreScala al posto di 185 e Offset al posto di
500. Per esempio:
tempo = tempo */ FattoreScala
tempo = tempo + offset
' Scala per 0,724.
' Offset di 500.
Con i valori che abbiamo assegnato ai nomi di costanti con le direttive CON, i comandi
sono in realtà:
tempo = tempo + 500
' Scala per 0,724.
' Offset di 500.
Un vantaggio importante nell’uso di costanti è quello di poter cambiare una direttiva CON,
e questa aggiorna ogni istanza di quel nome di costante in tutto il vostro programma. Per
esempio, se scrivete un grosso programma che usa la costante FattoreScala in 11 posti
differenti, un cambio a FattoreScala CON…, e tutte le istanze di FattoreScala nel
voatro programma useranno quel valore aggiornato nel successivo scarico del
programma. Quindi, se cambiate FattoreScala CON 500 in FattoreScala CON 510,
ogni comando contenente FattoreScala userà 510 invece di 500.
Potete anche dare nomi ai pin I/O usando direttive PIN. Per esempio, potete dichiarare
una direttiva PIN per il pin I/O P7 come la seguente:
PinRc
PIN 7
Ci sono due posti nel programma esempio precedente dove il numero 7 è usato per fare
riferimento al pin I/O P7. Il primo può ora essere scritto come:
HIGH PinRc
Il secondo può essere scritto come:
RCTIME PinRc, 1, tempo
Se in un secondo tempo cambiate il vostro circuito per usare pin I/O differenti, tutto ciò
che dovete fare è cambiare il valore nella vostra direttiva PIN, e sia il comando HIGH che
il comando RCTIME saranno aggiornati automaticamente. Analogamente, se dovete
ricalibrare il vostro fattore di scala o l’offset, potete anche qui cambiare semplicemente le
direttive CON all’inizio del programma.
La direttiva PIN ha una caratteristica aggiuntiva: Il compilatore PBASIC può rilevare se il
nome del pin è usato in input o in output, ed essa sostituisce o il numero di pin I/O per
l’output, o la variabile bit del corrispondente registro di input per l’input. Per esempio, potete
dichiarare due direttive pin, come PinLed PIN 14 e PinButton PIN 3. Allora, il vostro
codice potrà contenere una frase come IF PinButton = 1 THEN HIGH PinLed. Il
compilatore PBASIC converte questa frase in IF IN3 = 1 THEN HIGH 14. La frase IF
PinButton = 1… ha fatto un confronto, e il compilatore PBASIC sa che voi state usando
PinButton come input. Quindi esso usa il bit IN3 del registro di input invece del numero
3. Analogamente, il compilatore PBASIC sa che HIGH PinLed usa il nome pin PinLed
come il valore costante 14 per una operazione di uscita, così gli sostituisce HIGH 14.
Programma esempio: ControlloServoConPotEUsoDirettive.bs2
Questo programma lavora proprio come ControlloServoConPot.bs2 ma fa uso delle
costanti e dei pin I/O con nome.
 Digitate ed eseguite ControlloServoConPotEUsoDirettive.bs2.
 Osservate come il servo risponde al potenziometro e verificate che si comporti
nello stesso modo che in ControlloServoConPot.bs2.
' Che cos’è un microcontrollore - ControlloServoConPotEUsoDirettive.bs2
' Legge il potenziometro in circuito tempo-RC usando il comando RCTIME.
' Applica fattore scala e offset, quindi invia valore al servo.
' {$STAMP BS2}
' {$PBASIC 2.5}
PinRC
PIN
7
' Definizioni Pin I/O
PinServo
PIN
14
FattoreScala
offset
ritardo
CON
CON
CON
185
500
10
' Dichiarazioni di Costanti
tempo
VAR
Word
' Dichiarazioni di Variabile
PAUSE 1000
' Inizializzazione
DO
HIGH PinRC
PAUSE ritardo
RCTIME PinRC, 1, tempo
tempo = tempo */ FattoreScala
tempo = tempo + offset
PULSOUT PinServo, tempo
DEBUG HOME, DEC5 tempo
' Routine principale (Main)
' Misura decadimento RC
'
'
'
'
Scalatura x FattoreScala.
Offset x offset.
Invia impulso a servo.
Visualizza valore tempo corretto.
LOOP
Il vostro turno – Aggiornamento di una direttiva PIN
Come è stato ricordato prima, se collegate il circuito RC ad un pin I/O diverso, potete
semplicemente cambiare il valore della direttiva PIN PinRC, e questo cambiamento si
riflette automaticamente nei comandi HIGH PinRC e RCTIME PinRC, 1, tempo.
 Memorizzate il programma esempio con un nuovo nome.
 Cambiate FattoreScala e offset nei valori propri del vostro circuito RC che
avete determinato nel capitolo precedente “Il vostro turno”.
 Eseguite il programma modificato e verificate che lavori correttamente.
 Modificate il vostro circuito muovendo la connessione del circuito tempo-RC dal
pin I/O P7 al pin I/O P8.
 Modificate la dichiarazione PinRC in modo che sia:
PinRC
PIN 8
 Rieseguite il programma e verificate che i comandi HIGH ed RCTIME funzionino
ancora correttamente sul pin I/O differente con il solo cambiamento fatto alla
direttiva PinRC PIN.
SOMMARIO
Questo capitolo ha introdotto il potenziometro, un componente usato spesso sotto varie
manopole e dischi a quadrante. Il potenziometro ha un elemento resistivo connesso di
solito ai suoi due terminali esterni e un terminale mobile che fa contatto con un punto
variabile dell’elemento resistivo. Il potenziometro può essere utilizzato come resistenza
variabile se in un circuito si utilizzano il terminale mobile ed uno dei due terminali
esterni.
In questo capitolo è stato introdotto anche il condensatore. Un condensatore può essere
usato per immagazzinare e rilasciare carica elettrica. La quantità di carica che un
condensatore può immagazzinare è relativa al suo valore, che si misura in farad, (F). Il
simbolo µ è la notazione ingegneristica per micro, e significa un milionesimo. I
condensatori utilizzati nelle attività di questo capitolo vanno da 0,01 a 3300 µF.
Una resistenza e un condensatore si possono collegare assieme in un circuito che prende
una certa quantità di tempo per caricarsi e scaricarsi. Questo circuito è detto
comunemente circuito a tempo RC. Le lettere R e C in un circuito a tempo RC stanno
per resistenza e condensatore. Quando un valore (C nelle attività di questo capitolo) è
mantenuto costante, il cambiamento di tempo che il circuito impiega a scaricarsi è legato
al valore di R. Quando il valore di R cambia, il valore del tempo che il circuito impiega a
caricarsi e scaricarsi cambia anch’esso. Il tempo complessivo che il circuito a tempo RC
impiega a scaricarsi può essere scalato impiegando un condensatore di dimensione
diversa.
E’ stato usato un sondaggio per controllare il tempo di scarica di un condensatore in un
circuito RC con un valore di C molto grande. Per mostrare come cambia il tempo di
scarica quando cambia il valore della resistenza nel circuito, sono state usate molte
resistenze di diverso valore. È stato poi usato il comando RCTIME per controllare un
potenziometro (una resistenza variabile) in un circuito a tempo RC con condensatori di
capacità più piccole. Nonostante questi condensatori facciano sì che i tempi di scarica
varino da circa 2 a 1500 µs (milionesimi di secondo), il BASIC Stamp non ha problemi a
registrare queste misure con il comando RCTIME. Il pin I/O deve essere impostato ad
HIGH, e quindi si deve permettere al condensatore nel circuito a tempo RC di caricarsi
usando un comando PAUSE prima di poter usare il comando RCTIME.
Si può utilizzare la programmazione PBASIC per misurare un sensore resistivo come un
potenziometro e scalare il suo valore in modo che sia utile ad un altro dispositivo, come
ad esempio un servo. Ciò comporta l’esecuzione di operazioni matematiche sul tempo di
scarica RC misurato, che il comando RCTIME memorizza in una variabile. Il valore di
questa variabile può essere corretto aggiungendogli un valore costante, cosa conveniente
per il controllo di un servo. Nel capitolo Progetti, potrete usare altrettanto moltiplicazione
e divisione.
All’inizio di un programma, per sostituire un nome a un valore costante (un numero) si
può usare la direttiva CON. Dopo che una costante ha ricevuto un nome, in tutto il
programma si potrà usare quel nome al posto del numero. Questo fatto può risultare
comodo, specialmente se vi occorre usare lo stesso numero in 2, 3, o persino 100 posti
diversi nel programma. Potete cambiare il numero nella direttiva CON, e tutte le 2, 3, o
persino le 100 istanze differenti di quel numero sono aggiornate automaticamente la
successiva volta che eseguirete il programma. La direttiva PIN vi consente di nominare i
pin I/O. Il nome di un pin I/O è sensibile al contesto, quindi il compilatore PBASIC
sostituisce il numero del corrispondente pin I/O quando trova un nome di pin in comandi
come HIGH, LOW, ed RCTIME. Se il nome di pin è usato in una frase condizionale, gli
sostituisce il registro di input corrispondente, come IN2, IN3, ecc.
Domande
1. Quando ruotate una manopola o un disco in un sistema audio, quale tipo di
componente state molto probabilmente regolando?
2. In un tipico potenziometro, la resistenza tra i due terminali esterni è regolabile?
3. In che cosa un condensatore è simile ad una batteria ricaricabile? In che cosa è
diverso?
4. Che cosa potete fare in un circuito a tempo RC per acquisire una indicazione del
valore di una resistenza variabile?
5. Che cosa accade al tempo di scarica RC quando il valore di R (la resistenza)
diventa più grande o più piccolo?
6. Che cosa fa la direttiva CON? Spiegatelo in termini di nome e numero.
Esercizio
1. Diciamo che avete un condensatore da 0,5 µF in un circuito temporizzatore RC,
e volete che la misura (del tempo RC) diventi 10 volte più lunga. Calcolate il
valore del nuovo condensatore.
Progetti
1. Aggiungete un circuito con un LED bicolore a quello di fig. 5.11. Modificate il
programma esempio in modo che il LED bicolore sia rosso quando il servo sta
ruotando in senso antiorario, verde quando il servo sta ruotando in senso orario,
ed è spento (off ) quando il servo mantiene la sua posizione.
2. Usate IF...THEN per modificare il primo programma esempio della Attività #4
in modo che il servo ruoti soltanto tra i valori di PULSOUT 650 e 850.
Soluzioni
D1. Un potenziometro.
D2. No, è fissa. La resistenza è variabile tra qualsiasi dei terminali esterni e il
terminale mobile (intermedio).
D3. Un condensatore è simile ad una batteria ricaricabile nel fatto che può essere
caricato per mantenere un determinato voltaggio. Ls differenza è che mantiene
una carica soltanto per un tempo molto breve.
D4. Potete misurare il tempo che il condensatore impiega per scaricarsi (o caricarsi).
Questo tempo è collegato ai valori della resistenza e della capacità. Se la capacità
è nota e la resistenza è variabile, allora il tempo di scarica dà una indicazione
della resistenza.
D5. Quando la resistenza R aumenta, il tempo di scarica RC aumenta in proporzione
diretta all’aumento di R. Quando R diventa più piccola, il tempo di scarica RC
diminuisce in proporzione diretta alla diminuzione di R.
D6. La direttiva CON sostituisce un nome ad un numero.
E1. Nuova cap = (10 x vslore vecchia cap) = (10 x 0,5µF) = 5 µF
P1. Attività #4 con aggiunta di un LED bicolore.
P13
1
2
P12
470
'
'
'
'
'
'
'
'
Schema del potenziometro dalla Figura
5-11 a pagina 163, servo dalla attività 4,
pagina 169, e LED bicolore da Figura 2-19
a pagina 57 con P15 e P14 cambiati in P13
e P12 come indicato.
Che cos’è un microcontrollore – Cap05Pr01_ControlloServoConPot.bs2
Legge potenziometro in circuito a tempo RC usando un comando RCTIME.
La var tempo varia tra 126 e 713, ed occorre un offset di 330.
Il LED bicolore in P12, P13 dice la direzione di rotazione servo:
verde per CW (oraria), rosso per CCW (antioraria), spento (off)
quando il servo sta mantenendo la sua posizione.
{$STAMP BS2}
{$PBASIC 2.5}
PAUSE 1000
tempo
TempoPrec
VAR
VAR
Word
Word
' lettura tempo da pot
' lettura precedente
DO
TempoPrec = tempo
'
HIGH 7
'
PAUSE 10
RCTIME 7, 1, tempo
tempo = tempo + 350
'
IF (tempo > TempoPrec + 2) THEN
'
HIGH 13
'
LOW 12
ELSEIF (tempo < TempoPrec - 2) THEN
LOW 13
HIGH 12
ELSE
LOW 13
LOW 12
ENDIF
Memorizza lettura tempo preced.
Legge pot usando RCTIME
Scala pot, incontra range servo
se cresce, pot ruota CCW
LED bicolore rosso
' valore calato, pot ruota CW
' LED bicolore verde
' Servo mantiene posizione
' LED spento (off)
PULSOUT 14, tempo
LOOP
P2. Il punto chiave è aggiungere il blocco IF...THEN; un esempio è mostrato qui
sotto. CLREOL è un utile carattere di controllo DEBUG che significa “cancella fino
a fine riga.”
'
'
'
'
'
Che cos’è un microcontrollore - Cap5Pr02_ControlloServoConPot.bs2
Legge potenziometro in circuito a tempo RC usando un comando RCTIME.
Modificato con IF…THEN in modo che servo ruota solo tra 650 e 850.
La variabile tempo varia tra 1 e 691, quind serve un offset di
almeno 649.
' {$STAMP BS2}
' {$PBASIC 2.5}
PAUSE 1000
Tempo
VAR Word
DO
HIGH 7
PAUSE 10
' Legge pot con RCTIME
RCTIME 7, 1, tempo
tempo = tempo + 649
IF (tempo
tempo =
ENDIF
IF (tempo
tempo =
ENDIF
< 650) THEN
650
' Scala tempo a range servo
' Limita range da 650 a 850
> 850) THEN
850
PULSOUT 14, tempo
DEBUG HOME, "tempo = ", DEC4 tempo, CLREOL
LOOP
Misure di Luce · Pagina 183
Capitolo 6: Display digitale
IL DISPLAY DIGITALE QUOTIDIANO
La Figura 6-1 mostra un display posto sullo sportello anteriore di un forno. Quando il
forno non è in uso, il display visualizza l’ora. Quando il forno è in uso, visualizza il
temporizzatore del forno, le predisposizioni di cottura, e lampeggia spento – acceso
contemporaneamente, al suono di un allarme, per farvi sapere che il cibo è cotto. Un
microcontrollore all’interno dello sportello del forno controlla i pulsanti e aggiorna il
display. Controlla inoltre i sensori all’interno del forno e commuta i dispositivi che
accendono e spengono (on ed off) gli elementi riscaldatori.
Figura 6-1
Display a 7 segmenti
orologio digitale sullo
sportello di un forno
Ciascuna delle tre cifre in Figura 6-1 è chiamata display a 7 segmenti. In questo capitolo,
programmerete il BASIC Stamp per visualizzare numeri e lettere su un display a 7
segmenti.
CHE COSA E’ UN DISPLAY A 7 SEGMENTI?
Un display a 7 segmenti è un blocco rettangolare di 7 porzioni di riga della stessa
lunghezza che possono essere accese, scegliendo i LED, per visualizzare cifre e alcune
lettere. La Figura 6-2 mostra un disegno di parte del display LED a 7 segmenti che
userete nelle attività di questo capitolo. Il display ha anche un punto usabile come punto
decimale. Ciascuno dei segmenti (da A fino a G) e il punto contengono un LED separato,
che si può controllare singolarmente. La maggior parte dei pin ha un numero con una
etichetta che corrisponde ad uno dei segmenti LED. Il pin 5 è etichettato DP, che
significa punto decimale. I pin 3 e 8 sono etichettati “catodo comune” e saranno spiegati
quando verrà introdotto lo schema elettrico di questo componente.
Catodo
Comune
10 9 8 7 6
G F
A B
A
F
B
G
C
E
D
E D
Figura 6-2
Disegno di parte e mappa dei pin del
Display LED a 7 segmenti
C DP
1 2 3 4 5
Catodo
Comune
Mappa dei pin: La Figura 6-2 è un esempio di mappa dei pin. Una mappa dei pin contiene
informazioni utili che vi aiutano a collegare un componente a diversi circuiti. Le mappe dei
pin di solito mostrano per ciascun pin un numero, un nome, e un riferimento.
Guardate la Figura 6-2. Ciascun pin è numerato, e il nome di ciascun pin è la lettera del
segmento vicina al pin. Il riferimento per questo componente è il punto decimale. Orientate
il componente in modo che il punto decimale sia in basso a destra. Potrete allora vedere
dalla mappa dei pin che il Pin 1 è in basso a sinistra, e il numero del pin aumenta
muovendosi intorno all’involucro in senso antiorario.
La Figura 6-3 mostra lo schema dei LED all’interno del display LED a 7 segmenti.
L’anodo di ciascun LED è connesso ad un singolo pin. Tutti i catodi sono collegati
assieme da fili interni alla parte. Poiché tutti i catodi condividono il collegamento, il
display LED a 7 segmenti può essere detto display a catodo comune. Collegando il pin 3
o il pin 8 della parte a Vss, collegherete tutti i catodi dei LED a Vss.
1
4
6
7
9
10
5
E
C
B
A
F
G
DP
LED’s
3
Figura 6-3
Schema del Display
LED a 7 segmenti
8
ATTIVITÀ #1: COSTRUZIONE E PROVA DEL DISPLAY A LED A 7
SEGMENTI
In questa attività, costruirete a mano i circuiti per provare ciascun segmento nel display.
Parti per la prova dei LED del display a 7 segmenti
(1) display LED a 7 segmenti
(5) Resistenze – 1 kΩ (marrone-nero-rosso)
Circuiti di prova del display a LED a 7 segmenti
 Con l’energia (alimentazione) scollegata dalla vostra Board of Education o
HomeWork Board, costruite il circuito mostrato in Figura 6-4 e Figura 6-5.
 Ricollegate energia e verificate che il segmento A emetta luce.
Cosa vuol dire nello schema la x con il simbolo nc sopra di essa? Il simbolo nc significa
non collegato o nessuna connessione. Indica che un particolare pin sul display LED a 7
segmenti non è connesso a niente. La x all’estremità del pin significa anch’essa non
connesso. Gli schemi a volte usano soltanto la x o soltanto il nc.
Vdd
nc
X
X
X
nc
nc
nc
X
nc
X
nc
X
nc
X
1 k
1
4
6
7
9
10
5
E
C
B
A
F
G
DP
Figura 6-4
Schema del circuito di
prova per il segmento
“A” del Display a LED
LED’s
8
X
3
Vss
nc
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vdd
Vin
Vss
Figura 6-5
del circuito di prova per
il segmento “A” del
display a LED
 Scollegate l’energia, e modificate il circuito collegando la resistenza all’ingresso
del LED B come mostrato in Figura 6-6 e Figura 6-7.
Vdd
X
nc
nc
nc
X
X
nc
X
nc
X
nc
X
nc
X
1 k
1
4
6
7
9
10
5
E
C
B
A
F
G
DP
Figura 6-6
Schema del circuito di
prova per il segmento
”B” del Display a LED
LED’s
8
X
3
Vss
nc
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vdd
Vin
Vss
Figura 6-7
del circuito di prova per
il segmento “B” del
display a LED
 Ricollegate energia e verificate che il segmento B emetta luce.
 Usando la mappa dei pin dalla Figura 6-2 come guida, ripetete questi passi per i
segmenti da C fino a G.
Il vostro turno – Il Numero 3 e la Lettera H
La Figura 6-8 e la Figura 6-9 mostrano la cifra “3” cablata entro il display LED a 7
segmenti.
Vdd
Vdd
Vdd
Vdd
Vdd
1 kall)
X
nc
X
nc
X
nc
1
4
6
7
9
10
5
E
C
B
A
F
G
DP
Figura 6-8
Cablaggio della
Cifra “3”
LED’s
8
X
3
Vss
nc
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vdd
Vin
Vss
Figura 6-9
Diagramma di
cablaggio per la
Figura 6-8
 Costruite e provate il circuito mostrato in Figura 6-8 e Figura 6-9, e verificate
che esso visualizzi il numero tre.
 Disegnate uno schema che visualizzi il numero 2 sul LED a 7 segmenti.
 Costruite e provate il circuito per assicurarvi che lavori. Mettetelo a punto se
necessario.
 Determinate il circuito che occorre per la lettera “H” e poi costruitelo e
provatelo.
ATTIVITÀ #2: CONTROLLO DEL DISPLAY LED A 7 SEGMENTI
In questa attività, collegherete il display LED a 7 segmenti al BASIC Stamp, e poi
eseguirete un semplice programma per provarlo e assicurarvi che ciascun LED sia
connesso in modo corretto.
Parti occorrenti per il Display LED a 7 segmenti
(1) Display LED a 7 segmenti
Collegamento del Display LED a 7 segmenti al BASIC Stamp
La Figura 6-11 mostra lo schema e la Figura 6-12 mostra il diagramma di cablaggio per
questo esempio di un display LED a 7 segmenti controllato dal BASIC Stamp.
 Costruite il circuito mostrato nella Figura 6-11 e nella Figura 6-12.
Schema elettrico e mappa dei pin: Se state provando a costruire il circuito dallo schema in
Figura 6-11 senza far riferimento alla Figura 6-12, accertatevi di consultare la mappa dei pin
del display LED a 7 segmenti, mostrata di nuovo qui in Figura 6-10 per convenienza.
Common
Cathode
10 9 8 7 6
G F
A B
A
F
B
Figura 6-10
Disegno di parte e mappa dei pin del
Display LED a 7 segmenti
G
C
E
D
E D
C DP
1 2 3 4 5
Common
Cathode
1 k
(All)
P15
P14
P13
P12
P11
P10
P9
P8
E
C
G
DP
LED’s
common
Vss
F
A
B
Figura 6-11
Schema del
Display LED
a 7 segmenti
controllato
dal BASIC
Stamp
State attenti con le resistenze collegate a P13 e P14. Guardate attentamente le
resistenze connesse a P13 e P14 in Figura 6-12. C’è un intervallo tra queste due
resistenze. L’intervallo è mostrato perché il pin 8 sul display LED a 7 segmenti è lasciato
non connesso. Una resistenza connette il pin I/O P13 al pin 9 del display LED a 7
segmenti. Un’altra resistenza collega P14 al pin 7 del display LED a 7 segmenti.
DP
EDC GFAB
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vdd
Figura 6-12
per la Figura 6-11
Vin
Vss
Usate le lettere di
segmento sopra questo
diagramma come
riferimento
.
Dispositivo parallelo: Il display LED a 7 segmenti è detto dispositivo parallelo perché il
BASIC Stamp deve usare un gruppo di linee I/O per inviare dati (informazioni alte e basse)
al dispositivo. Nel caso di questo display LED a 7 segmenti, prende 8 pin I/O per istruire il
dispositivo su cosa visualizzare.
Bus parallelo : I fili che trasmettono I segnali HIGH/LOW dal BASIC Stamp al display LED
a 7 segmenti sono detti (costituiscono) un bus parallelo. Notate che questi fili sono
disegnati come linee parallele in Figura 6-11. Il termine che cita “parallelo” ha senso per la
geometria dello schema.
Programmazione della prova del Display LED a 7 segmenti
I comandi HIGH e LOW accetteranno una variabile come argomento Pin. Per provare
ciascun segmento, uno alla volta, ponete semplicemente i comandi HIGH e LOW in un ciclo
FOR...NEXT, ed usate l’indice del ciclo per impostare il pin I/O alto, poi di nuovo basso.
 Digitate ed eseguite ProvaSegmentoConAltoBasso.bs2.
 Verificate che ciascun segmento nel display LED a 7 segementi si illumini
brevemente, accendendosi e poi spegnendosi di nuovo.
 Registrate un elenco di quale segmento controlli ciascun pin I/O.
Programma esempio: ProvaSegmentoConAltoBasso.bs2
' Che cos’è un microcontrollore - ProvaSegmentoConAltoBasso.bs2
' Prova singolarmente ciascun segmento in un display LED a 7 segmenti.
'{$STAMP BS2}
'{$PBASIC 2.5}
ContatorePin
VAR
Nib
PAUSE 1000
DEBUG "Pin I/O", CR,
"-------", CR
FOR ContatorePin = 8 TO 15
DEBUG DEC2 ContatorePin, CR
HIGH ContatorePin
PAUSE 1000
LOW ContatorePin
NEXT
Il vostro turno – Un disegno diverso
Rimuovere il commando LOW ContatorePin avrà un effetto interessante:
 Commentate (trasformate in commento) il comando LOW ContatorePin
aggiungendo un apostrofo alla sua sinistra.
 Eseguite il programma modificato ed osservatene l’effetto.
ATTIVITÀ #3: VISUALIZZAZIONE DI CIFRE
Se includete il punto decimale ci sono otto differenti pin I/O del BASIC Stamp che
inviano segnali alto/basso al display LED a 7 segmenti. Cioè a dire, per visualizzare
soltanto un numero ci vogliono otto diversi comandi HIGH o LOW. Se volete contare da
zero a nove, ciò comporterebbe una discreta quantità di linee di codice di
programmazione Fortunatamente, ci sono variabili speciali che potrete usare per
predisporre i valori alto e basso per i gruppi di pin I/O.
In questa attività, userete numeri binari a 8 cifre invece dei comandi HIGH e LOW per
controllare i segnali alto/basso inviati dai pin I/O del BASIC Stamp. Impostando variabili
speciali chiamate DIRH ed OUTH uguali ai numeri binari, potrete controllare i segnali
alto/basso inviati da tutti i pin I/O connessi al circuito del display LED a 7 segmenti con
un unico comando PBASIC.
8 bit: Un numero binario che ha otto cifre si dice che ha otto bit. Ciascun bit è un deposito
dove potrete memorizzare sia un 1 sia uno 0.
Un byte è una variabile che contiene 8 bit. Ci sono 256 combinazioni differenti di zeri ed uni
che potete usare per contare da 0 a 255 con 8 bit. Questa è la ragione per cui una variabile
byte può memorizzare un numero tra 0 e 255.
Parti e circuito per visualizzare cifre
Le stesse dell’attività precedente
Programmazione di modelli On/Off usando numeri binari
In questa attività, sperimenterete le variabili DIRH ed OUTH. DIRH è una variabile che
controlla la direzione (input o output) dei pin I/O da P8 fino a P15. OUTH controlla i
segnali alto o basso che ciascuno di questi pin I/O invia. Come potrete vedere presto,
OUTH è particolarmente utile poiché potrete usarlo per impostare i segnali alto/basso per
otto differenti pin I/O in una sola volta con un unico comando Ecco un programma
esempio che mostra come si possano usare queste due variabili per contare da 0 a 9 sul
display LED a 7 segmenti senza utilizzare i comandi HIGH e LOW:
Programma esempio: VisualizzaCifre.bs2
Questo programma esempio farà ciclare (farà eseguire ripetitivamente) il display LED a 7
segmenti con le cifre dallo 0 al 9.
 Digitate ed eseguite VisualizzaCifre.bs2.
 Verificate che siano visualizzate le cifre dallo 0 fino al 9.
' Che cos’è un microcontrollore - VisualizzaCifre.bs2
' Visualizza le cifre da 0 a 9 su un display LED a 7-segmenti.
'{$STAMP BS2}
'{$PBASIC 2.5}
OUTH = %00000000
DIRH = %11111111
'
BAFG.CDE
OUTH = %11100111
PAUSE 1000
OUTH = %10000100
PAUSE 1000
OUTH = %11010011
PAUSE 1000
OUTH = %11010110
PAUSE 1000
OUTH = %10110100
PAUSE 1000
OUTH = %01110110
PAUSE 1000
OUTH = %01110111
PAUSE 1000
OUTH = %11000100
PAUSE 1000
OUTH = %11110111
PAUSE 1000
OUTH = %11110110
PAUSE 1000
DIRH = %00000000
' OUTH è inizializzato a basso.
' Imposta P8-P15 tutti a output basso.
' Cifra:
' 0
' 1
' 2
' 3
' 4
' 5
' 6
' 7
' 8
' 9
' pin I/O ad input,
' segmenti spenti (off).
END
Come lavora VisualizzaCifre.bs2
La Figura 6-13 mostra come potete usare le variabili DIRH ed OUTH per controllare la
direzione e lo stato (alto/basso) dei pin I/O da P8 fino a P15.
Vin
Vss
Il primo comando:
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
X3
Vdd
Figura 6-13
Usiare DIRH ed OUTH
per impostare ttutti i pin
I/O a Output-basso
OUTH = %00000000
DIRH = %11111111
OUTH = %00000000
...rende tutti i pin I/O (da P8 fino a P15) pronti ad inviare segnali bassi. Se tutti inviano
segnali bassi, essi commuteranno tutti i LED nel display LED a 7 segmenti in off
(spento). Se volevate che tutti i pin I/O inviino un segnale alto, potete usare invece OUTH
= %11111111.
Che cosa fa %? Il formattatore binario % è usato per dire all’Editor del BASIC Stamp che il
numero è un numero binario. Per esempio, il numero binario %00001100 è la stessa cosa
del numero decimale 12. Come vedrete in questa attività, i numeri binari possono rendere
molti compiti di programmazione molto più facili.
I segnali bassi non saranno realmente inviati dai pin I/O fin quando non usiate la variabile
DIRH per cambiare tutti i pin I/O da input ad output. Il comando:
DIRH = %11111111
...imposta i pin I/O da P8 fino a P15 ad output. Non appena questo comando viene
eseguito, i pin da P8 fino a P15 iniziano tutti ad inviare segnali bassi. Questo avviene
perché il comando OUTH = %00000000 era stato eseguito proprio prima di quel comando
DIRH. Non appena il comando DIRH imposta tutti i pin I/O ad output, essi iniziano ad
inviare i loro segnali bassi. Per cambiare tutti i pin I/O da capo ad input, potete anche
usare DIRH = %00000000.
Prima che i pin I/O diventino outputs: Fin quando i pin I/O vengono cambiati da input ad
output, essi ascoltano soltanto se arrivano segnali ed aggiornano la variabile INH. Questa è
la variabile che contiene IN8, IN9, e così via fino a IN15. Queste variabili possono essere
utilizzate allo stesso modo di come erano state usate IN3 ed IN4 per leggere i pulsanti in
Ingresso Digitale – Pulsanti (capitolo 3).
Tutti i pin I/O del BASIC Stamp iniziano a funzionare come inputs. Questa proprietà è
detta di default. Dovete dire voi ad un pin I/O del BASIC Stamp di diventare un output prima
che inizi ad inviare un segnale alto o basso. Entrambi i comandi HIGH e LOW cambiano
automaticamente la direzione di un pin I/O del BASIC Stamp ad output. Anche il porre un 1
nella variabile DIRH rende uno dei pin I/O un output.
Impostate sempre i valori in un dato registro di OUT prima di renderli outputs con i
valori nel corrispondente registro DIR. Ciò previene brevemente l’invio di segnali
indesiderati. Ad esempio, se DIR5 = 1 è seguito da OUT5 = 1 all’inizio di un programma,
questo invierà brevemente un segnale basso indesiderato prima di commutarlo ad alto
poiché OUT5 memorizza 0 quando il programma parte. (Tutte le variabili e i registri PBASIC
sono inizializzati a 0.) Se OUT5 = 1 è seguito invece da DIR5 = 1, il pin I/O invierà un
segnale alto non appena diviene un output.
Poiché i valori memorizzati da tutte le variabili sono di default 0 quando il
programma parte, il comando OUTH = %00000000 è in realtà ridondante.
La Figura 6-14 mostra come usare la variabile OUTH per inviare selettivamente segnali alti
e bassi ai pin da P8 fino a P15. Per inviare un segnale alto si usa un 1 binario, e per
inviare un segnale basso si usa uno 0 binario. Questo esempio visualizza il numero tre
sul display LED a 7 segmenti:
'
BAFG.CDE
OUTH = %11010110
Vin
Vss
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
X3
Vdd
Figura 6-14
Usio di OUTH per
controllare i segnali
Alto/Basso di P8 – P15
‘
BAFG.CDE
OUTH = %11010110
Il display è acceso in modo che il tre sul display è a testa in giù poiché questo mostra più
chiaramente come i valori in OUTH si allineano con i pin I/O. Il comando
OUTH = %11010110 usa degli zeri binari per impostare i pin I/O P8, P11, e P13 bassi, e
usa degli uni binari per impostare P9, P10, P12, P14 e P15 alti. La riga proprio prima del
comando è un commento che mostra le etichette del segmento allineate con il valore
binario che accende/spegne il segmento on/off.
Entro i comandi HIGH e LOW:
HIGH 15
...è in realtà identico a:
OUT15 = 1
DIR15 = 1
...è lo stesso che:
OUT15 = 0
DIR15 = 1
Analogamente, il commando :
LOW 15
Se volete cambiare P15 di nuovo ad un input, usate DIR15 = 0. Potete poi usare IN15
per rilevare segnali alto/basso (invece di inviarli).
Il vostro turno – Visualizzare le lettere da A fino ad F
 Immaginate quali sequenze di bit (combinazioni di zeri ed uni) vi occorrano per
visualizzare le lettere A, b, C, d, E, ed F.
 Modificate VisualizzaCifre.bs2 in modo che visualizzi A, b, C, d, E, F.
Decimale ed esadecimale Le cifre base nel sistema di numerazione decimale (a base 10)
sono:
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Nel sistema di numerazione esadecimale (a base 16) le cifre base sono:
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, b, C, d, E, F.
La base 16 è usata estensivamente sia nella programmazione di computer che dei
microcontrollori. Una volta che immaginate come visualizzare i caratteri da A ad F, potete
ulteriormente modificare il vostro programma per contare in esadecimale da 0 ad F.
Mantenere un elenco delle configurazioni (modelli) On/Off
Il commando LOOKUP vi fa scrivere il codice per le configurazioni di un disoplay LED a 7
segmenti molto più facilmente. Il comando LOOKUP vi permette di “cercare” elementi in
un elenco. Ecco un esempio di codice che utilizza il comando LOOKUP:
LOOKUP indice, [7, 85, 19, 167, 28], valore
In questo commando sono usate due variabili, indice e valore. Se indice è 0, valore
memorizza 7. Se indice è 1, valore memorizza 85. Nel successivo programma
esempio, indice è impostato a 2, in modo che il commando LOOKUP pone 19 entro
valore, e questo visualizza il terminale di Debug.
Programma esempio: RicercaSemplice.bs2




Digitate ed eseguite Ricerca Semplice.bs2
Eseguite il programma così com’è, con la variabile indice impostata uguale a 2.
Provate a impostare la variabile indice uguale a numeri tra 0 e 4.
Rieseguite il programma dopo ciascun cambiamento della variabile indice e
notate quale valore dell’elenco si posiziona nella variabile valore.
 Opzionale: Modificate il programma ponendo il commando LOOKUP in un ciclo
FOR...NEXT che conti da 0 a 4.
' Che cos’è un microcontrollore - RicercaSemplice.bs2
' Trova un valore usando un indice e una tabella di ricerca.
' {$STAMP BS2}
' {$PBASIC 2.5}
valore
indice
VAR
VAR
Byte
Nib
indice = 2
PAUSE 1000
DEBUG ? indice
LOOKUP indice, [7, 85, 19, 167, 28], valore
DEBUG ? valore, CR
DEBUG "Cambiate la variabile indice in un ", CR,
"numero differente (tra 0 e 4).", CR, CR,
"Eseguite il programma modificato e ", CR,
"controllate per vedere quale numero ", CR,
"il commando LOOKUP pone nella", CR,
"variable valore."
END
Programma esempio: VisualizzaCifreConRicerca.bs2
Questo programma esempio mostra come il commando LOOKUP può dimostrarsi
realmente alla mano per memorizzare le sequenze di bit usate nella variabile OUTH. Di
nuovo, la variabile indice è usata per scegliere quale valore binario è posto entro la
variabile OUTH. Questo programma esempio conta di nuovo da 0 a 9. La differenza tra
questo programma e VisualizzaCifre.bs2 è che questo programma è molto più versatile.
È molto più veloce e più facile da regolare per sequenze differenti di numeri usando le
tabelle di ricerca.
 Digitate ed eseguite VisualizzaCifreConRicerca.bs2.
 Verificate che fa la stessa cosa del programma precedente (con molto minor
lavoro).
 Date un’occhiata al terminale di Debug mentre il programma viene eseguito.
Esso mostra come il valore di indice è usato dal comando LOOKUP per caricare
il valore binario corretto dall’elenco contenuto entro OUTH.
' Che cos’è un microcontrollore - VisualizzaCifreConRicerca.bs2
' Usa una tabella di ricerca per memorizzare e visualizzare cifre con un
' display LED a 7 segmenti.
'{$STAMP BS2}
'{$PBASIC 2.5}
indice
VAR
Nib
OUTH = %00000000
DIRH = %11111111
PAUSE 1000
DEBUG "indice
"------
OUTH
", CR,
--------", CR
FOR indice = 0 TO 9
LOOKUP indice, [ %11100111, %10000100, %11010011,
%11010110, %10110100, %01110110,
%01110111, %11000100, %11110111, %11110110 ], OUTH
DEBUG "
", DEC2 indice, "
PAUSE 1000
NEXT
", BIN8 OUTH, CR
DIRH = %00000000
END
Il vostro turno – Visualizzazione di nuovo da 0 ad F
 Modificate VisualizzaCifreConRicerca.bs2 perché conti da 0 fino ad F in
esadecimale. Non dimenticate di aggiornare l’argomento EndValue del ciclo
FOR...NEXT.
ATTIVITÀ #4: VISUALIZZAZIONE DELLA POSIZIONE DI UN DISCO
Nel capitolo 5, attività 4, avete usato il potenziometro per controllare la posizione di un
servo. In questa attività, visualizzerete la posizione del potenziometro col display LED a
7 segmenti.
Parti del quadrante e del display
(1) Display LED a 7 segmenti
(1) Condensatore – 0.1 µF
Costruzione del quadrante e dei circuiti per il Display
La Figura 6-15 mostra uno schema del circuito col potentiometro che dovete aggiungere
al progetto. La Figura 6-16 mostra il diagramma di cablaggio del circuito dalla Figura
6-15 combinato col circuito dalla Figura 6-11 a pagina 190.
 Aggiungere il circuito col potenziometro al circuito del display LED a 7
segmenti come mostrato in Figura 6-16.
Figura 6-15
Schema del circuito col
potenziometro aggiunto
al progetto
Figura 6-16
per la Figura 6-15
Programmazione del quadrante e del display
C’è un comando molto utile chiamato LOOKDOWN e, come potete immaginare, è il
contrario del comando LOOKUP. Mentre il comando LOOKUP vi fornisce un numero sulla
base di un indice, il comando LOOKDOWN vi dà un indice in base ad un numero.
Programma esempio: RicercaInversaSemplice.bs2
Questo programma esempio dimostra come lavora il comando LOOKDOWN.
 Digitate ed eseguite RicercaInversaSsmplice.bs2.
 Eseguite il programma così com’è, con la variabile valore impostata uguale a
167, ed usate il terminale di Debug per osservare il valore di indice.
 Provate ad impostare la variabile valore uguale a ciascuno degli altri numeri
elencati dal comando LOOKDOWN: 7, 85, 19, 28.
 Ri-eseguite il programma dopo ciascun cambiamento della variabile valore e
notate quale valore dall’elenco viene posto nella variabile indice.
Domande trucco: che cosa accade se il vostro valore è maggiore di 167? Questo piccolo
“fuori programma” nel comando LOOKDOWN può causare problemi poiché il comando
LOOKDOWN non fa alcun cambiamento all’indice.
' Che cos’è un microcontrollore - RicercaInversaSemplice.bs2
' Trova un indice usando un valore e una tabella di ricerca.
' {$STAMP BS2}
' {$PBASIC 2.5}
valore
indice
VAR
VAR
Byte
Nib
valore = 167
PAUSE 1000
DEBUG ? valore
LOOKDOWN valore, [7, 85, 19, 167, 28], indice
DEBUG ? indice, CR
DEBUG "Cambiate la variabile valore in un ", CR,
"numero differente di questo elenco:", CR,
"7, 85, 19, 167, or 28.", CR, CR,
"controllate per vedere quale numero il", CR,
"commando LOOKDOWN pone nella ", CR,
" variabile indice."
END
Fin quando non dite al programma di fare un tipo diverso di confronto, il comando
LOOKDOWN verifica se un valore è uguale ad uno degli elementi dell’elenco. Potete anche
controllare se un valore è maggiore, minore, o uguale, ecc. Ad esempio, per cercare se
un valore introdotto nella variabile valore è inferiore o uguale, usate l’operatore <=
proprio prima della prima parentesi che inizia l’elenco. In altre parole, l’operatore
restituisce l’indice del primo valore nell’elenco che rende vera la frase nell’istruzione.
 Modificate RicercaInversSemplice.bs2 sostituendo questo valore e la frase
LOOKDOWN al posto di quelli esistenti:
valore = 35
LOOKDOWN valore, <= [ 7, 19, 28, 85, 167 ], indice
 Modificate il comando DEBUG in modo che sia:
DEBUG "Cambiate la variabile valore in un ", CR,
"numero differente in questo intervallo:", CR,
"da 0 a 170.", CR, CR,
"controllate quale numero il comando ", CR,
"LOOKDOWN pone nella variabile ", CR,
"indice."
 Sperimentate con valori differenti e vedete se la variabile indice visualizza
quello che vi aspettate.
Programma esempio: VisualizzaQuadrante.bs2
Questo programma esempio fa da specchio alla posizione della manopola del
potenziometro illuminando i segmenti intorno all’esterno di un display LED a 7 segmenti
come mostrato in Figura 6-17.
Figura 6-17
Visualizzazione della posizione del
Potenziometro col Display LED a 7
segmenti
 Digitate ed eseguite VisualizzaQuadrante.bs2.
 Ruotate la manopola del potenziometro e accertatevi che lavori. Ricordatevi di
premerla verso il basso per mantenere il pot allocato sulla breadboard.
 Quando eseguite il programma esempio, può non essere preciso come mostrato
in Figura 6-17. Regolate i valori nella tabella del LOOKDOWN in modo che il
display digitale rappresenti più accuratamente la posizione del potenziometro.
' Che cos’è un microcontrollore - VisualizzaQuadrante.bs2
' Visualizza la posizione del POT tramite il display LED a 7 segmenti.
'{$STAMP BS2}
'{$PBASIC 2.5}
PAUSE 1000
indice
tempo
VAR
VAR
Nib
Word
OUTH = %00000000
DIRH = %11111111
DO
HIGH 5
PAUSE 100
RCTIME 5, 1, tempo
LOOKDOWN tempo, <= [40, 150, 275, 400, 550, 800], indice
LOOKUP indice, [ %11100101, %11100001, %01100001,
%00100001, %00000001, %00000000 ], OUTH
LOOP
Come lavora VisualizzaQuadrante
Questo programma esempio prende una misura RCTIME del potenziometro e la
memorizza in una variabile di nome tempo.
HIGH 5
PAUSE 100
RCTIME 5, 1, tempo
La variabile tempo è usata quindi in una tabella LOOKDOWN. La tabella LOOKDOWN decide
di quale numero del suo elenco il valore di tempo è inferiore, e quindi carica il numero
introdotto (da 0 a 5 in questo caso) entro la variabile indice.
LOOKDOWN tempo, <= [40, 150, 275, 400, 550, 800], indice
Successivamente, la variabile indice è usata in una tabella LOOKUP per scegliere il valore
binario da caricare entro la variabile OUTH.
LOOKUP indice, [ %11100101, %11100001, %01100001,
%00100001, %00000001, %00000000 ], OUTH
Il vostro turno – Aggiungere un segmento
VisualizzaQuadrante.bs2 fa accendere soltanto cinque dei sei segmenti quando ruotate il
quadrante. La sequenza per accendere i LED in Visualizza Quadrante.bs2 è E, F, A, B,
C, ma non D.
 Memorizzate
VisualizzaQuadrante.bs2
con
il
nome
VisualizzaQuadranteVostroTurno.bs2.
 Modificate VisualizzaQuadranteVostroTurno.bs2 in modo che faccia accendere
in sequenza tutti e sei LED più esterni quando il potenziometro viene ruotato.
La sequenza dovrebbe essere E, F, A, B, C, e D.
Suggerimento: Lasciate il vostro circuito LED a 7 segmenti sulla vostra scheda.
Useremo di nuovo il LED a 7 segmenti assieme ad altri circuiti nel Capitolo 7, Attività #4.
SOMMARIO
Questo capitolo ha introdotto il display LED a 7 segmenti, e il modo in cui leggere una
mappa di pin. Questo capitolo ha introdotto anche alcune tecniche per dipositivi e
circuiti che hanno input paralleli. Sono state introdotte le variabili DIRH ed OUTH come
mezzo per controllare i valori dei pin I/O da P8 fino a P15 del BASIC Stamp. Sono stati
introdotti i comandi LOOKUP e LOOKDOWN come mezzo per riferirsi all’elenco di valori
usati per visualizzare lettere e numeri.
Domande
1. In un display LED a 7 segmenti, qual’è l’ingrediente attivo che rende il diaplay
leggibile quando un microcontrollore manda un segnale alto o basso?
2. Cosa significa catodo comune? Cosa pensate che significhi anodo comune?
3. Come è chiamato il gruppo di fili che conduce i segnali verso e da un dispositivo
parallelo?
4. Quali sono i nomi dei comandi che sono stati usati in questo capitolo per gestire
elenchi di valori?
Esercizi
1. Scrivete un comando OUTH per impostare P8, P10, P12 alti e P9, P11, P13 bassi.
Assumendo che tutti i vostri pin I/O iniziino come input, scrivete il comando
DIRH che fa in modo che i pin I/O da P8 a P13 mandino segnali alti/bassi mentre
lasciate P14 e P15 configurati come input.
2. Scrivete i valori di OUTH richiesti per fare le lettere: a, C, d, F, H, I, n, P, S.
Progetto
1. Fate sillabare la frase “FISH CHIPS And dIP” indefinitamente con il vostro
display LED a 7 segmenti. Fate in modo che ciascuna lettera duri 400 ms.
Soluzioni
D1. L’ingrediente attivo è un LED.
D2. Catodo comune significa che tutti i catodi sono connessi assieme, cioè, essi
condividono un punto di connessione comune. Anodo comune dovrebbe significare
che tutti gli anodi sono connessi assieme.
D3. Un bus parallelo.
D4. LOOKUP e LOOKDOWN gestiscono elenchi di valori.
E1. Il primo passo per configurare OUTH è impostare un "1" in ciascuna posizione di
bit specificata come HIGH. Così i bit 8, 10, e 12 vanno impostati ad "1". Poi
ponete uno "0" per ciascun LOW, così ottengono uno "0" i bit 9, 11, e 13, come
mostrato. Per configurare DIRH, i pin specificati, 8, 10, 12, 9, 11, e 13 devono
essere posti come output impostando quei bit a "1". 15 e 14 sono configurati
come input ponendo zeri nei bit 15 e 14. Il secondo passo è tradurre questo in
una istruzione PBASIC.
Bit 15 14 13 12 11 10
OUTH 0 0 0 1 0 1
9
0
8
1
OUTH = %00010101
Bit 15 14 13 12 11 10
DIRH 0 0 1 1 1 1
9
1
8
1
DIRH = %00111111
E2. La chiave per risolvere questo problema è disegnare ciascuna lettera e notare
quali segmenti devono essere accesi. Porre un 1 in ciascun segmento che deve
essere acceso. Tradurre questo nel valore binario OUTH. L’elenco di segmenti
BAFG.CDE per i bit in OUTH viene dalla Figura 6-14 a pagina 197.
Lettera
a
C
d
F
H
I
n
P
S
Segmenti LED
e, f, a, b, c, g
a, f, e, d
b, c, d, e, g
a, f, e, g
f, e, b, c, g
f, e
e, g, c
tutti tranne c e d
a, f, g, c, d
B A F G.C D E
11110101
01100011
10010111
01110001
10110101
00100001
00010101
11110001
01110110
Dalla Figura 6-2 a pagina 184.
Valore OUTH =
%11110101
%01100011
%10010111
%01110001
%10110101
%00100001
%00010101
%11110001
%01110110
Common
Cathode
10 9 8 7 6
G F
A B
A
F
B
G
C
E
D
E D
C D
1 2 3 4 5
Common
Cathode
P1. Usate lo schema della Figura 6-11 a pagina 190. Per risolvere questo problema,
modificate VisualizzaCifreConRicerca.bs2, usando i modelli di lettera elaborati
nell’esercizio 2. Nella soluzione, le lettere sono state impostate come costanti
per rendere il programma più intuitivo. Usare i valori binari è altrettanto buono,
ma maggiormente soggetto ad errori.
' Che cos’è un microcontrollore - Cap6Pr01_FishAndChips.bs2
' Usa una tabella di ricerca per memorizzare e visualizzare cifre con
' un display a 7 segmenti. Sillaba il messaggio: FISH CHIPS And dIP
'{$STAMP BS2}
'{$PBASIC 2.5}
' Sequenze per creare lettere sul Display a 7 Segmenti
A
CON
%11110101
C
CON
%01100011
d
CON
%10010111
F
CON
%01110001
H
CON
%10110101
I
CON
%00100001
n
CON
%00010101
P
CON
%11110001
S
CON
%01110110
spazio
CON
%00000000
indice
VAR
Byte
' 19 car. nel messaggio
OUTH = %00000000
DIRH = %11111111
' All’inizio tutto spento (off)
' Tutti i LED devono essere output
PAUSE 1000
' 1 sec. prima del 1° messaggio
DO
DEBUG "indice
"------
OUTH
", CR,
--------", CR
FOR indice = 0 TO 18
' 19 car. nel messaggio
LOOKUP indice, [ F, I, S, H, spazio, C, H, I, P, S, spazio,
A, n, d, spazio, d, I, P, spazio ], OUTH
DEBUG "
PAUSE 400
NEXT
LOOP
", DEC2 indice, "
", BIN8 OUTH, CR
' 400 ms tra le lettere
Capitolo 7: Misure di luce
DISPOSITIVI CHE CONTENGONO SENSORI DI LUCE
I primi capitoli hanno introdotto i pulsanti come sensori di contatto/pressione e i
potenziometri come sensori di rotazione/posizione. Entrambi questi sensori sono comuni
nei prodotti elettronici—pensate soltanto a quanti dispositivi con pulsanti e dischi
(quadranti) utilizzate quotidianamente. Un altro sensore comune che si trova in molti
prodotti è il sensore di luce. Ecco alcuni esempi di dispositivi che necessitano di sensori
di luce per funzionare in modo corretto:






Fari di automobile che si accendono automaticamente quando fa buio
Lampioni stradali che si accendono automaticamente quando diventa sera
Luci esterne di sicurezza che si accendono quando qualcuno attraversa il vostro
cortile (ma soltanto di notte)
Visori di computer portatili che diventano più luminosi in aree ben illuminate e
meno luminosi in aree con poca luce
Fotocamere con impostazione automatica dell’esposizione
Sensori interni a TV, lettori di DVD ed altri componenti di sistemi di
intrattenimento che rilevano la radiazione infrarossa di un telecomando distante
I primi tre esempi nell’elenco sono illuminati automaticamente, e dipendono da sensori di
luce ambiente per distinguere il giorno dalla notte. L’elettronica di questi dispositivi
deve sapere soltanto se c’è luce o buio, in modo che essi possano trattare i loro sensori di
luce come output binari analoghi a pulsanti. I visori di computer portatili e gli
esposimetri automatici di fotocamere si regolano sulle condizioni di illuminazione della
zona acquisendo dai loro sensori di luce informazioni su quanta luce o buio ci sia. Essi
devono trattare i loro sensori di luce come output analogici che forniscono un numero
indicatore di quanta luce o buio c’è, in modo molto simile agli esempi col potenziometro
dove i numeri indicavano la posizione della manopola.
I sensori di luce all’interno di TV e di altri componenti di sistemi di intrattenimento
rilevano radiazione infrarossa (IR), che è luce non visibile all’occhio umano ma che può
essere rilevata da molti dispositivi elettronici. Per esempio, se guardate l’estremità dei
telecomandi che puntate su un TV o altri dispositive di intrattenimento, troverete un LED
IR trasparente. Quando premete un pulsante del telecomando, esso invia segnali
codificati al componente del sistema di intrattenimento facendo lampeggiare on/off il
LED IR. Poiché non possiamo vedere la luce infrarossa, non ci sembra che il LED del
telecomando faccia nulla quando premete un pulsante. Però, se provate ad agire sul
telecomando mentre guardate al LED attraverso l’obiettivo di una fotocamera digitale, il
LED apparirà quasi bianco. La luce bianca contiene tutti i colori dello spettro. I sensori
rosso, verde e blu dentro il chip di una fotocamera riportano tutti di aver rilevato luce, in
risposta alla luce bianca. Così accade allo stesso modo che i sensori rosso/verde/blu
rilevino tutti la luce infrarossa dal LED IR del telecomando. Quindi la fotocamera
interpreta anch’essa la luce di un LED infrarosso come luce bianca.
Ancora sui LED a infrarosso e i rivelatori:
Il testo Robotica con il Boe-Bot (Robotics with the Boe-Bot) contiene esempi dove un robot
Boe-Bot controllato dal BASIC Stamp usa il LED IR che si trova nei telecomandi TV e il
ricevitore IR che si trova negli apparecchi TV per rilevare oggetti di fronte a lui. Il Boe-Bot
usa il LED IR come un piccolo lampeggiatore e il ricevitore IR che si trova entro un TV per
rilevare le riflessioni dei lampeggiamenti IR provenienti da oggetti che lo fronteggiano. Il
testo IR Remote for the Boe-Bot spiega come i telecomandi dei TV codificano i messaggi
che inviano ai TV e contiene esempi di come programmare il microcontrollore del BASIC
Stamp per decodificare messaggi dal telecomando in modo da inviare messaggi al vostro
robot Boe-Bot, e perfino guidarlo in giro, tutto con un telecomando TV.
Il tipo di luce che un determinato dispositivo sente dipende da che cosa è stato progettato
per fare. Ad esempio, i sensori di luce per i dispositivi che si regolano sulle condizioni di
luce ambiente debbono sentire luce visibile. I sensori di pixel rosso, verde e blu
contenuti nelle fotocamere digitali sentono ciascuno i livelli di colori specifici di una
immagine digitale. Il sensore IR entro un TV cerca luce infrarossa che stia lampeggiando
on/off con frequenza vicina ai 40 kHz. Questi sono soltanto pochi esempi, e ciascuna
applicazione richiede un tipo diverso di sensore di luce.
La Figura 7-1 mostra alcuni esempi dei molti sensori di luce disponibili per vari requisiti
di sensibilità alla luce. Da sinistra a destra, sono mostrati un fototransistor, una
fotoresistenza al solfuro di cadmio, un sensore di luce lineare, un fotodiodo con massimo
sul blu, un convertitore luce – frequenza, un fototransistor ad infrarosso, e un ricevitore
remoto ad infrarosso da TV.
Figura 7-1 Esempi di sensori di luce
Dettagli sulla cella al solfuro di cadmio (CdS) o Fotoresistenza
La cella al solfuro di cadmio (CdS) o fotoresistenza era uno dei più comuni sensori di luce
ambiente nell’illuminazione automatizzata.
Con l’avvento della direttiva Restrizioni
dell’Unione Europea sull’utilizzo di alcune sostanze ritenute pericolose (RoHS), le
fotoresistenze al solfuro di cadmio non possono essere più incorporate entro molti dispositivi
importati o fabbricati in Europa. Ciò ha aumentato l’uso di un certo numero di prodotti
sostitutivi delle fotoresistenze, inclusi il fototransistor e il sensore lineare di luce. Come
risultato di questi cambiamenti, questa edizione ora promuove il fototransistor come
rilevatore di livelli luminosi al posto della fotoresistenza al solfuro di cadmio.
La documentazione di ciascun sensore descrive il tipo di luce che rileva, in termini di
lunghezza d’onda. La Lunghezza d’onda è la misura della distanza tra forme ripetute o
cicli. Ad esempio, immaginate un’onda che viaggia attraverso l’oceano, muovendosi in
su e in giù. La lunghezza d’onda di quell’onda sarebbe la distanza tra ciascuno dei picchi
(o creste spumose) del ciclo dell’onda. La lunghezza d’onda della luce può essere
misurata in un modo simile, noi stiamo misurando – invece (delle creste spumose) – la
distanza tra due picchi delle oscillazioni elettromagnetiche della luce. Ciascun colore
della luce ha la sua propria lunghezza d’onda ed è considerato essere luce visibile, il che
significa che può essere rilevata dall’occhio umano. La Figura 7-2 mostra le lunghezze
d’onda per la luce visibile come anche quelle per alcuni tipi di luce che l’occhio umano
non può rilevare, incluse l’ultravioletto e l’infrarosso. Queste lunghezze d’onda sono
misurate in nanometri, che si abbrevia nm. Un nanometro è un miliardesimo di un metro.
Figura 7-2 Lunghezze d’onda e colori corrispondenti
Lunghezza d’onda 10…380
450 495
570 590 620
(nm)
Violetto
Verde
Arancio
Colore
Ultravioletto
Blu
Giallo
Rosso
750…100,000
Infrarosso
NOTA: Se state vedendo questa figura in un libro stampato in scala di grigio, potete scaricarne
una versione PDF a colori dal sito www.parallax.com/go/WAM.
INTRODUZIONE AL FOTOTRANSISTOR
Un transistor è simile ad una valvola che consente ad una certa quantità di corrente di
attraversare due dei suoi terminali. Il terzo terminale di un transistor controlla proprio
quanta corrente passa attraverso gli altri due. A seconda del tipo di transistor, il flusso di
corrente può essere controllato da voltaggio, corrente o, nel caso del fototransistor, dalla
luce. La Figura 7-3 mostra lo schema elettrico e il disegno di parte del fototransistor
contenuto nel kit What’s a Microcontroller (Che cos’è un microcontrollore). Maggiore è
la luce che colpisce il terminale base (B) del fototransistor, maggiore sarà la corrente che
esso condurrà nel suo terminale collettore (C), corrente che fluisce fuori dal suo terminale
emettitore (E). Inversamente, una minor luce che brilla sul terminale di base produrrà
una minor corrente condotta.
B
C
Figura 7-3
parte del fototransistor
B
E
E
C
La sensibilità di picco di questo fototransistor è 850 nm, lunghezza che – secondo la
Figura 7-2 - è nella gamma dell’infrarosso. Questo fototransistor risponde anche alla luce
visibile, però è un pò meno sensibile, specialmente per le lunghezze d’onda sotto 450 nm,
Che in Figura 7-2 sono a sinistra del blu. La luce di lampade alogene e ad incandescenza,
e in special modo la luce del sole, sono sorgenti di infrarosso, molto più intense delle
lampade fluorescenti. Il transistor a infrarosso risponde bene a tutte queste sorgenti di
luce, ma è molto più sensibile alla luce solare, poi alle lampade alogene e ad
incandescenza, e un po’ meno sensibile alle lampade fluorescenti.
Il disegno di circuiti che usano il transistor può essere modificato per lavorare meglio in
certi tipi di condizioni di illuminazione, e i circuiti con fototransistor in questo capitolo
sono progettati per l’uso indoor (in interni). C’è una applicazione di sensibilità alla luce
esterna, ma essa farà uso di un dispositivo differente, che potrebbe a prima vista sembrare
improbabile come candidato sensore di luce: un diodo emettitore di luce.
ATTIVITÀ #1: COSTRUZIONE E PROVA DEL MISURATORE DI LUCE
Il capitolo 5 ha introdotto le misure di decadimento RC con il comando RCTIME per
misurare il tempo che un condensatore impiega a perdere la sua carica attraverso la
resistenza variabile interna ad un potenziometro. Con una resistenza più grande (verso il
flusso di corrente elettrica), il potenziometro rallentava la velocità alla quale il
condensatore perdeva la sua carica, e con una resistenza più piccola questa velocità
aumentava. La misura del tempo di decadimento dava un’indicazione della resistenza del
potenziometro, che a sua volta rendeva possibile al BASIC Stamp conoscere la posizione
del disco del potenziometro.
Quando, in un circuito di decadimento RC, viene posto un fototransistor, che conduce più
o meno corrente quando è colpito da maggiore o minor luce, questo si comporta in modo
molto simile al potenziometro. Quando una maggior quantità di luce colpisce il
fototransistor, esso conduce più corrente, e il condensatore perde la sua carica più
rapidamente. Con una minor quantità di luce, il fototransistor conduce meno corrente, e
il condensatore perde la sua carica meno rapidamente. Così la stessa misura RCTIME,
che ci dava una indicazione della posizione del disco con un potenziometro nel Capitolo
5, può essere ora usata per misurare i livelli di luce con un fototransistor.
In questa attività, costruirete e proverete un circuito di decadimento RC che misura il
tempo che impiega la carica di un condensatore a decadere attraverso un fototransistor.
La misura del decadimento RC vi darà un’idea dei livelli di luce sentiti dalla superficie
raccogli-luce del fototransistor. Come con la prova del potenziometro, i valori di tempo
misurati dal comando RCTIME saranno visualizzati nel terminale di Debug.
Parti per la prova del rivelatore di luce
(1) Fototransistor
(2) Condensatori – 0.01 µF (etichettati 103)
(1) Condensatore – 0.1 µF (etichettato 104)
Costruzione del circuito a tempo RC con un fototransistor
La Figura 7-4 mostra uno schema e un diagramma di cablaggio del circuito a tempo RC
che userete in questo capitolo. Questo circuito è diverso dal circuito del potenziometro
nell’attività #3 del capitolo 5 per due motivi. Prima di tutto, il pin I/O usato per misurare
il tempo di decadimento è differente (P2). Seconda cosa, il potenziometro è stato
sostituito da un fototransistor.
Suggerimento: Lasciate connesso il vostro LED a 7 segmenti, e aggiungete alla
vostra scheda il circuito con il fototransistor. Useremo il LED a 7 segmenti con il
fototransistor nell‘attività #4 di questo Capitolo.
 Assicuratevi che i terminali collettore ed emettitore (C ed E) del fototransistor
siano connessi come mostrato nel diagramma di cablaggio.
Figura 7-4
Schema e diagramma di
cablaggio del circuito a
tempo RC per il
fototransistor
Iniziare con il
condensatore da 0.01
µF, etichettato 103.
Vdd
Vin
Vss
X3
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Terminale
(C) col pin
più lungo
Terminale (E)
a bordo piatto
Prova di programmazione del fototransistor
Il primo programma esempio (ProvaFototransistor.bs2) è in realtà solo una versione con
poche revisioni di LeggiPotConRcTime.bs2 dalla Attività # 3, capitolo 5. Il circuito del
potenziometro da pagina 167 (attività #3, cap.5) era connesso al pin I/O P7. Il circuito in
questa attività è connesso a P2. A causa di questa differenza, per farlo lavorare devono
essere aggiornati due comandi del programma esempio. Il comando HIGH 7 del
programma esempio precedente diventa qui HIGH 2 poiché il circuito del fototransistor è
connesso a P2 e non a P7. Per la stessa ragione, il comando RCTIME 7, 1, tempo è
stato modificato in RCTIME 2, 1, tempo.
Programma esempio: ProvaFototransistor.bs2
La superficie del fototransistor che raccoglie la luce è in cima alla cupola del suo
contenitore di plastica chiaro, ed è il terminale base (B) mostrato in Figura 7-3.
Attraverso quella cupola dovrebbe essere visibile un piccolo quadratino nero. Quel
quadratino nero è proprio il fototransistor, un piccolo pezzo di silicio. Il resto del
dispositivo è il suo contenitore, che include l’involucro di plastica, il telaio di filo, e i fili
di collegamento.
Invece di ruotare la manopola del potenziometro come facevamo nell’attività 3 del
capitolo 5, questo circuito viene provato esponendo la superficie fotosensibile del
fototransistor a livelli di luce differenti. Quando il programma esempio è in esecuzione,
il terminale di Debug dovrebbe visualizzare piccoli valori in condizioni di luce forte, w
grandi valori in condizioni di luce debole.
Evitate la luce solare diretta! Il circuito e il programma che state usando è progettato per
rilevare variazioni di luce in interni e non lavora alla luce solare diretta. Lasciate le luci
interne all’ambiente accese, ma chiudete le imposte se il sole invade l’ambiente in
prossimità delle finestre.
 Digitate ed eseguite ProvaFototransistor.bs2.
 Prendete nota della variabile tempo sul terminale di Debug in condizioni di luce
normali.
 Gettate ombra sopra il circuito con la vostra mano e controllate di nuovo la
variabile tempo. Dovrebbe essere un numero grande.
 Coprite il circuito con la vostra mano per fare più ombra; il terminale di Debug
dovrebbe visualizzare un valore significativamente maggiore per tempo.
' Che cos’è un microcontrollore - ProvaFototransistor.bs2
' Legge un fototransistor in un circuito a tempo RC usando un comando RCTIME.
' {$STAMP BS2}
' {$PBASIC 2.5}
tempo
PAUSE 1000
VAR
Word
DO
HIGH 2
PAUSE 100
RCTIME 2, 1, tempo
DEBUG HOME, "tempo =
LOOP
", DEC5 tempo
Il vostro turno – Uso di un condensatore diverso per condizioni di luce
differenti
Le misure di tempo con un condensatore da 0,1 μF prenderanno dieci volte il tempo preso
da quelle con un condensatore da 0,01 μF, il ché significa che il valore della variabile
tempo visualizzato dal terminale di Debug dovrebbe essere dieci volte più grande.
Sostituire il condensatore da 0,01 μF con un condnsatore da 0,1 μF può essere utile in
stanze molto illuminate dove di solito vedreste misure piccole con il condensatore da 0,01
μF. Per esempio, dicianmo che le condizioni di illuminazione siano molto brillanti, e le
misure variano soltanto da 1 a 13 con il condensatore da 0,01 μF. Se lo sostituite con un
condensatore da 0,1 μF, la vostre misure varieranno invece tra 1 e 130, e la vostra
applicazione sarà molto più sensibile alle variazioni di luce nella stanza.
 Modificate il circuito sostituendo il condensatore da 0,01 μF con un
condensatore da 0,1 μF (etichettato 104).
 Ri-eseguite ProvaFototransistor.bs2 e verificate che le misure di tempo RC sono
all’incirca dieci volte i loro valori precedenti.
L’intervallo di tempo più lungo che il comando RCTIME può misurare è 65535 unità di 2
µs ciascuna, che corrisponde ad un tempo di decadimento di: 65535 × 2 μs = 131 ms =
0,131 s. Se il tempo di decadimento supera 0,131 secondi, il comando RCTIME restituisce
0 per indicare che il massimo tempo di misura è stato superato.
 Potete fare sopra il fototransistor un buio sufficiente a superare la misura
massima di 65535 e fare in modo che il comando RCTIME restituisca 0?
La prossima attività farà uso del minore tra i due condensatori.
 Prima di passare all’attività successiva, riportate il circuito a quello originale
mostrato in Figura 7-4, rimuovendo il condensatore da 0,1 μF e sostituendolo
con il condensatore da 0,01 μF.
ATTIVITÀ #2: REGISTRAZIONE DI EVENTI LUMINOSI
Una delle caratteristiche più utili della memoria di programma del modulo BASIC Stamp
è che potete scollegare energia alla scheda senza perdere il vostro programma. Non
appena l’energia viene riconnessa, il programma inizierà ad essere eseguito di nuovo
dall’inizio. Poiché il codice della vostra applicazione tipicamente non riempie la
memoria del modulo BASIC Stamp, qualsiasi porzione non usata per il programma potrà
essere usata per memorizzare dati. Questa memoria è adatta in special modo a
memorizzare dati che non volete che il BASIC Stamp dimentichi. Mentre i valori
memorizzati dalle variabili vengono cancellati quando si disconnette l’energia, il BASIC
Stamp ricorderà ancora tutti i valori memorizzati nella sua memoria di programma
quando si ricollega energia.
Che cos’è il datalogging? Datalogging (o raccolta dati) è ciò che fa un microcontrollore
quando registra e memorizza misure periodiche di un sensore per una certa quantità di
tempo. I dispositivi di datalogging, o “datalogger”, sono utili in special modo nella ricerca
scientifica. Per esempio, invece di inviare una persona in un determinato luogo distante, per
prendere misure di tempo atmosferico, si può attrezzare una stazione di datalogging
atmosferica. Essa registra misure periodiche, e gli scienziati visitano la stazione quanto
spesso vogliono per raccogliere i dati o, in alcuni casi, la stazione scarica le misure su un
computer tramite telefono cellulare, radio, o satellite.
Il chip sul BASIC Stamp che memorizza programma e dati è mostrato in Figura 7-5.
Questo chip è detto EEPROM, che significa Memoria a sola lettura cancellabile e
programmabile elettricamente (Electrically Erasable Programmable Read-Only
Memory). E’ del tutto impronunciabile, e pronunciare ciascuna delle iniziali di EEPROM
è ancora molto lavoro. Quindi, quando le persone parlano di EEPROM, usualmente
pronunciano: “E-E-Prom”.
Una EEPROM
da 2 KB
memorizza il
vostro codice
sorgente
PBASIC.
Figura 7-5
Chip EEPROM sul modulo
BASIC Stamp
Questa EEPROM memorizza il
vostro codice di programma e
tutti gli altri dati che il vostro
programma pone là,
mantenendoli perfino quando
l’energia è disconnessa.
La Figura 7-6 mostra la finestra della mappa di memoria (Memory Map) dell’Editor del
BASIC Stamp. Potete vedere questa finestra cliccando il menu Run dell’Editor del
BASIC Stamp e scegliendo Memory Map.
La Memory Map (Mappa di memoria) usa colori diversi per mostrare come vengono
usate sia la RAM del modulo BASIC Stamp (variabili in random access memory), sia la
EEPROM (memoria di programma). Il quadratino a cornice rossa nella barra di
scorrimento all’estrema sinistra indica quale porzione della EEPROM è visibile nella
mappa della EEPROM. Potete cliccare e trascinare questo quadratino su e giù per vedere
varie porzioni della memoria EEPROM. Trascinando quel quadratino rosso in giù fino
alla fine, potete vedere come la maggior parte dello spazio di memoria EEPROM è usata
da ProvaFototransistor.bs2 a pagina 222. I byte che contengono simboli di programma
sono evidenziati in blu, e soltanto 35 byte dei 2048 byte componenti la EEPROM sono
utilizzati per il programma. I restanti 2013 byte sono liberi per memorizzare dati.
Figura 7-6
Mappa di
memoria
Per vedere
questa finestra,
cliccate Run, e
scegliete Memory
Map.
La mappa della EEPROM mostra gli indirizzi come valori esadecimali, che sono stati
discussi brevemente nel riquadro Decimale ed esadecimale a pagina 198. I valori lungo
il lato sinistro mostrano l’indirizzo di partenza di ciascuna riga di byte. I numeri lungo il
lato superiore mostrano il numero del byte entro quella riga, da 0 ad F in esadecimale,
che è da 0 a 15 in decimale. Per esempio, in Figura 7-6, il valore eaadecimale C1 è
memorizzato all’indirizzo 7E0. CC è memorizzato all’indirizzo 7E1, 6D è memorizzato
all’indirizzo 7E2, e così via, fino ad E8, che è memorizzato all’indirizzo 7EF. Se scorrete
in su e giù con la barra di scorrimento, vedrete che gli indirizzi più grandi di memoria
sono all’estremità inferiore della mappa della EEPROM, e gli indirizzi più piccoli sono in
cima, con la riga all’estremità superiore che inizia in 000.
I programmi PBASIC sono sempre memorizzati agli indirizzi di EEPROM maggiori,
mostrati all’estremità inferiore della mappa della EEPROM. Così, se il vostro programma
sta per memorizzare dati nella EEPROM, dovrebbe iniziare con l’indirizzo più basso,
iniziare con l’indirizzo 0. Ciò aiuta a garantire che i vostri dati memorizzati non
sovrascriveranno il programma PBASIC, cosa che si tradurrebbe usualmente in un
collasso del programma. Nel caso della mappa della EEPROM mostrata in Figura 7-6, il
programma PBASIC risiede negli indirizzi da 7FF fino a 7DD, iniziando dall’indirizzo
più grande e continuando verso l’indirizzo più piccolo. Quindi la vostra applicazione può
memorizzare dati dall’indirizzo 000 fino all’indirizzo 7DC, procedendo dall’indirizzo più
piccolo al pià grande. In decimale, dall’indirizzo 0 fino all’indirizzo 2012.
Se state pensando di memorizzare dati nella EEPROM, è importante riuscire a convertirli
da esadecimale a decimale per poter calcolare qual è il più grande indirizzo scrivibile.
Qui sotto c’è la matematica per convertire il numero 7DC da esadecimale a decimale.
L’esadecimale è un sistema di numerazione con base 16, il ché significa che, per
rappresentare i suoi valori, usa 16 cifre diverse. Le cifre 0-9 rappresentano i primi dieci
valori, e le lettere A-F rappresentano i valori 10-15. Quando si effettua una conversione
da esadecimale a decimale, ciascuna cifra da destra rappresenta una potenza di sedici più
grande (della cifra precedente). La cifra all’estrema destra è il numero di uni, cioè il
numero di 160 (unità). La cifra successiva da destra è il numero dei 16, cioè il numero di
161. La terza cifra è il numero dei 256, cioè il numero di 162.
Esadecimale 7DC
=
=
=
=
=
(7 × 162) + (D × 161) + (C × 160)
(7 × 162) + (13 × 161) + (12 × 160)
(7 × 256) + (13 × 16) + (12 × 1)
1792 + 208 + 12
2012 (valore decimale, cioè in base 10)
Questo approccio di conversione lavora alla stessa maniera in altre basi di numerazione,
inclusi i valori decimali in base 10. Ad esempio:
2102 = (2 × 103) + (1 × 102) + (0 × 101) + (2 × 100)
= (2 × 1000) + (1 × 100) + (0 × 10) + (2 × 1)
2048 byte = 2 KB.
Sebbene tanto il suffisso maiuscolo “K” e il suffisso minuscolo “k”’siano chiamati “chilo,” essi
hanno significati leggermente differenti. In elettronica e informatica, il K maiuscolo è usato
10
per indicare un kilobyte binario, che è 1 × 2 = 1024.
Quando vogliamo riferirci
esattamente a 1000 byte, dobbiamo usare il k minuscolo, che sta per kilo (chilo, in italiano)
3
e nel sistema metrico è 1 x 10 = 1000.
Inoltre, il suffisso maiuscolo “B”’ sta per byte, mentre il suffisso minuscolo “b” sta per bit.
Questo può comportare una grande differenza perché 2 Kb significa 2048 bit, che sono
2048 numeri differenti, ma ciascun numero è limitato ad un valore di 0 o di 1. In contrasto, 2
KB, sono 2048 byte, ciascuno dei quali può memorizzare un valore nell’intervallo da 0 a
255.
Usare la EEPROM per memorizzare dati può essere molto utile per applicazioni remote.
Un esempio di applicazione remota potrebbe essere un rilevatore di temperature posto in
un camion frigorifero che trasporta cibi congelati. Il rilevatore potrebbe registrare la
temperatura durante l’intero viaggio per vedere se essa è rimasta sempre abbastanza
fredda da assicurare che nessuno degli alimenti trasportati si sia scongelato. Un secondo
esempio è una stazione di rilevamento del tempo atmosferico. Una delle parti di dati che
la stazione potrebbe memorizzare per reperimenti successivi, è costituita dalle condizioni
di luce. Ciò può dare un’indicazione della copertura di nuvole a determinate ore del
giorno, e alcuni studi usano questo dato per controllare gli effetti dell’inquinamento
atmosferico e le tracce di condensazione su aeroplano (con trails, in inglese), sui livelli di
luce che raggiungono la superficie terrestre.
Avendo in mente le registrazioni dei livelli di luce, questa attività introduce una tecnica
per memorizzare nella EEPROM i livelli di luce misurati e reperirli di nuovo in un
secondo tempo. In quest‘attività, eseguirete un programma esempio PBASIC che
memorizza una serie di misure di luce nella EEPROM del modulo BASIC Stamp. Dopo
aver terminato questo programma, eseguirete un secondo programma che ritrova i valori
posti nella EEPROM dal primo e li visualizza nel terminale di Debug.
Programmazione di memorizzazione a lungo termine
Per memorizzare valori nella EEPROM si usa il comando WRITE, e per reperire quei
valori si usa il comando READ.
La sintassi del comando WRITE è la seguente:
WRITE Locazione, {WORD} Valore
Ad esempio, se volete scrivere il valore 195 all’indirizzo 7 nella EEPROM, userete il
comando:
WRITE 7, 195
I valori word possono essere dovunque da 0 a 65565 mentre i valori byte possono
contenere soltanto numeri da 0 a 255. Un valore word prende lo spazio di due byte. Se
volete scrivere un valore a dimensione word nella EEPROM, dovete usare il modificatore
opzionale Word. State attenti, nondimeno. Poiché una word prende due byte, dovete
saltare uno degli indirizzi a dimensione byte nella EEPROM prima di poter scrivere
un’altra word. Diciamo che vi occorre salvare due valori word nella EEPROM: 659 e
50012. Se volete memorizzare il primo valore all’indirizzo 8, dovrete scrivere il secondo
valore all’indirizzo 10.
WRITE 8, Word 659
WRITE 10, Word 50012
E’ possible sovrascrivere il vostro programma? Si, e se lo fate, è probabile che il
programma inizi a comportarsi in modo strano o smetta completamente di girare. Poiché i
simboli di un programma PBASIC risiedono agli indirizzi più alti della EEPROM, è meglio
usare i valori di Location più piccoli per memorizzare numeri con il comando WRITE.
Come posso sapere se il Location che sto usando è troppo grande? Potete usare la
mappa di memoria per immaginare quale sia il valore più grande non usato dal vostro
programma PBASIC. La spiegazione che segue la Figura 7-6 a pagina 219 descrive come
calcolare quanti indirizzi di memoria siano disponibili. Come scorciatoia per convertire un
esadecimale in decimale, potete usare il formattatore DEC del comando DEBUG e il
formattatore esadecimale $ come fatto qui sotto:
DEBUG DEC $7DC
Il vostro programma visualizzerà il valore decimale dell’esadecimale 7DC poiché il
formattatore esadecimale $ dice al comando DEBUG che 7DC è un numero esadecimale.
Poi, il formattatore DEC fa visualizzare al comando DEBUG quel valore in formato decimale.
Programma esempio: MemorizzaMisureDiLuceInEeprom.bs2
Questo programma esempio mostra come usare il comando WRITE prendendo misure di
luce ogni 5 secondi, per 2 minuti e ½, e memorizzandole in EEPROM. Come il
programma esempio dell’attività precedente, esso visualizza le misure nel terminale di
Debug, ma memorizza anche ciascuna misura in EEPROM, per reperimento successivo
da parte di un diverso programma che usa il comando READ.
 Digitate ed eseguite MemorizzaMisureDiLuceInEeprom.bs2.
 Registrate le misure visualizzate dal terminale di Debug così da poter verificare
le misure lette indietro dalla EEPROM.
 Aumentate gradualmente l’ombra sul fototransistor durante il periodo di prova di
2 ½ minuti per ottenere dati significativi.
Specialmente se avete una scheda USB, riconnetterla al computer può reimpostare il
BASIC Stamp e riavviare il programma, nel qual caso, esso ripartirà prendendo un nuovo
insieme di misure.
 Dopo che MemorizzaMisureDiLuceInEeprom.bs2 ha completato la sua
esecuzione, disconnettere energia dalla vostra scheda immediatamente e
lasciatela disconnessa finché siete pronti ad eseguire il programma esempio
successivo: LeggiMisureDiLuceDaEeprom.bs2.
Potete cambiare le pause nel ciclo FOR…NEXT. Questo programma esempio ha pause di 5
secondi, che evidenziano le misure periodiche prese dai dispoositivi di datalogging. Esse
potrebbero sembrare brevi o lunghe, potete, quindi, ridurre il PAUSE 5000 a PAUSE 500
per far eseguire il programma dieci volte più velocemente per ogni prova.
' Che cos’è un microcontrollore - MemorizzaMisureDiLuceInEeprom.bs2
' Scrive misure di luce nella EEPROM.
' {$STAMP BS2}
' {$PBASIC 2.5}
tempo
IndirizzoEeprom
VAR
VAR
Word
Byte
PAUSE 1000
DEBUG "Inizio delle misure...", CR, CR,
"Misura
Valore", CR,
"----------------", CR
FOR IndirizzoEeprom = 0 TO 58 STEP 2
HIGH 2
PAUSE 5000
RCTIME 2, 1, tempo
DEBUG DEC2 IndirizzoEeprom,
"
", DEC tempo, CR
WRITE IndirizzoEeprom, Word tempo
NEXT
DEBUG "Finito. Adesso, eseguire:", CR,
"LeggiMisureDiLuceDaEeprom.bs2"
END
Come lavora MemorizzaMisureDiLuceInEeprom.bs2
Il ciclo FOR...NEXT che misura i valori a tempo RC e li memorizza nella EEPROM deve
contare in passi di 2 poiché nella EEPROM sono scritti i valori word.
FOR IndirizzoEeprom = 0 to 58 STEP 2
Il comando RCTIME carica la misura di tempo di decadimento nella variabile tempo
dimensionata a word.
RCTIME 2, 1, tempo
Il valore che la variabile tempo memorizza è copiato all’indirizzo di EEPROM dato dal
valore corrente della variabile IndirizzoEeprom ogni volta che il ciclo è eseguito.
Ricordate che l’indirizzo per un comando WRITE è sempre in termini di byte. Quindi, la
variabile IndirizzoEeprom è incrementata di due ciascuna volta che si esegue il ciclo
perché una variabile Word occupa due byte.
WRITE IndirizzoEeprom, Word tempo
NEXT
Programmazione del reperimento dati
Per reperire dalla EEPROM i valori che avete appena registrato, potete usare il comando
READ. La sintassi del comando READ è la seguente:
READ Location, {WORD} Variable
Mentre il comando WRITE può copiare un valore sia da una costante, sia da una variabile,
nella EEPROM, il comando READ deve copiare il valore memorizzato ad un dato
indirizzo in EEPROM, in una variabile; come suggerisce il suo nome, l’argomento
Variable deve essere una variabile.
Tenete a mente che le variabili sono memorizzate nella RAM del modulo BASIC Stamp. A
differenza della EEPROM, i valori in RAM vengono cancellati ogni volta che l’energia viene
disconnessa ed anche ogni volta che si preme il pulsante Reset sulla scheda.
Il BASIC Stamp 2 ha 26 byte di RAM, mostrati sul lato destro della mappa di memoria in
Figura 7-6 a pagina 219. Se dichiarate una variabile word, state usando fino a due byte.
Una dichiarazione di variabile byte usa un byte, un nibble usa mezzo byte, e un bit usa 1/8
di un byte.
Diciamo che ValoreAEeprom e ValoreBEeprom sono variabili Word, e piccoloEE è una
variabile Byte. Queste variabili dovranno essere definite all’inizio di un programma con
dichiarazioni di variabile VAR. Ecco alcuni comandi per reperire i valori già memorizzati
prima a certi indirizzi di EEPROM, con comandi WRITE, forse anche in un programma
differente.
READ 7, piccoloEE
READ 8, Word ValoreAEeprom
READ 10, Word ValoreBEeprom
Il primo comando reperisce un valore byte dall’indirizzo 7 della EEPROM e lo copia
nella variabile chiamata piccoloEE. Il successivo comando copia la word che occupa i
byte di indirizzi 8 e 9 della EEPROM e li memorizza nella variabile word
ValoreAEeprom. L’ultimo dei tre comandi copia la word che occupa i byte di indirizzi
10 ed 11 della EEPROM e li memorizza nella variabile ValoreBEeprom.
Programma esempio: LeggiMisureDiLuceDaEeprom.bs2
Questo programma esempio mostra come usare il comando READ per reperire le misure di
luce memorizzate in EEPROM dal programma MemorizzaMisureDiLuceInEeprom.bs2.
 Riconnettere energia alla vostra scheda.
 Digitate LeggiMisureDiLuceDaEeprom.bs2 nell’Editor del BASIC Stamp.
 Se avete disconnesso energia dalla scheda, quando la riconnettete, cliccate
immediatamente il pulsante Run dell’Editor del BASIC Stamp per scaricare il
programma entro il BASIC Stamp.
Non aspettate più di 6 secondi tra il riconnettere energia e il caricare
LeggiMisureDiLuceDaEeprom.bs2 entro il BASIC Stamp o il programma che è ancora nella
memoria di programma (MemorizzaMisureDiLuceInEeprom.bs2) partirà registrando sopra le
misure precedenti. Inoltre, se riducete la Duration del comando PAUSE da 5000 a 500,
avrete soltanto 1,5 secondi!
 Confrontate la tabella nel terminale di Debug visualizzata da questo programma
con quella visualizzata da MemorizzaMisureDiLuceInEeprom.bs2, e verificate
che i valori siano gli stessi.
' Che cos’è un microcontrollore - LeggiMisureDiLuceDaEeprom.bs2
' Legge misure di luce dalla EEPROM.
' {$STAMP BS2}
' {$PBASIC 2.5}
Tempo
IndirizzoEeprom
VAR
VAR
Word
Byte
PAUSE 1000
DEBUG "Reperimento
"Misura
"----------
misure", CR, CR,
Valore", CR,
------", CR
FOR IndirizzoEeprom = 0 TO 58 STEP 2
READ IndirizzoEeprom, Word tempo
DEBUG DEC2 IndirizzoEeprom, "
NEXT
END
", DEC tempo, CR
Come lavora LeggiMisureDiLuceDaEeprom.bs2
Come con il comando WRITE, il comando READ si affida a indirizzi di byte. Poiché
vogliamo leggere valori da word della EEPROM, la variabile IndirizzoEeprom deve
sommare 2 al suo contenuto ad ogni ripetizione del ciclo FOR...NEXT.
FOR IndirizzoEeprom = 0 to 58 STEP 2
Il comando READ ottiene il valore a dimensione word presente in IndirizzoEeprom, e il
valore viene copiato nella variabile tempo.
READ IndirizzoEeprom, Word tempo
I valori delle variabili tempo ed IndirizzoEeprom sono visualizzati in colonne adiacenti
in forma di tabella nel terminale di Debug.
DEBUG DEC2 IndirizzoEeprom, "
NEXT
", DEC tempo, CR
Il vostro turno – Più misure
 Modificate MemorizzaMisureDiLuceInEeprom.bs2 in modo che prenda e
registri il doppio di misure nella stessa quantità di tempo.
 Modificate LeggiMisureDiLuceDaEeprom.bs2 in modo che visualizzi tutte le
misure da MemorizzaMisureDiLuceInEeprom.bs2 appena modificato.
ATTIVITÀ #3: REGISTRARE GRAFICAMENTE MISURE DI LUCE
(OPZIONALE)
L’elenco di misure come quelle della tabella prodotta dai programmi precedenti può
risultare noioso da analizzare. Immaginate di leggere centinaia di questi numeri cercando
quando sorge il sole. O forse state cercando un evento particolare, come quando il
sensore di luce viene coperto per breve tempo. Potreste perfino star cercando una
combinazione di misure che dicano quanto frequentemente il sensore di luce è stato
coperto. Questa informazione può essere utile se il sensore di luce è posto in una zona
attraversata da persone o animali, o un oggetto che passa sopra un sensore posto sopra
una cinghia di raccolta dev’essere registrato e analizzato. Indipendentemente
dall’applicazione, se dovete lavorare tutti con un lungo elenco di numeri, trovare quegli
eventi e configurazioni può essere compito molto difficile e che porta via molto tempo.
Se invece fate un grafico dell’elenco delle misure, vi farà trovare eventi e configurazioni
in modo molto più facile. La persona, l’animale o l’oggetto che passa sopra il sensore di
luce sarà mostrata come un punto in alto o un picco nelle misure. La Figura 7-7 mostra un
esempio di grafico che indica la velocità alla quale gli oggetti su una cinghia di raccolta
stanno passando sopra il sensore. I picchi del grafico avvengono quando le misure
diventano grandi. Nel caso di una cinghia di raccolta, essi indicherebbero che un oggetto
che passa sopra il sensore produce un’ombra. Queso grafico rende facile vedere a colpo
d’occhio che un oggetto passa sopra il sensore grosso modo ogni 7 secondi, ma che
l’oggetto che stiamo aspettando a 28 secondi era o non era là.
Figura 7-7 Grafico delle misure di luce di un fototransistor
Tempo di decadimento
funzione del tempo
Decay Time Vs.inTime
per
circuito RC diRC
unCircuit
fototransistor
forilPhototransistor
9000
8000
7000
Tempo di dec. (2 us)
6000
5000
4000
3000
2000
1000
0
0
10
"Tempo di decadimento"
20
30
40
50
60
Tempo (s)
Il grafico in Figura 7-7 è stato generato copiando valori nel terminale di Debug ed
incollandoli su un file di testo che è stato poi importato in un foglio dello spreadsheet
Microsoft Excel. Alcune utilità grafiche possono prenderee il posto del terminale di
Debug e riportare in grafico direttamente i valori invece di visualizzarli come elenchi di
numeri. La Figura 7-8 mostra un esempio di una di queste, chiamata StampPlot LITE.
Figura 7-8 StampPlot LITE
In questa attività opzionale, potete andare al sito www.parallax.com/go/WAM e quindi
seguire il link del Data Plotting (tracciamento grafico di dati) per trovare un certo
numero di attività che mostrano come tracciare grafici di valori usando vari pacchetti
software di spreadsheet ed utilità grafiche.
ATTIVITÀ #4: UN SEMPLICE MISURATORE DI LUCE
Le informazioni del sensore di luce possono essere comunicate in molti modi. Il
misuratore di luce con il quale lavorerete in questa attività cambia la velocità alla quale il
display lampeggia in funzione dell’intensità luminosa che rileva.
Parti del misuratore di luce
(1) Fototransistor
(1) Resistenza – 220 Ω (rosso-sosso-marrone)
(2) Condensatori – 0.01 μF (etichettati 103)
(1) Condensatore – 0.1 μF (etichettato 104)
(1) display LED a 7 segmenti
(6) Connettori di filo
Costruzione del circuito del misuratore di luce
La Figura 7-9 mostra lo schema del circuito misto display LED a 7 segmenti –
fototransistor usato per il misuratore di luce, e la Figura 7-10 mostra un diagramma di
cablaggio dei circuiti. Il circuito del fototransistor è lo stesso delle ultime due attività, e il
circuito del display LED a 7 segmenti è lo stesso della Figura 6-11 a pagina 190.
 Provate il display LED a 7 segmenti per assicurarvi che sia stato connesso in
modo corretto, usando il programma ProvaSegmentoConAltoBasso.bs2 dalla
Attività#2, Capitolo 6, che inizia a pagina 189.
LED
Figura 7-9
Schema del
circuito del
misuratore di luce
comune
Figura 7-10
Diagramma di
cablaggio per la
Figura 7-9
Uso di subroutine
La maggior parte dei programmi che avete scritto fin qui opera entro un ciclo
DO...LOOP. Dal momento che l’attività principale di un intero programma si svolge
internamente ad un DO...LOOP, questo è chiamato di solito programma (o routine)
principale. Man mano che aggiungete al vostro programma più circuiti e più funzioni
utili, può risultare abbastanza difficile tenere traccia di tutto il codice nel programma
principale. I vostri programmi saranno molto più semplici e facili da gestire se li
organizzate, invece, in segmenti di codice più piccoli che svolgono determinati compiti.
Il PBASIC ha alcuni comandi che potete usare per fare in modo che il programma esca
fuori dal segmento principale, faccia un lavoro, e poi torni indietro allo stesso punto del
segmento principale da cui era partito. Ciò vi consentirà di mantenere ciascun segmento
di codice che svolge un compito particolare, in un certo altro posto rispetto al segmento
principale. Ciascuna volta in cui vi serve che il programma svolga uno di questi compiti,
potete scrivere un comando interno al segmento principale che dica al programma di
saltare a quel compito, eseguirlo, e tornare indietro quando il compito è stato svolto. I
compiti sono chiamati subroutine e questo processo appena descritto è detto chiamare
una subroutine.
La Figura 7-11 mostra un esempio di subroutine e del suo uso. Il comando GOSUB
Subroutine_Name fa saltare il programma all’etichetta Subroutine_Name:. Quando il
programma raggiunge l’etichetta, esegue i comandi fino al comando RETURN. Quindi, il
programma torna indietro al comando che seguiva il comando GOSUB. Nel caso
dell’esempio in Figura 7-11, il comando successivo è: DEBUG "Next command".
DO
GOSUB Subroutine_Name
DEBUG "Next command"
LOOP
Subroutine_Name:
DEBUG "This is a subroutine..."
PAUSE 3000
RETURN
Figura 7-11
Come lavora una
Subroutine
Che cosa è una etichetta? Una etichetta è un nome usato come segnaposto nel vostro
programma. GOSUB è uno dei comandi usabili per saltare a un‘etichetta. Altri comandi sono
GOTO, ON GOTO, e ON GOSUB. Una etichetta deve terminare con “due punti”, e per amore di
stile, separate le parole che la compongono con il carattere underscore (sottolineatura) in
modo che siano facili da riconoscere. Quando scegliete un nome come etichetta,
assicuratevi di non usare una parola riservata o un nome che è già stato usato per una
variabile o costante. Le altre regole per un nome di etichetta sono le stesse di quelle
adoperate per i nomi delle variabili, elencate nel box informativo a pagina 47.
Programma esempio: SubroutineSemplici.bs2
Questo programma esempio mostra come lavorino le subroutine, inviando messaggi al
terminale di Debug.
 Esaminate SubroutineSemplici.bs2 e provate ad indovinare l’ordine in cui
verranno eseguiti i comandi DEBUG.
 Digitate ed eseguite il programma.
 Confrontate il comportamento effettivo del programma con le vostre previsioni.
' Che cos’è un microcontrollore - SubroutineSemplici.bs2
' Mostra come lavorano le subroutine.
' {$STAMP BS2}
' {$PBASIC 2.5}
PAUSE 1000
DO
DEBUG
PAUSE
GOSUB
DEBUG
PAUSE
GOSUB
DEBUG
PAUSE
CLS, "Inizio programma principale.", CR
2000
Prima_Subroutine
"Ritorno al programma principale.", CR
2000
Seconda_Subroutine
"Ripeto il programma principale...", CR
2000
LOOP
Prima_Subroutine:
DEBUG " Esecuzione prima
DEBUG "subroutine.", CR
PAUSE 3000
RETURN
"
Seconda_Subroutine:
DEBUG " Esecuzione seconda "
PAUSE 3000
RETURN
Come lavora SubroutineSemplici.bs2
La Figura 7-12 mostra come lavora nel programma principale (ciclo DO...LOOP) la
chiamata di Prima_Subroutine. Il comando GOSUB Prima_Subroutine manda il
programma all’etichetta Prima_Subroutine:. Poi, vengono eseguiti i tre comandi
interni alla subroutine. Quando il programma incontra il comando RETURN, salta indietro
al comando che viene proprio dopo il comando GOSUB Prima_Subroutine, che è DEBUG
"Ritorno al programma principale.", CR.
Che cos’è una chiamata di subroutine? Quando usate il comando GOSUB per far saltare
il programma ad una subroutine, questo compito è detto chiamata di una subroutine.
PAUSE 2000
GOSUB Prima_Subroutine
DEBUG "Ritorno al programma principale.", CR
Prima_Subroutine:
DEBUG "
Esecuzione di prima "
Figura 7-12
Chiamata di
Prima
Subroutine
PAUSE 3000
RETURN
La Figura 7-13 mostra un secondo esempio dello stesso processo con la chiamata della
seconda subroutine (GOSUB Seconda_Subroutine).
PAUSE 2000
GOSUB Seconda_Subroutine
DEBUG "Ripeto il programma principale...", CR
Seconda_Subroutine:
DEBUG "
Esecuzione seconda "
DEBUG "subroutine", CR
Figura 7-13
Chiamata
Seconda
Subroutine
PAUSE 3000
RETURN
Il vostro turno – Aggiunta e annidamento di subroutine
Potete aggiungere altre subroutine dopo le due che sono nel programma, e chiamarle
dall’interno del programma principale.
 Aggiungete la subroutine mostrata in Figura 7-11 a pagina 231 al programma
SubroutineSemplici.bs2.
 Fate qualsiasi modifica sia necessaria ai comandi DEBUG in modo che il loro
display vada d’accordo con tutte e tre le subroutine.
Potete anche chiamare una subroutine dall’interno di un’altra. Questo evento è detto
annidamento di subroutines.
 Provate a muovere il comando GOSUB che chiama Subroutine_Name entro una
delle altre subroutine, e guardate come lavora.

Quando annidate subroutine la regola è non più di quattro chiamate annidate. Guardate il
Manuale del BASIC Stamp o l’aiuto dell’Editor del BASIC Stamp per avere maggiori
informazioni. Attenzione a GOSUB e RETURN.
Misuratore di luce che usa subroutine
Il programma successivo, MisuratoreDiLuce.bs2, usa subroutine per controllare il display
del LED a 7 segmenti a seconda del livello di luce rilevato dal fototransistor. I segmenti
del display ciclano on e off in una configurazione circolare che va più veloce quando la
luce sul fototransistor diventa più forte. Quando la luce diventa più debole, il ciclo in
configurazione circolare rallenta. Il programma esempio MisuratoreDiLuce.bs2 usa una
subroutine chiamata Aggiorna_Display per controllare l’ordine in cui avanzano i
segmenti del misuratore di luce.
Il programma che mette in moto il misuratore di luce tratterà di tre diverse operazioni:
1. Leggere il fototransistor.
2. Calcolare quanto si debba aspettare prima di aggiornare il display LED a 7
segmenti.
3. Aggiornare il display LED a 7 segmenti.
Ciascuna operazione è contenuta entro la sua propria subroutine, e la routine principale
DO...LOOP chiamerà ciascuna subroutine in sequenza, indefinitamente.
Programma esempio: MisuratoreDiLuce.bs2
Condizioni di illuminazione controllate fanno una bella differenza! Per avere risultati
ottimi, condurre questa prova in un ambiente illuminato da lampade fluorescenti con poca
luce solare, o comunque non alla luce solare diretta (chiudere le tapparelle). Per
informazioni su come calibrare questo misuratore in altre condizioni di illuminazione, vedere
il paragrafo “Il vostro turno”.
 Digitate ed eseguite MisuratoreDiLuce.bs2.
 Verificate che la velocità di ciclo della configurazione circolare visualizzata dal
LED a 7 segmenti sia controllata dalle condizioni di illuminazione percepite dal
fototransistor. Fate questo gettando su di esso un’ombra con la vostra mano o
con un pezzo di carta e verificate che la velocità della configurazione circolare
del display rallenti.
' Che cos’è un microcontrollore - MisuratoreDiLuce.bs2
' Indica il livello di luce usando un display a 7 segmenti.
' {$STAMP BS2}
' {$PBASIC 2.5}
PAUSE 1000
indice
tempo
VAR
VAR
Nib
Word
' Dichiarazione di variabili.
OUTH = %00000000
DIRH = %11111111
' Inizializza display a 7 segmenti.
DO
' Routine principale.
GOSUB Ottieni_Tempo_Rc
GOSUB Ritarda
GOSUB Aggiorna_Display
LOOP
' Subroutine
Ottieni_Tempo_Rc:
' subroutine tempo RC
HIGH 2
PAUSE 3
RCTIME 2, 1, tempo
RETURN
Ritarda:
' subroutine ritarda.
PAUSE tempo / 3
RETURN
Aggiorna_Display:
' subroutine che aggiorna il Display.
IF indice = 6 THEN indice = 0
'
BAFG.CDE
LOOKUP indice, [ %01000000,
%10000000,
%00000100,
%00000010,
%00000001,
%00100000 ], OUTH
indice = indice + 1
RETURN
Come lavora MisuratoreDiLuce.bs2
Le prime due righe del programma dichiarano le variabili. Non importa se queste
variabili siano usate nelle subroutine o nel programma principale, è sempre meglio
dichiarare le variabili (e le costanti) all’inizio del programma.
Visto che questa è una pratica così comune, la sezione di codice ha un nome,
“Dichiarazioni di variabili.” Questo nome è mostrato nel commento a destra della prima
dichiarazione di variabile.
indice
tempo
VAR Nib
VAR Word
' Dichiarazioni di variabili.
Molti programmi hanno anche cose che debbono essere fatte una volta sola all’inizio del
programma. Impostare bassi tutti i pin I/O del 7 segmenti e poi farli diventare output, è
un esempio.
Questa sezione di programma PBASIC ha anch’essa un nome,
“Inizializzazione.”
OUTH = %00000000
DIRH = %11111111
' Inizializza display a 7 segmenti.
Il segmento di codice successivo è detto routine principale. La routine principale chiama
per prima la subroutine Ottieni_tempo_Rc. Poi, chiama la subroutine Ritarda, e
dopo di questa, chiama la subroutine Aggiorna_Display. Tenete a mente che il
programma va sulle tre subroutine quanto più velocemente può, all’infinito.
DO
GOSUB Ottieni_tempo_Rc
GOSUB Ritarda
GOSUB Aggiorna_Display
LOOP
' Routine principale.
Tutte le subroutine sono poste di solito dopo la routine principale. Il nome della prima
subroutine è Ottieni_tempo_Rc, ed essa prende le misure di tempo (di decadimento)
RC sul circuito del fototransistor. La subroutine ha un comando PAUSE che carica il
condensatore. La Duration di questo comando è piccola perché occorre che la pausa
consenta soltanto di assicurarsi che il condensatore si sia caricato. Notate che il comando
RCTIME imposta il valore della variabile tempo. Questa variabile sarà usata dalla seconda
subroutine.
Ottieni_tempo_Rc:
HIGH 2
PAUSE 3
RCTIME 2, 1, tempo
RETURN
' Subroutine
' subroutine tempo RC
Il nome della seconda subroutine è Ritarda, e tutto ciò che contiene è un comando
PAUSE tempo / 3. Il comando PAUSE consente che il tempo di decadimento misurato
(cioè quanto sia alta la luce) controlli il ritardo tra l’accensione di ciascun segmento
lumiinoso nel display a rivoluzione circolare del LED a 7 segmenti. Il valore a destra
dell’operatore / di divisione può essere reso maggiore per avere una rotazione più veloce
in condizioni di luce bassa o più lento per rallentare il display in condizioni di luce più
alta. Potete anche usare * per moltiplicare la variabile tempo per un valore invece che
dividerla, per fare in modo che il display vada parecchio più piano, e per un controllo più
preciso sulla velocità, non dimenticate l’operatore */. Maggiori informazioni su questo
operatore sono nella sezione “Il vostro turno”.
Ritarda:
PAUSE tempo / 3
RETURN
La terza subroutine è detta Aggiorna_Display. Il comando LOOKUP in questa
subroutine contiene una tabella con configurazioni di sei bit, usate per creare le
configurazioni circolari intorno al perimetro esterno del display LED a 7 segmenti.
Aggiungendo 1 alla variabile indice ciascuna volta che la subroutine viene richiamata,
si fa immettere nella variabile OUTH la configurazione successiva nella sequenza. Ci sono
solo sei entrate nella tabella del LOOKUP per i valori di indice da 0 fino a 5. Che cosa
accade quando il valore di indice passa a 6? Il comando LOOKUP non sa tornare
automaticamente indietro alla prima entrata, ma voi potete usare una frase IF...THEN
per correggere questo problema. Il comando IF indice = 6 THEN indice = 0
reimposta il valore di indice a 0 ogni volta che esso va a 6. Esso fa anche ripetere
indefinitamente la sequenza di configurazioni di bit posta in OUTH . Ciò, a sua volta, fa in
modo che il display LED a 7 segmenti ripeta la sua configurazione circolare
indefinitamente.
Aggiorna_Display:
'
BAFG.CDE
%10000000,
%00000100,
%00000010,
%00000001,
%00100000 ], OUTH
indice = indice + 1
RETURN
Il vostro turno – Regolazione dell’hardware e del software del misuratore
Ci sono due modi per cambiare la sensibilità del misuratore. Primo: il “software,” che è
il programma PBASIC, si può modificare per regolare la velocità. Come già ricordato
prima, dividendo la variabile tempo – nel comando PAUSE tempo / 3 della subroutine
Ritarda - per numeri superiori a 3, si accelererà il display, e numeri più piccoli lo
rallenteranno. Per rallentarlo davvero, tempo può anche essere moltiplicato per valori
con l’operatore di moltiplicazione *, e per una regolazione più precisa, c’è l’operatore */.
Quando connettete dei condensatori in parallelo, i loro valori si sommano. Quindi, se
inserite un secondo condensatore da 0,01 μF proprio appresso al primo, come mostrato in
Figura 7-14 e Figura 7-15 (connessione in parallelo), la capacità totale sarà 0,02 μF. Con
una capacità doppia, la misura del decadimento per lo stesso livello di luce durerà il
doppio.
 Connettete il secondo condensatore da 0,01 μF proprio accanto al primo nella
porzione sensore di luce del circuito del misuratore di luce in Figura 7-14 e
Figura 7-15.
 Eseguite MisuratoreDiLuce.bs2 ed osservate il risultato.
Poiché le misure di tempo saranno più grandi del doppio, la configurazione circolare del
LED a 7 segmenti dovrebbe ruotare due volte più velocemente.
Figura 7-14
Due condensatori da
0,01 μF in parallelo =
0,02 μF
Figura 7-15
Circuiti del Misuratore
di luce con due
condensatori da 0,01
μF in parallelo
Invece di metà della velocità con un condensatore da 0,01 μF, che ve ne pare di un
decimo della velocità? Potete far questo sostituendo i due condensatori da 0,01 μF con
un condensatore da 0,1 μF. Questo funzionerà bene in ambienti molto illuminati, ma sarà
probabilmente un po’ più lento con illuminazione normale. Ricordate che quando usate
un condensatore dieci volte più grande, la misura del tempo RC prenderà un tempo dieci
volte maggiore.
 Sostituite i condensatori da 0,01 µF con un condensatore da 0,1 µF.
 Eseguite il programma e guardate se l’effetto previsto si verifica.
 Prima di continuare, reimpostate il circuito in modo che ci sia un condensatore
da 0,01 in parallelo col fototransistor iniziando di nuovo, come mostrato dalla
Figura 7-9 e dalla Figura 7-10, a pagina 230.
 Provate il circuito ripristinato per verificare che lavori prima di continuare.
Cosa è meglio, modificare il software o regolare l’hardware? Potete sempre provare ad
usare il meglio di entrambi i mondi. Prendete un condensatore che vi dà le misure più
accurate nella maggior gamma di livelli di illuminazione. Una volta che il vostro hardware è
il migliore che potete avere, usate il software per regolare automaticamente il misuratore di
luce in modo che operi bene per l’utente sotto la maggior gamma di condizioni. Ciò prende
un considerevole ammontare di prove e raffinamenti, ma tutto questo è parte del processo di
sviluppo di un prodotto.
ATTIVITÀ #5: USCITA ON/OFF DI UN FOTOTRANSISTOR
Prima che i microcontrollori fossero d’uso comune nei prodotti, nei circuiti venivano
usate le fotoresistenze che variavano il loro voltaggio di uscita. Quando il voltaggio
scendeva sotto un valore di soglia, che indicava le ore notturne, altri circuiti del
dispositivo accendevano le luci. Quando il voltaggio superava la soglia, indicando con
ciò la luce del giorno, gli altri circuiti nel dispositivo spegnevano le luci. Questo
comportamento da interruttore binario di luci può essere emulato con lo stesso BASIC
Stamp e il circuito di decadimento RC, modificando semplicemente il programma
PBASIC. In alternativa, il circuito può essere modificato in modo che invii un 1 o uno 0
ad un pin I/O a seconda del valore di voltaggio fornito al pin, in modo simile a quello in
cui si comporta un pulsante. In questa attività, proverete entrambi questi approcci.
Regolazione del programma per gli stati On/Off
FototransistorAnalogicoABinario.bs2 prende l’intervallo di misure del fototransistor e lo
confronta col punto a metà strada tra la misura più grande e quella più piccola. Se la
misura è al disopra del punto a metà strada, visualizza “Accendi le luci”; altrimenti,
visualizza “Spegni le luci.” Il programma usa direttive costanti per definire le misure più
grande e più piccola che il programma dovrebbe aspettarsi dal circuito del fototransistor.
valMax
valMin
CON
CON
4000
100
Il programma usa anche gli operatori MIN e MAX per garantire che i valori stiano entro
questi limiti, prima di utilizzarli per prendere qualsiasi decisione. Se tempo è maggiore
di valMax (4000 nel programma esempio), la frase imposta tempo a valMax = 4000.
Analogamente se tempo è minore di valMin (100 nel programma esempio), la frase
imposta tempo a valMin = 100.
tempo = tempo MAX valMax MIN valMin
Una frase IF...THEN...ELSE converte l’intervallo dei valori analogici digitati in una
uscita binaria che prende la forma di messaggi accendi-luci o spegni-luci.
IF tempo > (valMax - valMin) / 2 THEN
DEBUG CR, "Accendi le luci "
ELSE
DEBUG CR, "Spegni le luci "
ENDIF
Prima che questo programma lavori correttamente, dovete calibrare le vostre condizioni
di illuminazione come segue:
 Controllate il circuito del fototransistor per assicurarvi che abbia soltanto un
condensatore da 0,01 μF (etichettato 103).
 Digitate FototransistorAnalogicoABinario.bs2 nell’Editor del BASIC Stamp.
Assicuratevi di aggiungere uno spazio extra dopo la “i” di “luci” nel messaggio
"Accendi le luci ". Altrimenti, dal messaggio "Spegni le luci ", che ha un
carattere in meno, otterrete una “i” fantasma, prodotta dal primo messaggio.
 Caricate il programma nel BASIC Stamp.
 Osservate il terminale di Debug quando applicate le condizioni di più buio e più
luce che volete provare, e prendete nota dei valori massimo e minimo di tempo
risultanti.
 Digitate questi valori nelle direttive valMax e valMin del programma.
Ora, il vostro programma è pronto per essere eseguito e provato.
 Caricate il programma modificato nel BASIC Stamp.
 Provatelo per verificare che le condizioni di luce bassa producano il messaggio
“Accendi le luci ” e le condizioni di luce forte producano il messaggio “Spegni
le luci”.
' Che cos’è un microcontrollore - FototransistorAnalogicoABinario.bs2
' Cambia le misure analogiche del fototransistor in un risultato binario.
' {$STAMP BS2}
' {$PBASIC 2.5}
valMax
valMin
CON
CON
4000
100
tempo
VAR
Word
PAUSE 1000
DO
HIGH 2
PAUSE 100
RCTIME 2, 1, tempo
DEBUG HOME, "tempo = ", DEC5 tempo
ELSE
ENDIF
LOOP
Il vostro turno – Soglie differenti per luce e buio
Se provate ad incorporare FototransistorAnalogicoABinario.bs2 entro un sistema di
illluminazione automatico, esso ha un difetto potenziale. Diciamo che fuori è abbastanza
buio per far passare la misura di tempo al di sopra di (valMax – valMin) / 2, in modo
che la luce venga accesa. Ma se il sensore rileva quella luce, causerà il passaggio della
misura al di sotto di(valMax – valMin) / 2, in modo che la luce si spegnerà di nuovo.
Questo ciclo accendi/spegni della luce potrbbe ripetersi rapidamente per tutta la notte!
La Figura 7-16 mostra in un grafico come potrebbe lavorare questa cosa. Non appena il
livello di luce scende, il valore della variabile tempo aumenta, e quando esso oltrepassa
la soglia, le luci si accenderanno automaticamente. Quindi, dal momento che il
fototransistor sente la luce che si è appena accesa, la misura della variabile tempo cade di
nuovo sotto la soglia, quindi la luce si spegne. Allora, il valore della variabile tempo
aumenta di nuovo, e supererà la soglia, per cui le luci si accenderanno, e la variabile
tempo cade di nuovo sotto la soglia, e così via …
valMax
"Accendi le luci "
(valMax - valMin) / 2
"Spegni le luci"
Figura 7-16
Oscillazioni
sopra/sotto una
soglia
valMin
Un rimedio a questo problema è aggiungere una seconda soglia, come illustrato nella
Figura 7-17. La soglia “Accendi le luci” accende le luci soltanto dopo che si è fatto buio
completo, e la soglia “Spegni le luci” spegne le luci soltanto dopo che si è fatto
completamente giorno. Con questo sistema, la luce si accende dopo che tempo passa
entro l’intervallo “Accendi le luci”. L’accensione delle luci fa più chiaro di quanto era,
quindi tempo cade leggermente, ma dal momento che non cade di nuovo chiaro al di
sotto della soglia “Spegni le luci”, non cambia nulla, e la luce resta accesa come in realtà
dovrebbe. Per descrivere questo tipo di sistema si usa il termine isteresi, con due diverse
soglie di ingresso che influenzano le sue uscite, assieme ad una zona di non-transizione
tra le due.
valMax
"Accendi le luci "
(valMax - valMin) / 4 * 3
Nessuna transizione
(valMax - valMin) / 4
"Spegni le luci"
Figura 7-17
Uso di soglie diverse
Alta e Bassa per
prevenire oscillazioni
valMin
Potete implementare questo sistema a due soglie nel vostro codice PBASIC modificando
la frase IF...THEN...ELSEIF di FotransistorAnalogicoABinario.bs2. Eccovi un
esempio:
IF tempo > (valMax - valMin) / 4 * 3 THEN
ELSEIF tempo < (valMax - valMin ) / 4 THEN
ENDIF
Il primo blocco di codice IF...THEN visualizza "Accendi le luci " quando la variabile
tempo memorizza un valore che è a più di ¾ di strada dal valore più alto di tempo (luce
minima). Il blocco di codice ELSEIF visualizza "Spegni le luci " soltanto quando la
variabile tempo memorizza un valore che è a meno di ¼ di strada sopra il valore di tempo
più piccolo (luce massima).
 Salvate FototransistorAnalogicoABinario.bs2 come FotransistorIsteresi.bs2.
 Prima di modificare FotransistorIsteresi.bs2, provatelo per accertarvi che la
soglia esistente lavori. Ripetete i passi di calibrazione di valMin e valMax
(visti prima del codice esempio di FototransistorAnalogicoABinario.bs2), se la
luce è cambiata.
 Sostituite la frase IF...ELSE...ENDIF di FotransistorIsteresi.bs2 con la
IF...ELSEIF...ENDIF appena discussa.
 Caricate FotransistorIsteresi.bs2 nel BASIC Stamp.
 Provatelo e verificate che la soglia “Accendi le luci” sia la più buia, e la soglia
“Spegni le luci” sia la più luminosa.
Se aggiungete un circuito con LED e modificate il codice in modo che accenda e spenga
il LED, potrebbero accadere alcune cose interessanti. Potreste ancora vedere il
comportamento on/off (accendi/spegni) quando diventa buio, anche con l’isteresi
programmata, specialmente se ponete il LED proprio vicino al fototransistor,. Quanto
lontano dal fototransistor dovrà essere il LED per ottenere che le due soglie prevengano il
comportamento on/off? Supponendo che valMin e valMax siano gli stessi in entrambi i
programmi, quanto dovrà essere lontano il LED per far operare il programma
FototransistorAnalogicoABinario.bs2 non modificato in modo corretto?
TTL Vs. Trigger di Schmitt
Il vostro pin I/O del BASIC Stamp invia e riceve segnali usando la transistor-transistor logic
(TTL). Come output, il pin I/O invia un segnale alto di 5 V o un segnale basso di 0 V. Il lato
sinistro della Figura 7-18 mostra il pin I/O che si comporta come input. Il registro IN del pin
I/O (IN0, IN1, IN2, ecc.) memorizza un 1 se il voltaggio applicato è sopra 1,4 V, o uno 0 se
è sotto 1,4 V. Nella figura questi sono indicati come 1 Logico e 0 Logico.
Un trigger di Schmitt è un circuito rappresentato dal simbolo al centro della Figura 7-18. Il
lato destro della Figura 7-18 mostra come si comporterebbe un pin I/O impostato come input
se avesse incorporato un circuito trigger di Schmitt. Come il codice PBASIC con due soglie,
il trigger di Schmitt ha una isteresi. Il valore di input memorizzato dal registro INx del pin
I/O non cambia da 0 ad 1 fino a quando il voltaggio di input supera 4,25 V. Analogamente,
non cambia da 1 a 0 fino a quando il voltaggio di input scende sotto 0,75 V. Il BASIC Stamp
2px ha un comando PBASIC che consente di configurare i suoi pin di input come trigger di
Schmitt.
Figura 7-18 Soglie e simbolo di TTL Vs. Trigger di Schmitt
Soglie
TTL
Simbolo del
Trigger di Schmitt
5V
Soglia
Trigger di Schmitt
5V
≈4.25 V
1 Logico
1 Logico
Nessun Cambiamento
≈1.4 V
0 Logico
0V
≈0.75 V
0V
0 Logico
Regolazione del circuito per gli stati On/Off
Come è stato ricordato nel Capitolo 5, Attività #2, la soglia di voltaggio per i pin I/O del
BASIC Stamp è 1.4 V. Quando un pin I/O è impostato come input, i voltaggi sopra 1,4
V applicati al pin I/O producono un 1 binario e i voltaggi sotto 1,4 V producono uno 0
binario. Il nodo Vo nel circuito mostrato in Figura 7-19 varia in voltaggio con la luce.
Questo circuito può essere connesso a un pin I/O del BASIC Stamp e, con poca luce, il
voltaggio scenderà sotto la soglia di 1,4 V del BASIC Stamp, e il registro di input del pin
I/O memorizzerà uno 0. In condizioni di luce forte, Vo sale al di sopra di 1,4 V, e il
registro di input del pin I/O memorizzerà un 1.
Figura 7-19
Uscita in voltaggio del
circuito misuratore di luce
+
V
–
=R
I
La ragione per cui il voltaggio in Vo cambia con i livelli di luce è la legge di Ohm, che
stabilisce che il voltaggio ai capi di una resistenza (V in Figura 7-19) è uguale alla
corrente che attraversa la resistenza (I) , moltiplicata per il valore della resistenza (R).
V=I×R
Ricordate che un fototransistor lascia passare più corrente quando è esposto a luce forte, e
meno corrente quando è esposto a luce debole. Diamo un’occhiata più da vicino al
circuito esempio in Figura 7-19 e calcoliamo quanta corrente deve passare nella
resistenza per creare una caduta di 1,4 V ai suoi capi. Prima di tutto, sappiamo che il
valore della resistenza è 10 kΩ, cioè 10,000 Ω. Sappiamo anche che vogliamo un
voltaggio uguale a 1,4 V, così dobbiamo modificare la legge di Ohm per risolvere in
funzione di I. Per farlo, dividiamo entrambi i lati dell’equazione V = I × R per R, e
otteniamo I = V ÷ R. Poi, sostituiamo i valori noti (V = 1,4 V e R = 10 kΩ), e risolviamo
in funzione di I.
I
=
=
=
V÷R
1,4 V ÷ 10 kΩ
1,4 V ÷ 10.000 Ω
=
=
=
0,00014 V/Ω
0,00014 A
0,14 mA
Ora, che succede se il transistor lascia passare il doppio di quella corrente poiché la luce è
forte, e quale dovrebbe essere il voltaggio ai capi della resistenza? Per il doppio della
corrente, I = 0,28 mA, e la resistenza è ancora 10 kΩ, quindi ora torniamo a risolvere per
V dall’equazione originale V = I × R con I = 0,28 mA ed R = 10 kΩ:
V
=
=
=
=
=
I×R
0,28 mA × 10 kΩ
0,00028 A × 10.000 Ω
2,8 AΩ
2,8 V
Con 2,8 V applicati ad un pin I/O, il suo registro di input memorizzerà un 1 poiché 2,8 V
è sopra al voltaggio di soglia 1,4 V del pin I/O.
Il vostro turno – Più calcoli
Che succede se il fototransistor fa passare nel circuito metà della corrente relativa alla
tensione di soglia (0,07 mA), e quale dovrebbe essere il voltaggio ai capi della resistenza?
Inoltre, cosa memorizzerebbe il registro di input del pin I/O?
Prova del sensore binario di luce
Provare il circuito del sensore di luce binario è molto simile a provare il circuito del
pulsante dall’attività #1, capitolo 3. Quando il circuito è connesso a un pin I/O, il
voltaggio sarà al di sopra o al di sotto della soglia di 1,4 V del pin I/O del BASIC Stamp,
questo produrrà un 1 o uno 0, che saranno visualizzati allora con il terminale di Debug.
Parti del sensore di luce Analogico-a-Binario
(1) Fototransistor
(1) Resistenza – 4,7 kΩ (giallo-viola-rosso)
(1) Resistenza – 100 kΩ (masrrone-nero-giallo)
Circuito del sensore di luce Analogico-a-Binario
Se il circuito è quello mostrato in Figura 7-20, si comporta come un pulsante controllato
dall’oscurità. Il buio produce in2 = 0, la luce forte produce in2 = 1. Tenete a mente
che un pin I/O impostato ad input non influenza il circuito che controlla, perché non
origina o cede alcuna corrente. Ciò rende tanto il pin I/O che la resistenza da 220 Ω
essenzialmente invisibili al circuito. Così, il voltaggio risultante dai calcoli del nostro
circuito fatti nella sezione precedente sarà lo stesso con o senza la resistenza da 220 Ω e il
pin I/O connessi.
Figura 7-20: Schema elettrico e Diagramma di cablaggio per il circuito del sensore di luce
analogico-a-binario connesso ad un pin I/O
Codice di prova sensore di luce Analogico-a-Binario
ProvaBinariaFototransistor.bs2 è una versione modificata di LeggiStatoPulsante.bs2
dall’attività #1 del capitolo 3. A parte la modifica dei commenti, l’unico cambiamento al
programma reale è la riga DEBUG ? IN2, che era DEBUG ? IN3 nel programma esempio
col pulsante, perché il pulsante era connesso a P3 invece di P2.
 Rivedete l’attività #1 del capitolo 3 (pagina 69).
 Usate ProvaFototransistorBinario.bs2 qui sotto per verificare che una luce forte
sul fototransistor produce un 1 mentre il buio produce uno 0. Potreste aver
bisogno di una bella luce molto forte. Se la vostra illuminazione interna risulta
ancora in uno 0, provate con la luce del sole o con quella di un flash molto
ravvicinato. Un rimedio alternativo per la bassa illuminazione è sostituire la
resistenza da 10 kΩ con una resistenza da 100 kΩ.
' Che cos’è un Microcontrollore - ProvaFototransistorBinario.bs2
' Controlla lo stato dell’uscita binaria del circuito di un fototransistor
' ogni 1/4 di secondo.
' {$STAMP BS2}
' {$PBASIC 2.5}
DO
DEBUG ? IN2
PAUSE 250
LOOP
Prova di resistenze in serie
Date un’occhiata ai calcoli V = I × R fatti precedentemente in questa attività. Se la
resistenza in serie è 1/5 del suo valore, il voltaggio ai suoi capi sarà 1/5 del suo valore,
nelle stesse condizioni di luce. Analogamente, una resistenza che sia 10 volte più grande
produrrà un voltaggio dieci volte maggiore.
Cosa accade per questo al nostro circuito? Una resistenza da 100 kΩ al posto di una da
10 kΩ significa che il fototransistor dovrà condurre soltanto 1/10 della corrente perché il
pin I/O del BASIC Stamp salga oltre la soglia di 1,4 V, che a sua volta vuol dire che ci
vuole meno luce per portare un 1 binario nel registro di input del pin I/O. Questo circuito
potrebbe lavorare come sensore in un ambiente che si suppone sia al buio, visto che sarà
sensibile a piccole quantità di luce. Invece, 1/5 del valore della resistenza significa che il
fototransistor deve condurre una corrente 5 volte maggiore, perché il voltaggio ai suoi
capi superi la soglia di 1,4 V, per questo motivo ci vuole più luce per innescare un 1
binario nel registro di input del pin I/O. Quindi, questo circuito sarebbe migliore per
rilevare luce più forte.
 Sperimentate con resistenze di 2 kΩ, 4,7 kΩ, 10 kΩ, e 100 kΩ e confrontate le
variazioni di sensibilità alla luce con ciascuna resistenza.
Il vostro turno – Indicatore di livello di luce bassa
 Scegliete una resistenza con la miglior risposta 1/0 ai livelli di luce bassa della
vostra zona di lavoro.
 Aggiungete al vostro circuito a soglia con fototransistor il LED descritto
nell’attività #3 del Capitolo 3.
 Mettete qualcosa tra il LED e il fototransistor in modo che il fototransistor non
possa “vedere” il LED. Questo eliminerà una potenziale interferenza tra i due
dispositivi.
 Modificate il programma in modo che faccia lampeggiare luce (del LED) quando
si getta ombra sul fototransistor.
ATTIVITÀ #6: PER DIVERTIRSI—MISURA DELLA LUCE ESTERNA CON
UN LED
Come ricordato prima, il circuito introdotto nell’attività #4 è progettato per misure di luce
interna (indoor). Che cosa succede se la vostra applicazione deve prendere misure di luce
all’esterno (outdoor)? Una opzione sarebbe trovare un fototransistor che generi meno
corrente con la stessa quantità di luce. Un’altra opzione sarebbe usare uno degli altri
sensori di luce nel kit “What’s a Microcontroller”. Essi sono camuffati da LED, e si
comportano particolarmente bene per misure di luce intensa.
Quando attravero il LED passa una corrente elettrica, esso emette luce, così cosa pensate
che accada quando la luce brilla su di un LED? Si davvero, può provocare una corrente
elettrica che passa in un circuito. La Figura 7-21 mostra un circuito a LED per rilevare
livelli di luce esterna, o in altre aree a luce molto intensa. Mentre il fototransistor
consente alla corrente di passare purché sia applicata una pressione elettrica (voltaggio),
il LED è più simile ad un sottile pannello solare e crea il suo proprio voltaggio per fornire
la corrente. Per quanto riguarda il circuito a decadimento RC, il risultato con un LED è
all’incirca lo stesso. Il LED conduce più corrente e – con maggior luce – prosciuga il
condensatore della sua carica più rapidamente, e conduce meno corrente e prosciuga il
condensatore meno rapidamente con minor luce.
Giallo
Figura 7-21
Schema per il LED nel
Circuito a tempo RC
sensore di luce
Perché il LED è connesso in senso inverso? Nell’attività #1 del capitolo 5, l’anodo del
LED era connesso alla resistenza da 220 Ω, e il catodo era connesso a massa. Quel
circuito faceva emettere luce al LED come risultato del passaggio di una corrente elettrica
nel LED quando si applicava al circuito una tensione (voltaggio). Quando la luce brilla sul
LED, essa crea un piccolo voltaggio che genera una piccola corrente nella direzione
opposta. Così, il LED deve essere inserito in senso inverso in modo che la corrente che
conduce consente al condensatore di scaricarsi attraverso di esso nelle misure di
decadimento RC.
Parti del LED sensore di luce
(1) LED – giallo
(1) LED – verde
(1) LED – rosso
(1) Connettore di filo
Circuito del LED sensore di luce
Una delle maggiori differenze tra il LED e il fototransistor è che il LED conduce una
corrente molto minore con la stessa quantità di luce, quindi al LED occorre una luce
molto intensa per condurre corrente sufficiente a scaricare il condensatore abbastanza
rapidamente nella misura RCTIME. Ricordate che la misura massima di tempo che
RCTIME può misurare è 65535 × 2 μs ≈ 131 ms. Così per una buona misura di
decadimento RC con il BASIC Stamp, occorre un condensatore molto più piccolo.
Infatti, il circuito lavora meglio senza alcun condensatore esterno . Il LED ha una
piccolo capacità al suo interno, chiamata capacità di giunzione, e i fermagli metallici che
tengono i fili quando li inserite nella breadboard hanno anch’essi la loro capacità. A
ragione, un condensatore è composto da due piastre metalliche (armature) separate da un
isolante detto dielettrico. Così due fermagli metallici interni alla breadboard, separati da
plastica ed aria, formano un condensatore. La combinazione della capacità di giunzione
del LED e della capacità delle mollette (fermagli metallici) della breadboard rende il
LED tale da poterlo usare senza alcun condensatore esterno, come mostrato in Figura
7-22.
 Costruite il circuito mostrato in Figura 7-22 e Figura 7-23, usando il LED giallo.
Accertatevi di osservare la polarità mostrata nelle figure!
LED
giallo
Bordo piatto e pin
catodo
piùand
corto
Flat spot
shorter cathode pin
Figura 7-22
Schema elettrico del
circuito LED RCTIME
Figura 7-23
del circuito LED RCTIME
Pin anodo più lungo
Longer anode pin
Prova del LED sensore di luce con il codice PBASIC
Il circuito LED sensore di luce può essere provato in una stanza fortemente illuminata o
all’esterno durante il giorno. In una stanza debolmente illuminata è probabile che i tempi
di misura superino 65535, nel qual caso RCTIME memorizzerà zero nella variabile
risultato. Per la maggior parte delle situazioni, il codice è lo stesso codice dell’attività
#1, ProvaFototransistor.bs2.
Se siete in una stanza con illuminazione intensa provate a far questo:
 Eseguite ProvaFototransistor.bs2 dalla Attività #1.
 Puntate il LED sulla sorgente di luce forte affacciando la vostra scheda ad essa.
 Ruotate gradualmente la scheda allontanandola dalla sorgente di luce intensa
nella stanza; i valori visualizzati dal terminale di Debug dovrebbero aumentare
appena la luce diventa più debole.
Se avete una lampada flash intensa, provate a far questo:
 Eliminate la maggior parte delle sorgenti di luce intensa come la luce solare che
invade le finestre.
 Accendete la lampada flash e puntatela sulla parte superiore (tetto) del LED ad
una distanza di circa 4 pollici (circa 10 cm). Se possibile, spegnete alcune delle
lampade fluorescenti così che gli alti livelli di luce ambiente diventino bassi.
 Osservate le misure che il terminale di Debug visualizza man mano che
aumentate gradualmente la distanza della lampada flash dal tetto del LED . Ciò
vi consentirà di determinare la distanza della lampada flash dal LED.
Se siete in una stanza che ha solo luci fluorescenti e nessuna sorgente di luce forte:
 Eliminate la maggior parte delle sorgenti di luce come la luce del sole che invade
le finestre. Se possibile, spegnete alcune delle luci fluorescenti in modo che i
livelli di luce siano bassi.
 Puntate il LED sul monitor del vostro computer in modo che quasi tocchi il
monitor, e guardate se le misure rendano possible distinguere i vari colori sul
display.
Prove all’esterno (outdoor):




Eseguite MemorizzaMisureDiLuceInEeprom.bs2 dalla Attività #2.
Scollegate il cavo di programmazione e portate all’esterno la vostra scheda.
Orientate la scheda in modo che il LED punti direttamente sul sole.
Premete e rilasciate il pulsante Reset della vostra scheda per riavviare il
programma di raccolta dati (datalogging).
 Ruotate gradualmente la vostra scheda togliendola dal sole per più di 2 ½ minuti.
 Portate di nuovo dentro la vostra scheda e ricollegatela al PC.
 Eseguite LeggiMisureDiLuceDaEeprom.bs2, ed esaminate le misure di luce.
Poiché avete ruotato gradualmente il LED togliendolo dal sole, le misure
successive dovrebbero essere maggiori.
Il vostro turno – Può il vostro BASIC Stamp dire Rosso da Verde?
In Figura 7-2, il verde è a metà dello spettro, e il rosso è a destra. Se scaricate la versione
PDF a colori di questo libro dal sito www.parallax.com, oppure se avete già l’immagine
dello spettro a colori, ponete il LED verde e poi il LED rosso contro lo schermo e
registrate misure di luce sullo spettro dei colori. Poi, confrontando le misure più basse
con ciascun LED, potete rilevare se il LED è posto contro il verde o il rosso dello
schermo.
 Iniziate con un LED verde nei circuiti rilevatori di luce di Figura 7-22 e Figura
7-23.
 Scaricate la versione PDF di “What’s a Microcontroller?” dal sito
www.parallax.com/go/WAM, se la vostra figura 7-2 è in bianco e nero.
 Visualizzate lo spettro dei colori mostrato in Figura 7-2 (page 218) sul vostro
monitor, e zoomate sulla immagine.
 Col programma ProvaFototransistor.bs2 che visualizza le misure nel terminale di
Debug, tenete la scheda in modo che la cupola del LED verde stia puntando
direttamente sullo spettro dei colori entro il monitor. Per ottenere i migliori
risultati, la cupola del LED dovrebbe essere proprio a contatto col monitor, e i
livelli di luce nella stanza dovrebbero essere molto bassi.
 Fate scivolare il LED verde lentamente lungo la barra dello spettro visualizzata
sul monitor, e notate quale colore fornisce la misura più bassa.
 Ripetete con il LED rosso. Il LED rosso ha riportato la sua misura più bassa
sopra il rosso e il LED verde ha riportato la sua misura più bassa sopra il verde?
La più bassa misura del LED rosso dovrebbe verificarsi sopra il colore rosso sul display,
e la più bassa misura per il LED verde dovrebbe verificarsi sopra il verde.
SOMMARIO
Questo capitolo ha introdotto i sensori di luce e ha descritto il loro uso in una varietà di
prodotti. Sensori di luce differenti rilevano differenti specie di luce, e i loro foglispecifiche ci comunicano le loro sensibilità in termini di lunghezza d’onda della luce.
Questo capitolo ha evidenziato il fototransistor, un dispositivo che controlla la corrente
attraverso i suoi terminali collettore ed emettitore tramite la quantità di luce che investe il
suo terminale base. Poiché la luce può controllare la quantità di corrente che un
fototransistor conduce, la tecnica per misurare la posizione della manopola di un
potenziometro nell’attività #1 (circuito RC) lavora anche per misurare la luce che brilla
su di un fototransistor. Il tempo che occorre ad un condensatore per perdere la sua carica
attraverso il fototransistor produce una misura RCTIME che ci dà un numero
corrispondente alla brillantezza della luce che incide sul fototransistor.
È stato anche introdotto il Datalogging (raccolta dati), memorizzando misure di luce nella
porzione non utilizzata della memoria di programma EEPROM del modulo BASIC
Stamp. Per memorizzare i valori nella – e reperire i valori dalla – EEPROM del modulo
BASIC Stamp, sono stati usati i comandi WRITE e READ. Il volume di numeri interessato
nel datalogging può essere difficile da analizzare, ma riportando i dati in grafico diventa
molto più facile vedere configurazioni, tendenze ed eventi. I dati raccolti possono essere
trasferiti a fogli di calcolo convenzionali e tracciati in grafico, e certe utilità grafiche
possono anche sostituire il terminale di Debug, e diagrammare i valori inviati dal BASIC
Stamp invece di visualizzarli come testo. È stata anche sviluppata una applicazione
esempio di misuratore di luce, che dimostra come si possano usare misure di luce per
controllare un altro processo, in questo caso, la velocità delle configurazioni circolari
visualizzate da un LED a 7 segmenti. Questa applicazione ha usato anche le subroutine
per eseguire tre lavori diversi nell’applicazione del misuratore di luce.
Il BASIC Stamp può essere programmato anche per convertire una misura di tempo di
decadimento RC in un valore binario con frasi IF…THEN. In aggiunta, il programma può
prendere un intervallo di misure di decadimento RC ed applicarvi un’isteresi con una
soglia “accendi le luci ” nell’intervallo buio delle misure e una soglia “spegni le luci”
nell’intervallo più luminoso. Ciò può aiutare a prevenire le oscillazioni acceso/spento
che potrebbero altrimenti verificarsi quando il sensore riporta buio e il dispositivo
accende una luce nella zona. Senza isteresi, il dispositivo potrebbe sentire la luce,
spegnerla di nuovo, e ripetere questo ciclo all’infinito.
Un approccio hardware per sentire gli stati acceso/spento della luce è quello di applicare
energia al fototransistor in serie ad una resistenza. In accordo con la legge di Ohm, la
quantità di corrente che il fototransistor conduce influenza il voltaggio ai capi della
resistenza. Questo voltaggio variabile può essere applicato a un pin I/O, e ne risulterà un
1 binario se il voltaggio è sopra la soglia di 1,4 V del pin I/O, o uno 0 binario se è al di
sotto della soglia.
Il LED (light emitting diode – diodo emettitore di luce) che emette luce quando la
corrente lo attraversa, può anche comportarsi come un sottile pannello solare se la luce lo
colpisce, generando un piccolo voltaggio che a sua volta può far passare corrente elettrica
in circuiti. Le correnti che il LED genera sono abbastanza piccole perché una
combinazione della capacità di giunzione propria del LED e della capacità inerente alle
mollette (ganci metallici) interne alla breadboard fornisce una capacità sufficiente per un
circuito a decadimento RC con nessuna capacità esterna. Mentre il fototransistor nel kit
“What’s a Microcontroller” funziona meglio in interni, il LED è ottimo per misure di
intensa luce esterna.
Domande
1. Potete fare alcuni esempi di applicazioni di illuminazione automatica che
dipendono da sensori di luce ambiente?.
2. Potete fare alcuni esempi di prodotti che reagiscono ai cambiamenti di
luminosità nella luce ambiente?
3. In quale intervallo di lunghezze d’onda deve cadere lo spettro della luce visibile?
4. Quali sono i nomi dei terminali di un fototransistor, e quale di questi controlla la
quantità di corrente che il dispositivo consente che lo attraversi?
5. Che cosa significa l’acronimo EEPROM ?
6. Quanti byte può memorizzare la EEPROM del modulo BASIC Stamp? Quanti
bit può memorizzare?
7. Quale comando usate per memorizzare un valore in EEPROM? Quale comando
usate per reperire un valore dalla EEPROM? Quale richiede una variabile?
8. Che cosa è una etichetta?
9. Che cosa è una subroutine?
10. Quale comando si usa per richiamare una subroutine? Quale comando si usa per
terminare una subroutine?
Esercizi
1. Disegnate lo schema elettrico del circuito a tempo RC di un fototransistor
connesso a P5.
2. Modificate ProvaFototransistor.bs2 in modo che lavori su un circuito connesso a
P5 invece che a P2.
3. Spiegate come modifichereste MisuratoreDiLuce.bs2 perché la configurazione
circolare visualizzata dal display LED a 7 segmenti vada nella direzione opposta.
Progetti
1. Fate un piccolo prototipo di un sistema che chiuda automaticamente le tapparelle
(gli scuri) quando la luce è troppo intensa e le apra di nuovo quando la luce
diventa meno intensa. Usate come attuatore meccanico il servo . Suggerimento:
per il codice, potete aggiungere due comandi di controllo del servo al
programma FototransistorAnalogicoABinario.bs2, e cambiate il comando PAUSE
100 in PAUSE 1.
Assicuratevi di seguire le istruzioni nel testo per la
calibrazione delle condizioni di luce nella zona prima di provarlo.
2. Per avere crediti extra, evidenziate la vostra soluzione al Progetto 1
incorporandovi le modifiche dell’isteresi discusse nella attività #5.
Soluzioni
D1. Luci abbaglianti di un’automobile, lampioni stradali, e luci esterne di sicurezza
che si accendono automaticamente quando fa buio.
D2. Visualizzatori di computer portatili e fotocamere con esposizione automatica.
D3. Da 380 nm a 750 nm secondo la Figura 7-2 a pagina 212.
D4. Collettore, base, ed emettitore. La base controlla quanta corrente passa entro il
collettore ed esce fuori dall’emettitore.
D5. Electrically Erasable Programmable Read-Only Memory (Memoria a sola
lettura programmabile cancellabile elettricamente).
D6. 2048 byte. 2048 x 8 = 16,384 bit.
D7. Per memorizzare un valore – WRITE ; Per reperire un valore – READ; Il comando
READ richiede una variable.
D8. Una etichetta è un nome che può essere usato come segnaposto in un programma
PBASIC.
D9. Una subroutine è un piccolo segmento di codice che fa un determinato lavoro.
D10. Per richiamare: GOSUB; per terminare: RETURN
E1. Schema basato sulla Figura 7-4 a pagina 214, con P2 cambiato in P5.
E2. I cambiamenti richiesti sono molto simili a quelli spiegati a pagina 215.
DO
HIGH 5
PAUSE 100
RCTIME 5, 1, tempo
LOOP
", DEC5 tempo
E3. Per andare nella direzione opposta, la configurazione deve essere visualizzata in
ordine inverso. Ciò può essere fatto cambiando circolarmente le configurazioni
interne alla frase LOOKUP, o rovesciando l’ordine in cui vengono ricercate. Ecco
due soluzioni fatte con subroutine Aggiorna_Display alternative.
Soluzione 1
Soluzione 2
Aggiorna_Display:
'
BAFG.CDE
%10000000,
%00000100,
%00000010,
%00000001,
%00100000 ],
OUTH
indice = indice + 1
RETURN
Indice = 5 '<<Aggiungere dopo variabile
' Indice
Aggiorna_Display:
'
BAFG.CDE
%10000000,
%00000100,
%00000010,
%00000001,
%00100000 ], OUTH
IF (indice = 0) THEN
indice = 5
ELSE
indice = indice - 1
ENDIF
RETURN
P1. Fototransistor dalla Figura 7-4 a pagina 214, schema servo per la vostra board
dalla Attività #1, capitolo 4.
' Che cos’è un Microcontrollore - Cap07Pr01_Controllo_Scuri.bs2
' Controllo della posizione del servo con la luce.
' {$STAMP BS2}
' {$PBASIC 2.5}
valMax
valMin
tempo
CON
CON
VAR
4000
100
Word
PAUSE 1000
DO
HIGH 2
PAUSE 1
RCTIME 2, 1, tempo
' PAUSE 100 -> PAUSE 1
", DEC5 tempo
DEBUG CR, "Apri gli scuri
"
PULSOUT 14, 500
ELSE
DEBUG CR, "Chiudi gli scuri "
PULSOUT 14, 1000
ENDIF
' Modificata
' Aggiunta
' Modificata
' Aggiunta
LOOP
P2. Credito extra: aggiunta della funzionalità di Isteresi:
' Che cos’è un Microcontrollore - Cap07Pr02_Controllo_Extra_Scuri.bs2
' Controlla posizione servo con la luce inclusa isteresi.
' {$STAMP BS2}
' {$PBASIC 2.5}
valMax
valMin
CON
CON
4000
100
tempo
VAR
Word
PAUSE 1000
DO
HIGH 2
PAUSE 1
RCTIME 2, 1, tempo
' PAUSE 100 -> PAUSE 1
", DEC5 tempo
IF tempo > (valMax - valMin) / 4 * 3 THEN
DEBUG CR, "Apri gli scuri
"
PULSOUT 14, 500
ELSEIF tempo < (valMax - valMin ) / 4 THEN
DEBUG CR, "Chiudi gli scuri "
PULSOUT 14, 1000
ENDIF
LOOP
' Modificata
' Aggiunta
' Modificata
' Aggiunta
Frequenza e Suono · Pagina 261
Capitolo 8: Frequenza e Suono
LA VOSTRA GIORNATA E I BIP ELETTRONICI
Ecco alcuni esempi di bip che potreste ascoltare in una giornata normale: i bip del forno
a microonde quando ha finito di cuocere il vostro cibo. Il telefono cellulare suona con
bip di tono diverso che somigliano a canzoni per richiamare la vostra attenzione quando
sta arrivando una chiamata. La macchina ATM (il Bancomat) emette bip per ricordarvi
di non dimenticare la vostra scheda. Il registratore di cassa di un negozio emette bip per
far sapere al commesso che il codice a barre dell’elemento alimentare passato sotto lo
scanner è stato letto. Molte calcolatrici emettono bip quando si premono i tasti sbagliati.
Potete cominciare la vostra giornata con il bip di una sveglia.
MICROCONTROLLORI, ALTOPARLANTI, E SEGNALI ON/OFF
Quasi tutti i bip elettronici che sentite nella vostra routine giornaliera sono prodotti da
microcontrollori connessi ad altoparlanti. Il microcontrollore crea questi bip inviando
segnali alto/basso rapidi a vari tipi di altoparlanti. La velocità di questi segnali alto/basso
è chiamata frequenza, e determina il tono o altezza del bip. Ogni volta che un alto/basso
si ripete, avviene ciò che si chiama ciclo. Spesso, il numero di cicli per secondo viene
detto hertz, e si abbrevia con Hz. Ad esempio, una delle più comuni frequenze di bip che
aiutano le macchine ad attirare la vostra attenzione è 2 kHz. Ciò significa che i segnali
alto/basso si ripetono 2000 volte per secondo.
Introduzione dell’altoparlante piezoelettrico
In questa attività, sperimenterete l’invio di una varietà di segnali ad un comune, piccolo e
poco costoso altoparlante detto altoparlante piezoelettrico. Un altoparlante piezoelettrico
è detto altoparlante piezo o cicalino piezo, e piezo si pronuncia “pi-e-zO.” Il suo simbolo
schematico e il disegno di parte sono mostrati in Figura 8-1.
Figura 8-1
Disegno di parte e simbolo
schematico dell’altoparlante
piezoelettrico
ATTIVITÀ #1: COSTRUZIONE E PROVA DELL’ALTOPARLANTE
In questa attività, costruirete e proverete il circuito dell’altoparlante piezoelettrico.
Parti del circuito dell’altoparlante
(1) Altoparlante piezoelettrico
Costruzione del circuito dell’altoparlante piezoelettrico
Il terminale negativo dell’altoparlante piezoelettrico dev’essere connesso a Vss, e il
termnale positivo dev’essere connesso ad un pin I/O. Il BASIC Stamp sarà stato poi
programmato per inviare segnali alto/basso al terminale positivo dell’altoparlante
piezoelettrico.
 Se l’altoparlante piezo ha una etichetta, rimuovetela (non occorre lavarla).
Vdd
Vin
Vss
X3
P9
Vss
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
+
Figura 8-2
Schema circuitale e
del circuito
dell’altoparlante
piezoelettrico
Come lavora il circutio dell’altoparlante piezoelettrico
Quando una corda di chitarra vibra, produce cambiamenti di pressione nell’aria. Questi
cambi di pressione dell’aria sono rilevate come toni. Più veloci i cambi di pressione, più
alto il tono, e più lenti i cambi di pressione, più basso il tono. L’elemento entro
l’involucro di plastica dell’altoparlante piezo è detto elemento piezoelettrico. Quando si
applicano segnali alto/basso al terminale positivo dell’altoparlante, l’elemento piezoelettrico vibra, e produce i cambiamenti di pressione dell’aria proprio come fa la corda di
una chitarra. Come con la corda della chitarra, il vostro orecchio rileva i cambi di
pressione dell’aria (onde sonore) prodotti dall’altoparlante piezoelettrico, e questo suona
tipicamente come fa un bip o un tono.
Programmazione del Controllo dell’altoparlante
Il comando FREQOUT è un modo conveniente per inviare segnali alto/basso ad un
altoparlante e farlo così suonare. Il manuale del BASIC Stamp vi mostra la sintassi del
comando:
FREQOUT Pin, Duration, Freq1 {, Freq2}
Come per la maggior parte dei altri comandi usati in questo libro, Pin è un valore che vi
fa scegliere quale pin I/O del BASIC Stamp usare. L’argomento Duration dice al
comando FREQOUT quanto a lungo deve suonare il tono, in millisecondi. L’argomento
Freq1 è usato per impostare la frequenza del tono, in hertz. C’è un argomento opzionale
Freq2 che può essere usato per suonare contemporaneamente due note diverse.
Ecco come inviare un tono al pin I/O P9 che duri per 1,5 secondi ed abbia una frequenza
di 2 kHz:
FREQOUT 9, 1500, 2000
Programma esempio: ProvaPiezoConFreqout.bs2
Questo programma esempio invia il tono di 2 kHz all’altoparlante, sul pin I/O P9, per 1,5
secondi. Potete usare il terminale di Debug per vedere quando l’altoparlante deve
fischiare e quando deve fermarsi.
 Digitate ed eseguite ProvaPiezoConFreqout.bs2.
 Verificate che l’altoparlante produce un tono udibile chiaramente durante il
tempo in cui il terminale di Debug visualizza il messaggio “Invio tono …”
' Che cos’è un Microcontrollore - ProvaPiezoConFreqout.bs2
' Invia un tono all’altoparlante piezo usando il comando FREQOUT.
'{$STAMP BS2}
'{$PBASIC 2.5}
PAUSE 1000
DEBUG "Invio tono...", CR
FREQOUT 9, 1500, 2000
DEBUG "Tono inviato."
Il vostro turno – Regolazione di frequenza e durata




Memorizzate ProvaPiezoConFreqout.bs2 sotto altro nome.
Provate alcuni valori diversi degli argomenti Duration e Freq1.
Dopo ciascuna modifica, eseguite il programma e prendete nota dell’effetto.
Quando l’argomento Freq1 diventa più grande, l’altezza del tono va su o giù?
Provate valori di 1500, 2000, 2500 e 3000 per rispondere a questa domanda.
ATTIVITÀ #2: SUONI DI AZIONE
Molti giocattoli contengono microcontrollori utilizzati per produrre “suoni di azione.” I
suoni di azione tendono a coinvolgere chi ascolta cambiando rapidamente la frequenza
del suono eseguito dall’altoparlante. Potete ottenere anche alcuni effetti interessanti
suonando contemporaneamente due toni diversi, tramite l’argomento opzionale Freq2 del
comando FREQOUT. Questa attività presenta entrambe queste tecniche.
Programmazione dei suoni di azione
I suoni di azione e di applicazione hanno tre diverse componenti:
1. Pausa
2. Durata
3. Frequenza
La pausa è il tempo tra i toni, e per crearla potete usare il comando PAUSE. La durata è
la quantità di tempo che un tono dura, e potete impostarla con l’argomento Duration del
comando FREQOUT. La frequenza determina l’altezza del tono. Più alta è la frequenza,
maggiore l’altezza (toni alti), più bassa è la frequenza, minore l’altezza (toni bassi).
Questa è determinata, naturalmente, dall’argomento Freq1 del comando FREQOUT.
Progrmma esempio: ToniAzione.bs2
ToniAzione.bs2 dimostra alcune combinazioni diverse di pausa, durata, e frequenza. La
prima sequenza di toni suona in modo simile ad una sveglia elettronica. La seconda
suona in modo simile a qualcosa che potrebbe esser detto da un robot di un comune film
di fantascienza. La terza è più simile al tipo di effetti sonori che potreste ascoltare in un
vecchio video gioco.
 Digitate ed eseguite ToniAzione.bs2.
' Che cos’è un Microcontrollore - ToniAzione.bs2
' Dimostra come si possano usare diverse combinazioni di pausa, durata,
' frequenza per produrre effetti sonori.
'{$STAMP BS2}
'{$PBASIC 2.5}
durata
frequenza
VAR
VAR
Word
Word
PAUSE 1000
DEBUG "Allarme...", CR
PAUSE 100
FREQOUT 9, 500, 1500
PAUSE 500
FREQOUT 9, 500, 1500
PAUSE 500
FREQOUT 9, 500, 1500
PAUSE 500
FREQOUT 9, 500, 1500
PAUSE 500
DEBUG "Il robot risponde...", CR
PAUSE 100
FREQOUT 9, 100, 2800
FREQOUT 9, 200, 2400
FREQOUT 9, 140, 4200
FREQOUT 9, 30, 2000
PAUSE 500
DEBUG "Iperspazio...", CR
PAUSE 100
FOR durata = 15 TO 1 STEP 1
FOR frequenza = 2000 TO 2500 STEP 20
FREQOUT 9, durata, frequenza
NEXT
NEXT
DEBUG "Fatto", CR
END
Come lavora ToniAzione.bs2
La routine “Allarme” suona come una sveglia. Questa routine suona toni ad una
frequenza fissa di 1,5 kHz per una durata di 0,5 s con ritardi fissi tra i toni, di 0,5 s. La
routine “Il robot risponde” usa varie frequenze per brevi durate.
La routine “Iperspazio” non usa ritardi, ma varia sia la durata che la frequenza. Usando
cicli FOR...NEXT per cambiare rapidamente le variabili frequenza e durata, potete
ottenere effetti sonori interessanti. Quando si esegue un ciclo FOR...NEXT entro un altro,
questa struttura è detta ciclo annidato. Ecco come lavora il ciclo annidato FOR...NEXT
riportato qui sotto. La variabile durata inizia dal valore 15, poi il ciclo FOR
frequenza... va avanti e invia le frequenze 2000, poi 2020, poi 2040, e così via, fino a
2500, all’altoparlante piezo. Quando termina il ciclo FOR frequenza..., il ciclo FOR
durata... ha ripetuto soltanto uno dei suoi 15 passi. A questo punto sottrae 1 dal valore
di durata e ripete daccapo l’intero ciclo FOR frequenza... .
FOR durata = 15 TO 1
NEXT
NEXT
Programma esempio: CicliAnnidati.bs2
Per comprendere meglio come lavorino i cicli annidati FOR...NEXT, il programma
CicliAnnidati.bs2 usa il comando DEBUG per mostrare il valore di una versione molto
meno complicata di cicli annidati usata nel programma ToniAzione.bs2.
 Digitate ed eseguite CicliAnnidati.bs2.
 Esaminate l’uscita del terminale di Debug e verificate come cambiano le
variabili durata e frequenza ad ogni esecuzione del ciclo.
' Che cos’è un Microcontrollore - CicliAnnidati.bs2
' Dimostra come lavorino i cicli annidati in ToniAzione.bs2.
'{$STAMP BS2}
'{$PBASIC 2.5}
durata
frequenza
VAR
VAR
Word
Word
PAUSE 1000
DEBUG "Durata
"--------
Frequenza", CR,
---------", CR
DEBUG "
" , DEC5 durata,
"
", DEC5 frequenza, CR
NEXT
DEBUG CR
NEXT
END
Il vostro turno – Maggiori effetti sonori
Esiste un numero realmente infinito di modi per modificare ToniAzione.bs2 e ottenere
diverse combinazioni di suoni. Ecco qui una delle modifiche alla routine “Iperspazio”:
DEBUG "Salto nell’iperspazio...", CR
NEXT
NEXT
NEXT
NEXT
 Memorizzate il programma esempio con nome ToniAzioneVostroTurno.bs2.
 Divertitevi con questa e altre modifiche di vostra creazione.
Due frequenze contemporanee
Potete suonare con due frequenze contemporanee. Ricordate la sintassi del comando
FREQOUT dalla attività #1:
FREQOUT Pin, Duration, Freq1 {, Freq2}
Potete utilizzare l’argomento opzionale Freq2 per suonare due frequenze con un singolo
comando FREQOUT. Per esempio, potete suonare a 2 kHz e a 3 kHz col comando:
FREQOUT 9, 1000, 2000, 3000
Ciascun tono delle tastiere telefoniche è anche un esempio di due frequenze combinate
assieme. Nelle telecomunicazioni, questo evento è chiamato DTMF (Dual Tone Multi
Frequency, MultiFrequenza BiTonale). Esiste anche un comando PBASIC detto DTMFOUT
progettato proprio per l’invio di toni telefonici. Cercate questo comando nel Manuale BASIC
Stamp o nell’Aiuto per trovarne degli esempi.
Programma esempio: CoppiaDiToni.bs2
Questo programma esempio mostra la differenza di tono ottenuta se unìte assieme le
frequenze di 2 e 3 kHz. Mostra anche un interessante fenomeno che si verifica quando
sommate due onde sonore molto vicine tra loro in frequenza. Quando suonate
contemporaneamente 2000 Hz e 2001 Hz, il tono fluttua (si dissolve) in alto e basso una
volta ogni secondo (alla frequenza di 1 Hz). Se suonate 2000 Hz con 2002 Hz, si
dissolverà in alto e basso due volte al secondo (2 Hz), e così via.
Battimento è il fenomeno che si ha quando due toni molto vicini in frequenza vengono
eseguiti contemporaneamente, causando così la dissolvenza in alto e basso del tono che
udite. La frequenza di quella dissolvenza in su e giù è la differenza tra le due frequenze. Se
la differenza è 1 Hz, il tono si dissolve in su e giù ad 1 Hz. Se la differenza è 2 Hz, il tono si
dissolve in su e giù a 2 Hz.
Le variazioni nella pressione dell’aria fatte dall’altoparlante piezoelettrico sono dette onde
sonore. Quando il tono è amplificato al suo massimo, le variazioni di pressione dell’aria
causate dalle due frequenze si aggiungono l’una all’altra (si parla di sovrapposizione).
Quando il tono è al suo minimo, le variazioni nella pressione dell’aria si cancellano
reciprocamente (si chiama interferenza).
 Digitate ed eseguite CoppiaDiToni.bs2.
 Tenete d’occhio il terminale di Debug mentre vengono prodotti i toni, e notate i
diversi effetti prodotti dal miscelare toni differenti.
' Che cos’è un Microcontrollore - CoppiaDiToni.bs2
' Dimostra alcune delle cose che accadono quando miscelate due toni.
'{$STAMP BS2}
'{$PBASIC 2.5}
PAUSE 1000
DEBUG "Frequenza = 2000", CR
FREQOUT 9, 4000, 2000
DEBUG "Frequenza = 3000", CR
FREQOUT 9, 4000, 3000
DEBUG "Frequenza = 2000 + 3000", CR
FREQOUT 9, 4000, 2000, 3000
FREQOUT 9, 4000, 2000, 2001
FREQOUT 9, 4000, 2000, 2002
FREQOUT 9, 4000, 2000, 2003
FREQOUT 9, 4000, 2000, 2005
FREQOUT 9, 4000, 2000, 2010
DEBUG "Fatto", CR
END
Il vostro turno – Condensazione del codice
CoppiaDiToni.bs2 è stato scritto per mostrare alcune cose interessanti che possono
succedere quando suonate contemporaneamente due frequenze diverse con l’argomento
opzionale Freq2 del comando FREQOUT. Però, questo programma è molto inefficiente.
 Modificate CoppiaDiToni.bs2 in modo da far variare gli argomenti Freq2
nell’intervallo da 2001 a 2005, tramite una variabile word e un ciclo.
ATTIVITÀ #3: NOTE MUSICALI E SEMPLICI CANZONI
La Figura 8-3 mostra i 25 tasti più a destra della tastiera di un pianoforte. Mostra anche
le frequenze alle quali ciascuna corda all’interno del piano vibra quando si preme il tasto
relativo a quella corda.
Figura 8-3: Tasti più a destra di un Piano e loro frequenze
I tasti e le note loro corrispondenti sono etichettati da C6 a C8. Questi tasti sono
suddivisi in gruppi di 12, composti da 7 tasti bianchi e 5 tasti neri. La sequenza delle note
si ripete ogni 12 tasti. Le note che hanno la stessa lettera sono correlate nella frequenza,
che raddoppia ogni ottava più alta. Ad esempio, C7 è due volte la frequenza di C6, e C8
è il doppio della frequenza di C7. Analogamente, se andate giù di un’ottava, la frequenza
dimezzerà il suo valore; per esempio, A6 è metà della frequenza di A7.
Se avete mai ascoltato un cantante che pratichi le sue note cantando il Solfeggio, “Do Re
Mi Fa Sol La Si Do,” il cantante sta provando ad accordare le note che ottenete premendo
i tasti bianchi sulla tastiera di un pianoforte. Quei tasti bianchi sono chiamati tasti
naturali, e il nome “ottava” si riferisce al raddoppio della frequenza ogni otto tasti
naturali . Un tasto nero su un piano può essere chiamato sia diesis (sharp) che bemolle
(flat). Per esempio, il tasto nero tra i tasti C e D è chiamato sia C-diesis (C-sharp) (C#)
che D-bemolle (D-flat) (Db). Il fatto che un tasto sia chiamato diesis o bemolle dipende
dal particolare brano suonato, e le regole di questi è preferibile siano lasciate alle classi
musicali.
Ricerca della “scala musicale” su Internet: Usando le parole "scala musicale" troverete
moltissime informazioni affascinanti sulla storia, la fisica e la psicologia dell’argomento. La
scala di 12 note per ottava è la scala principale della musica occidentale. Altre culture
usano scale che contengono da 2 a 35 note per ottava.
Metodo di accordo: La tastiera in Figura 8-3 usa un metodo di accordo chiamato
temperato in modo uguale. Le frequenze sono determinate usando una nota di riferimento,
(n/12)
poi moltiplicandola per 2
per valori di n = 1, 2, 3, ecc. Per esempio, potete prendere la
(1/12)
frequenza per A6, e moltiplicarla per 2
per ottenere la frequenza di A6#. Multiplicarla
(2/12)
per 2
per ottenere la frequenza di B6, e così via. Ecco un esempio di calcolo della
frequenza di B6 usando A6 come frequenza di riferimento:
La frequenza di A6 è 1760
2
(2/12)
= 1,224
1760 X 1,224 = 1975,5
1975,5 è la frequenza di B6
Programmazione delle note musicali
Il comando FREQOUT è utile anche per le note musicali. Programmare il BASIC Stamp
per suonare musica con un altoparlante piezo comporta una varietà di regole usate nel
suonare musica tramite qualsiasi altro strumento musicale. Queste regole si applicano
agli stessi elementi usati per produrre effetti sonori: frequenza, durata, e pausa. Il
programma esempio che segue suona alcune delle frequenza di note musicali
sull’altoparlante piezo, ciascuna con la durata di mezzo secondo.
Programma esempio: DoReMiFaSolLaSiDo.bs2
 Digitate ed eseguite DoReMiFaSolLaSiDo.bs2
' Che cos’è un Microcontrollore - DoReMiFaSolLaSiDo.bs2
' Invia una ottava di note, di mezzo secondo ciascuna, tramite
' un altoparlante piezoelettrico.
'{$STAMP BS2}
'{$PBASIC 2.5}
PAUSE 1000
'Solfeggio
Tono
Nota
DEBUG "Do...", CR:
FREQOUT 9,500,1047
' C6
DEBUG "Re...", CR:
FREQOUT 9,500,1175
' D6
DEBUG "Mi...", CR:
FREQOUT 9,500,1319
' E6
DEBUG "Fa...", CR:
FREQOUT 9,500,1396
' F6
DEBUG "Sol..", CR:
FREQOUT 9,500,1568
' G6
DEBUG "La...", CR:
FREQOUT 9,500,1760
' A6
DEBUG "Si...", CR:
FREQOUT 9,500,1976
' B6
DEBUG "Do...", CR:
FREQOUT 9,500,2093
' C7
END
Il vostro turno – Note Diesis/Bemolle
 Usate le frequenze mostrate in Figura 8-3 per aggiungere le cinque note
diesis/bemolle (semitoni) a DoReMiFaSolLaSiDo.bs2
 Modificate il vostro programma in modo che suoni la successiva ottava
superiore. Suggerimento: risparmiate alcune digitazioni usando l’operazione * 2
dopo ciascun argomento Freq1. Per esempio, FREQOUT 9, 500, 1175 * 2
moltiplicherà D6 per 2 per darvi D7, la nota D nella 7ma ottava.
Memorizzazione e reperimento di sequenze di note musicali
Un buon modo di memorizzare note musicali è di scriverle nella EEPROM del modulo
BASIC Stamp . Per far questo, però, dovrete usare molti comandi WRITE; un modo
migliore è usare la direttiva DATA. Ecco la sintassi della direttiva DATA:
{Symbol} DATA {Word} DataItem {, {Word} DataItem, … }
Ecco un esempio di come utilizzare la direttiva DATA per memorizzare i caratteri che
corrispondono alle note musicali.
Note DATA "C","C","G","G","A","A","G"
Per accedere a questi caratteri potete usare il comando READ. La lettera “C” è posta
all’indirizzo Note + 0, e una seconda lettera “C” è posta all’indirizzo Note + 1. Poi, c’è
una lettera “G” a Note + 2, e così via. Per esempio, se volete caricare l’ultima lettera
“G” in una variabile byte detta LetteraNota, usate il comando:
READ Note + 6, LetteraNota
Usando la direttiva DATA, potete memorizzare anche elenchi di valori numerici di
frequenza e durata, che il BASIC Stamp usa per le note musicali che occorra
memorizzare in variabili word, perché esse sono di solito maggiori di 255. Ecco come
far questo con una direttiva DATA.
Frequenze
DATA Word 2093, Word 2093, Word 3136, Word 3136,
Word 3520, Word 3520, Word 3136
Dato che ciascuno di questi valori occupa due byte, accederli con il comando READ è
diverso dall’accedere caratteri. Il primo valore 2093 è all’indirizzo Frequenze + 0, ma il
secondo 2093 è posto a Frequenze + 2. Il primo 3136 è posto a Frequenze + 4, e il
secondo 3136 è posto a Frequenze + 6.
I valori nella direttiva DATA Frequenze corrispondono alle note musicali contenute
nella direttiva DATA Note.
Ecco un ciclo FOR...NEXT che pone i valori di Note DATA in una variabile chiamata
LetteraNota, poi pone i valori di Frequenze DATA in una variabile chiamata
FreqNota.
FOR indice = 0 to 6
READ Note + indice, LetteraNota
READ Frequenze + (indice * 2), Word FreqNota
DEBUG LetteraNota, " ", DEC FreqNota, CR
NEXT
Che cosa fa (indice * 2)?
Ciascun valore memorizzato nella direttiva Frequenze DATA occupa una word (due byte),
mentre ciascun carattere nella direttiva Note DATA occupa soltanto un byte. Il valore di
indice aumenta di uno ad ogni ripetizine del ciclo FOR...NEXT. Ciò va bene per accedere
al carattere nota usando il comando READ Note + indice, LetteraNota. Il problema
è che per ciascun byte in Note, la variabile indice deve puntare due volte più in basso
nell’elenco di Frequenze. Il comando READ Frequenze + (indice * 2), Word
FreqNota, si fa carico di questo.
Il programma esempio che segue memorizza note e durate usando DATA, e usa il comando
FREQOUT per suonare ciascuna frequenza di nota, per una determinata durata. Il risultato
sono le prime note della canzone per bambini “Twinkle Twinkle Little Star.” (“Brilla,
brilla, stellina”)
La canzone “Alphabet Song” usata dai bambini per memorizzare i loro “ABC” usa le
stesse note di “Twinkle Twinkle Little Star.”
Programma esempio: TwinkleTwinkle.bs2
Questo programma esempio dimostra come usare la direttiva DATA per memorizzare
elenchi e come usare il comando READ per accedere ai valori negli elenchi.
 Digitate ed eseguite TwinkleTwinkle.bs2
 Verificate che le note suonino la canzone “Twinkle Twinkle Little Star.”
 Usate il terminale di Debug per verificare che lavori come ci si aspetta
' Che cos’è un Microcontrollore - TwinkleTwinkle.bs2
' Sona le prime sette note da Twinkle Twinkle Little Star.
'{$STAMP BS2}
'{$PBASIC 2.5}
Note
DATA
"C","C","G","G","A","A","G"
Frequenze
DATA
Word 2093, Word 2093, Word 3136, Word 3136,
Word 3520, Word 3520, Word 3136
Durate
DATA
Word 500, Word 500, Word 1000
indice
LetteraNota
FreqNota
DurataNota
VAR
VAR
VAR
VAR
Nib
Byte
Word
Word
PAUSE 1000
DEBUG
"Nota
"----
Durata
--------
Frequenza", CR,
---------", CR
FOR indice = 0 TO 6
DEBUG "
", LetteraNota
READ Durate + (indice * 2), Word DurataNota
DEBUG "
", DEC4 DurataNota
READ Frequenze + (indice * 2), Word FreqNota
DEBUG "
", DEC4 FreqNota, CR
FREQOUT 9, DurataNota, FreqNota
NEXT
END
Il vostro turno – Aggiunta e riproduzione di più note
Questo programma ha riprodotto le prime sette note da Twinkle Twinkle Little Star. Le
parole erano “Twin-kle twin-kle lit-tle star.” La successiva frase della canzone dice
“How I won-der what you are” e le sue note sono F, F, E, E, D, D, C. Come nella prima
frase, l’ultima nota è tenuta due volte più a lungo delle altre note. Per aggiungere questa
frase alla canzone in TwinkleTwinkle.bs2, occorrerà espandere appropriatamente
ciascuna direttiva DATA. Non dimenticate di cambiare il ciclo FOR...NEXT in modo che
vada da 0 a 13 invece che da 0 a 6.
 Modificate TwinkleTwinkle.bs2 in modo che riproduca le prime due frasi della
canzone invece della sola prima frase.
ATTIVITÀ #4: MUSICA CON IL MICROCONTROLLORE
Le durate delle note non sono registrate sugli spartiti musicali in termini di millisecondi.
Esse sono. invece, descritte come nota intera, metà nota, un quarto, un ottavo, un
sedicesimo, e un trentaduesimo di nota . Come suggerisce il nome, metà nota dura la
metà di una nota intera. Un quarto di nota dura un quarto della durata di una nota intera,
e così via. Quanto dura una nota intera? Dipende dal brano musicale che viene eseguito.
Un brano potrebbe essere riprodotto per un tempo che fa durare una nota intera per
quattro secondi, un altro brano potrebbe avere una nota intera che dura due secondi, e un
altro ancora potrebbe avere qualche altra durata.
Riposi (o Pause) sono i tempi tra le note quando non sono eseguiti suoni. Le durate delle
pause sono misurate anch’esse come intera, metà, un quarto, un ottavo, un sedicesimo e
un trentaduesimo.
Ancora sulla musica con il microcontrollore: Dopo aver completato questa attività,
sarete pronti ad imparare il modo di scrivere codice musicale in PBASIC direttamente dagli
spartiti. Consultate il testo di aiuto Playing Sheet Music with the Piezospeaker e il suo
sillabario video di accompagnamento all’indirizzo web www.parallax.com/go/WAM.
Un sistema migliore per memorizzare e reperire musica
Potete scrivere programmi che memorizzano il doppio della musica nel vostro BASIC
Stamp usando byte invece di word nelle vostre direttive DATA. Potete anche modificare il
programma per rendere più facile la lettura delle note musicali usando alcune delle
convenzioni musicali più comuni per le note e le loro durate. Questa attività comincia a
introdurre come memorizzare informazioni musicali in un modo che fa riferimento ai
concetti di note, durate, e pause. E’ introdotto anche il tempo, che sarà riveduto
nell’attività successiva.
Ecco una delle direttive DATA che memorizza note musicali e durate per il programma
esempio successivo. Quando viene riprodotta, dovrebbe somigliare alla canzone “Frà
Martino campanaro (Frere Jacques).” Nella direttiva Note DATA sono memorizzati
soltanto i caratteri della nota poiché per far corrispondere le lettere alle frequenze
corrispondenti saranno usati i comandi LOOKUP e LOOKDOWN.
Note
DATA
Durate
DATA
NotaIntera
CON
"C","D","E","C","C","D","E","C","E","F",
"G","E","F","G","Q"
4,
2,
4,
4,
4,
4,
4,
2
4,
4,
4,
4,
4,
4,
2000
Il primo numero nella direttiva Durate DATA dice al programma quanto debba durare la
prima nota della direttiva Note Data. La seconda durata è per la seconda nota, e così
via. Le durate non sono più espresse in termini di millisecondi. Invece, esse sono numeri
molto più piccoli, memorizzabili in byte, in modo che non ci sia alcun prefisso Word nella
direttiva DATA. A paragone del memorizzare i valori in termini di millisecondi, questi
numeri sono collegati più da vicino allo spartito musicale.
Ecco un elenco dei significati di ciascuna durata.






1 – nota intera
2 – metà nota
4 – un quarto di nota
8 – un ottavo di nota
16 – un sedicesimo di nota
32 – un trentaduesimo di nota
Dopo aver letto dalla direttiva Durate DATA ciascun valore, questo è diviso per il valore
di NotaIntera, per ottenere la Durata usata nel comando FREQOUT. La quantità di
tempo per cui dura ciascuna nota dipende dal tempo della canzone. Un tempo più veloce
significa che ciascuna nota dura un tempo minore, mentre un tempo più lento significa
che ciascuna nota dura più a lungo. Poiché tutte le durate di nota sono frazioni di una
nota intera, potete usare la durata di una nota intera per impostare il tempo.
Cosa significa la "Q" in Note DATA? "Q" sta per “quit” (esci), e un ciclo DO
UNTIL...LOOP controlla che ci sia la "Q" in ciascuna ripetizione del ciclo, e viene ripetuto
fin quando non viene trovata.
Come si può eseguire una pausa? Potete inserire una pausa tra le note tramite
a
l’inserimento di una "P". Il capitolo “Il vostro turno” inizia con le prime note della 5 Sinfonia
di Beethoven, e fra di esse c’è una pausa.
Come posso suonare note diesis/bemolle? NoteEDurate.bs2 ha valori nelle sue tabelle di
ricerca per note diesis/bemolle. Quando utilizzate la versione della nota in lettera minuscola,
sarà suonata la nota bemolle. Per esempio, se volete suonare un B-bemolle, usate “b”
invece di “B”. Ricordate che questa nota ha la stessa frequenza di A-diesis.
Programma esempio: NoteEDurate.bs2
 Digitate ed eseguite NoteEDurate.bs2.
 Come suona?
' Che cos’è un Microcontrollore - NoteEDurate.bs2
' Suona le prime note di Fra Martino (Frere Jacques).
'{$STAMP BS2}
'{$PBASIC 2.5}
Note
DATA
"C","D","E","C","C","D","E","C","E","F",
"G","E","F","G","Q"
Durate
DATA
NotaIntera
CON
2000
indice
offset
VAR
VAR
Byte
Nib
LetteraNota
FreqNota
DurataNota
VAR
VAR
VAR
Byte
Word
Word
4,
2,
4,
4,
4,
4,
4,
2
4,
4,
4,
4,
4,
4,
DO UNTIL LetteraNota = "Q"
LOOKDOWN LetteraNota, [
LOOKUP offset,
"A",
"D",
"G",
"b",
"e",
"a",
"B",
"E",
"P",
"C",
"F",
"Q"
"d",
"g",
], offset
[ 1760, 1865, 1976, 2093, 2217,
2349, 2489, 2637, 2794, 2960,
3136, 3322,
0,
0
], FreqNota
READ Durata + indice, DurataNota
DurataNota = NotaIntera / DurataNota
FREQOUT 9, DuratsNota, FreqNota
indice = indice + 1
LOOP
END
Come lavora NoteEDurate.bs2 Works
Le direttive DATA Note and Durate sono state illustrate prima del programma. Queste
direttive combinate con la costante NotaIntera sono usate per memorizzare tutti i dati
musicali utilizzati dal programma.
Le dichiarazioni delle cinque variabili usate nel programma sono mostrate qui sotto.
Anche se per accedere ai dati non è più utilizzato un ciclo FOR...NEXT, occorre che ci sia
ancora una variabile (indice) che tiene traccia di quale entrata DATA è in lettura nelle
Note e Durate. La variabile offset è utilizzata nei comandi LOOKDOWN e LOOKUP per
selezionare un valore particolare. La variabile LetteraNota memorizza un carattere cui
si è avuto accesso tramite il comando READ. I comandi LOOKUP e LOOKDOWN sono
utilizzati per convertire questo carattere in un valore di frequenza. Questo valore è
memorizzato nella variabile FreqNota ed è utilizzato come argomento Freq1. del
comando FREQOUT. La variabile DurataNota è usata in un comando READ per ricevere
un valore dalla Durate DATA. È usata anche per calcolare l’argomento Duration del
comando FREQOUT.
indice
offset
VAR
VAR
Byte
Nib
LetteraNota
FreqNota
DurataNota
VAR
VAR
VAR
Byte
Word
Word
Il ciclo principale si mantiene in esecuzione fin quando dalla Note DATA viene letta la
lettera “Q” .
Un comando READ ricava un carattere dalla Note DATA, e lo memorizza nella variabile
LetteraNota. La variabile LetteraNota viene poi usata in un comando LOOKDOWN per
impostare il valore della variabile offset. Ricordate che offset memorizza un 1 se
viene rilevata una “b”, un 2 se viene rilevata una “B”, un 3 se viene rilevata una “C”, e
così via. Questo valore offset è usato successivamente in un comando LOOKUP per
prevedere quale dovrebbe essere il valore della variabile FreqNota. Se offset è 1,
FreqNota sarà 1865, se offset è 2, FreqNota sarà 1976, se offset è 3, FreqNota è
2093, e così via.
LOOKDOWN LetteraNota, [
LOOKUP offset,
"A", "b", "B", "C", "d",
"D", "e", "E", "F", "g",
"G", "a", "P", "Q" ], offset
[ 1760, 1865, 1976, 2093, 2217,
2349, 2489, 2637, 2794, 2960,
3136, 3322,
0,
0 ], FreqNota
La frequenza della nota è stata determinata, ma la durata dev’essere ancora prevista. Il
comando READ usa il valore di indice per porre un valore da Durate DATA in
DurataNota.
READ Durate + indice, DurataNota
Quindi, DurataNota è fatta uguale alla costante NotaIntera divisa per DurataNota. Se
DurataNota parte col valore 4 da un comando READ, diventa 2000 ÷ 4 = 500. Se
DurataNota è 8, diventa 2000 ÷ 8 = 250.
Ora che sono state determinate DurataNota e FreqNota, il comando FREQOUT suona la
nota.
Ad ogni esecuzione del ciclo principale, il valore di indice deve essere aumentato di
uno. Quando il ciclo principale torna all’inizio, la prima cosa che il programma fa è
leggere la nota successiva, usando la variabile indice.
indice = indice + 1
LOOP
Il vostro turno – Sperimentare con Tempo e un tono diverso
La quantità di tempo che ogni nota dura ha a che fare con il tempo (o ritmo). Potete
cambiare il tempo (musicale) regolando il valore della costante NotaIntera. Se lo
aumentate a 2250, il tempo diminuirà, e la canzone sarà suonata più lentamente. Se lo
diminuite a 1750, il tempo aumenterà e la canzone sarà suonata più rapidamente.
 Memorizzate NoteEDurate.bs2 con il nome NoteEDurateVostroTurno.bs2.
 Modificate il tempo di NoteEDurateVostroTurno.bs2 regolando il valore di
NotaIntera. Provate i valori 1500, 1750, 2000, e 2250.
 Ri-eseguite il programma dopo ciascuna modifica, e decidete quale suona
meglio.
Inserire dati musicali è molto più facile quando tutto ciò che dovete fare è registrare note
e durate. Eccovi le prime otto note della Quinta Sinfonia di Beethoven.
Note
DATA "G","G","G","e","P","F","F","F","D","Q"
Durate
DATA
NotaIntera CON
8,
8,
8,
2,
8,
8,
8,
8,
2
2000
 Memorizzate il vostro programma modificato col nome QuintaBeethoven.bs2.
 Sostituite le direttive DATA Note e Durate e la dichiarazione di costante
NotaIntera con il codice qui sopra.
 Eseguite il programma. Suona bene?
Aggiunta di caratteristiche musicali
Il programma esempio che avete appena terminato ha introdotto note, durate, e pause.
Esso ha utilizzato inoltre la durata di una nota intera per determinare il tempo (o ritmo).
Ecco tre ulteriori caratteristiche che possiamo aggiungere ad un programma che esegue
musica:



Suonare note “puntate”
Determinare la durata della nota intera (o “breve”) dal tempo
Suonare note da più di una ottava
Il termine puntato si riferisce ad un punto usato negli spartiti per indicare che una nota
dev’essere suonata a 1 ½ volta della sua durata normale. Per esempio, una nota puntata
ad un quarto dovrà durare per la durata di una nota a un quarto, più quella di una nota a
un ottavo. Una nota puntata a un mezzo dura per la durata di un mezzo più la durata di
una nota di un quarto. Potete aggiungere una tabella di dati che memorizza se una nota è
puntata o no. In questo esempio, uno zero significa che non c’è il punto mentre un 1
significa che c’è il punto:
Punti
DATA
0,
0,
0,
0,
0,
0,
0,
1,
0,
0
0,
1,
0,
0,
0,
0,
I programmi che eseguono musica esprimono tipicamente il tempo di una canzone in
battute per minuto. E’ lo stesso che dire quarti di nota per minuto.
BattutePerMin
CON
200
La Figura 8-4 è una ripetizione della Figura 8-3 da pagina 270. Essa mostra la 6a e la 7a
ottava sulla tastiera di un pianoforte. Queste sono le due ottave che suonano in modo più
chiaro quando sono riprodotte dall’altoparlante piezo. Ecco un esempio di una direttiva
DATA che userete nel capitolo Il vostro turno per eseguire note da più di una ottava usando
la direttiva Note DATA.
Ottave
DATA
6,
6,
7,
6,
6,
6
6,
6,
6,
6,
6,
6,
7,
6,
Figura 8-4: I tasti più a destra di un pianoforte e le loro frequenze
Programma esempio: MusicaConPiùCaratteristiche.bs2
Questo programma esempio suona le prime note di “For He’s a Jolly Good Fellow.”
(“Perché è un bravo ragazzo”) Tutte le note vengono dalla stessa (7a) ottava, ma alcune
note sono puntate. Nel capitolo Il vostro turno, proverete un esempio che usa note da più
di una ottava, e note puntate.
 Digitate ed eseguite MusicaConPiùCaratteristiche.bs2.
 Contate le note e osservate se potete sentire le note puntate ( durata 1 ½).
 Ascoltate anche le note dell’ottava 7. Provate a cambiare una di quelle note
all’ottava 6. Il cambio nel modo in cui la musica viene eseguita è del tutto
drastico.
' Che cos’è un Microcontrollore - MusicaConPiùCaratteristiche.bs2
' Suona l’inizio di Perchè è un bravo ragazzo.
'{$STAMP BS2}
'{$PBASIC 2.5}
Note
DATA
"C","E","E","E","D","E","F","E","E","D","D",
"D","C","D","E","C","Q"
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7
4, 2, 4, 4, 4, 4, 2, 2, 4, 2, 4,
4, 4, 4, 2, 2
0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
0, 0, 0, 1, 0
Ottave
DATA
Durate
DATA
Punti
DATA
BattutePerMin
CON
320
indice
offset
VAR
VAR
Byte
Nib
LetteraNota
FreqNota
DurataNota
OttavaNota
PuntoNota
VAR
VAR
VAR
VAR
VAR
Byte
Word
Word
Nib
Bit
NotaIntera
VAR
Word
NotaIntera = 60000 / BattutePerMin * 4
LOOKDOWN LetteraNota, [ "C",
"F",
"b",
LOOKUP offset,
"d",
"g",
"B",
"D",
"G",
"P",
"e",
"a",
"Q"
"E",
"A",
], offset
[ 4186, 4435, 4699, 4978, 5274,
5588, 5920, 6272, 6645, 7040,
7459, 7902,
0,
0
], FreqNota
READ Ottave + indice, OttavaNota
OttavaNota = 8 - OttavaNota
FreqNota = FreqNota / (DCD OttavaNota)
READ Punti + indice, PuntoNota
IF PuntoNota = 1 THEN DurataNota = DurataNota * 3 / 2
indice = indice + 1
LOOP
END
Come lavora MusicaConPiùCaratteristiche.bs2
Qui sotto sono riportati i dati musicali dell’intera canzone. Per ciascuna nota nella
direttiva Note DATA, c’è un corrispondente dato nelle direttive DATA Ottave, Durate, e
a
Punti. Per esempio, la prima nota è una nota C (Do) nella 7 ottava; è una nota da un
quarto e non è puntata. Ecco un altro esempio: la seconda a partire dall’ultima nota (non
inclusa “Q”) è una nota E (Mi), nella 7a ottava. E’ una nota metà, ed è puntata. C’è
anche una costante BatttutePerMin che imposta il tempo della canzone.
Note
DATA
Ottave
DATA
Durate
DATA
Punti
DATA
BattutePerMin
"C","E","E","E","D","E","F","E","E","D","D",
"D","C","D","E","C","Q"
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7
4, 2, 4, 4, 4, 4, 2, 2, 4, 2, 4,
4, 4, 4, 2, 2
0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
0, 0, 0, 1, 0
CON
320
Nel programma esempio precedente, NotaIntera era una costante. Questa volta, è una
variable che conterrà la durata di una nota intera in ms. Dopo aver calcolato questo
valore, NotaIntera sarà usata per determinare le durate di tutte le altre note, proprio
come nel programma precedente. Le variabili indice, offset, LetteraNota, e
DurataNota sono anch’esse usate nello stesso modo in cui lo erano nel programma
precedente. La variabile FreqNota è gestita in modo un pò diverso, poichè ora deve
essere regolata in funzione dell’ottava in cui viene suonata la nota. Le variabili
OttavaNota e PuntoNota sono state aggiunte per gestire le caratteristiche ottava e
punto.
NotaIntera
VAR
Word
indice
offset
VAR
VAR
Byte
Nib
LetteraNota
FreqNota
DurataNota
OttavaNota
PuntoNota
VAR
VAR
VAR
VAR
VAR
Byte
Word
Word
Nib
Bit
La variabile NotaIntera è calcolata usando BattutePerMin. Il tempo della canzone è
definito in battute per minuto e il programma deve dividere 60000 ms per
BattutePerMin, poi moltiplicare per 4. Il risultato è il valore corretto per una nota
intera.
NotaIntera = 60000 / BattutePerMin * 4
La Matematica viene eseguita da sinistra a destra. Nel calcolo NotaIntera = 60000
/ BattutePerMin * 4, il BASIC Stamp calcola prima 60000 / BattutePerMin. Poi,
moltiplica quel risultato per 4.
Per raggruppare le operazioni si possono usare le parentesi. Se volete prima dividere
BattutePerMin per 4 , potete far così: NotaIntera = 60000 / (BattutePerMin * 4).
Ciò è del tutto uguale al programma precedente:
LOOKDOWN LetteraNota, [ "C",
"F",
"b",
"d",
"g",
"B",
"D",
"G",
"P",
"e",
"a",
"Q"
"E",
"A",
], offset
Ora che nella miscela ci sono le ottave, la parte di codice che prevede la frequenza delle
note è stata cambiata. La tabella di valori del comando LOOKUP contiene frequenze di
nota dalla 8a ottava. Questi valori possono essere divisi per 1 se volete suonare le note
nella 8a ottava, per 2 se volete suonare le note nella 7a ottava, per 4 se volte suonare le
note nella 6a ottava e per 8 se volete suonare le note nella 5a ottava. La divisione va fatta
prima. Tutto ciò che fa questo comando LOOKUP è porre una nota dalla 8a ottava nella
variabile FreqNota.
LOOKUP offset,
[ 4186, 4435, 4699, 4978, 5274,
5588, 5920, 6272, 6645, 7040,
7459, 7902,
0,
0
], FreqNota
Ecco come la variabile FreqNota è regolata per avere l’ottava corretta. Dapprima, il
comando READ cattura il valore di ottava memorizzato nella Ottave DATA. Questo può
essere un valore tra 5 e 8.
READ Ottave + indice, OttavaNota
A seconda dell’ottava, vogliamo dividere FreqNota per 1, 2, 4, o 8. Questo significa che
il risultato è in realtà da dividere per 20 = 1, 21 = 2, 22 = 4, o 23 = 8. L’istruzione qui sotto
prende il valore di OttavaNota, che potrebbe essere un valore tra 5 ed 8, e sottrae quel
valore da 8. Se OttavaNota era 8, ora è 0. Se OttavaNota era 7, ora è 1. Se
OttavaNota era 6, ora è 2, e se OttavaNota era 5, ora è 3.
Ora, OttavaNota è un valore che può essere usato come esponente di 2, ma come si fa ad
elevare 2 ad una sua potenza in PBASIC? Una risposta è usare l’operatore DCD. DCD 0 è
1, DCD 1 è 2, DCD 2 è 4, e DCD 3 è 8. Dividendo FreqNota per DCD OttavaNota significa
che state dividendo per 1, 2, 4, o 8, che dividerà FreqNota per il valore corrente. Il
risultato finale è che FreqNota è impostato all’ottava corretta. Userete il terminale di
Debug nel capitolo Il vostro turno per osservare più da vicino come funzioni questo.
Come faccio a sapere come si usa l’operatore DCD? Apprendete e imparate con la
pratica. Ogni volta che vedete un nuovo comando, operatore, o qualsiasi altra parola chiave
usata in un esempio, cercatela nel manuale BASIC Stamp. Leggete cosa dice, e provate ad
usarla in un programma fatto da voi.
Acquisite l’abitudine di leggere periodicamente il Manuale del BASIC Stamp e provare i
piccoli programmi esempio. Questo è il modo migliore di acquisire familiarità con i vari
comandi ed operatori e con il loro modo di operare. Facendo queste cose, svilupperete
l’abitudine di aggiungere sempre qualcosa all’elenco di strumenti di programmazione che
potete usare per risolvere problemi.
Le prime due righe di codice per determinare la durata della nota sono quasi le stesse del
codice del programma esempio precedente. Ora, però, qualsiasi nota può essere puntata,
il che vuol dire che la sua durata potrebbe dover essere moltiplicata per 1,5. Per accedere
ai valori memorizzati in EEPROM dalla direttiva DATA Punti si usa un comando READ.
Ogni volta che il valore della variabile PuntoNota è 1, per moltiplicare per 3 e dividere
per 2 si usa una frase IF...THEN.
Matematica con interi. Il BASIC Stamp non elabora automaticamente un numero come
1,5. Quando effettua calcoli matematici, lavora soltanto con numeri interi: …, -5, -4, -3, -2, 1, 0, 1, 2, 3, … La migliore soluzione per moltiplicare per 1,5 è di moltiplicare per 3/2.
Dapprima, moltiplicare per 3, e poi dividere per 2.
Ci sono molti modi di programmare il BASIC Stamp per gestire valori frazionari. Potete
programmare il BASIC Stamp perché usi gli interi per considerare la parte decimale di un
numero. Questo fatto è stato introdotto nel manuale Basic Analog and Digital Student
Guide. Ci sono inoltre due operatori che rendono più facile il lavorare con valori frazionari, e
sono: ** and */. Questi operatori sono illustrati in dettaglio nel manuale Applied Sensors
Student Guide e nel manuale del BASIC Stamp.
La parte rimanente di questo programma esempio opera nello stesso modo in cui operava
nel programma esempio precedente:
indice = indice + 1
LOOP
END
Il vostro turno – Suonare un motivo con più di una ottava
MusicaConPiùCaratteristiche.bs2 faceva uso delle pause, ma si manteneva entro una sola
ottava. Il motivo “Take Me Out to the Ball Game” (“Portami fuori a giocare a palla”)
mostrato qui sotto suona la maggior parte delle sue note nella 6a ottava. Ci sono due note
nella 7a ottava, ed esse fanno una grande differenza nel modo in cui suona.
 Memorizzate
una
copia
del
programma
col
nome
MusicaConPiùCaratteristicheVostroTurno.bs2.
 Modificate il programma sostituendo le quattro direttive Data ed una
dichiarazione di costante con queste altre:
Note
DATA
Ottave
DATA
Durate
DATA
Punti
DATA
BattutePerMin
"C","C","A","G","E","G","D","P","C","C","A",
"G","E","G","Q"
6, 7, 6, 6, 6, 6, 6, 6, 6, 7, 6,
6, 6, 6
2, 4, 4, 4, 4, 2, 2, 4, 2, 4, 4,
4, 4, 2
0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
0, 0, 1
CON
240
 Eseguite il programma e verificate che suoni in modo corretto .
Quelle due note nella 7a ottava sono essenziali per far suonare il motivo in modo corretto.
E’ interessante ascoltare cosa succede se quei valori della 7a ottava sono cambiati nei
corrispondenti valori della 6a.
 Provate a cambiare i due valori della 7a nella direttiva Ottave DATA in modo che
essi siano della 6a. Tenetelo a mente, ciò farà suonare “Take Me out to the Ball
Game” in modo strano.
 Eseguite il programma, e ascoltate l’effetto dell’ottava errata sulla canzone.
 Cambiate di nuovo la Ottave DATA riportandola allo stato originario.
 Eseguite di nuovo il programma ed ascoltate il motivo per vedere se suona di
nuovo in modo corretto.
ATTIVITÀ #5: SUONERIE CON IL RTTTL
I vecchi telefoni cellulari usavano suonare i toni di avviso (delle chiamate, cioè le
suonerie) con un altoparlante piezo. Le suonerie venivano scaricate dal web su un
computer, e poi ricaricate dal computer sul microcontrollore del telefono cellulare.
All’epoca, uno dei modi più utilizzati per comporre, registrare e inviare suonerie era un
modo che usava stringhe di testo con caratteri che descrivevano ciascuna nota nel motivo.
Eccovi un esempio di come le prime note dalla “5a di Beethoven” apparivano in una di
queste stringhe:
Beethoven5:d=8,o=7,b=125:g,g,g,2d#,p,f,f,f,2d
Questo formato per memorizzare dati musicali è chiamato RTTTL, acronimo di Ringing
Tone Text Transfer Language (Linguaggio per trasferire testi di suonerie). La grande
trovata dei file RTTTL all’epoca fu la loro larga condivisione via World Wide Web.
Molti siti hanno file RTTTL disponibili per lo scarico gratuito. C’erano anche programmi
software gratuiti usabili per comporre e simulare questi file, oltre a caricarli sul vostro
cellulare. La specifica del RTTTL è ancora pubblicata online. L’Appendice C riassume
il modo in cui un file RTTTL memorizza note, durate, pause, tempo, e note puntate.
Questa attività introduce alcune tecniche di programmazione PBASIC usabili per
riconoscere elementi diversi di testo. L’abilità di riconoscere caratteri o gruppi di caratteri
diversi e compiere azioni basate sul contenuto dei caratteri è estremamente utile. Infatti,
è la chiave per convertire una suoneria di formato RTTTL (come la Beethoven5 riportata
sopra) in musica. Alla fine di questa attività, c’è un programma applicativo che potete
usare per suonare suonerie in formato RTTTL.
Scegliere quale blocco di codice eseguire in base a un tipo di carattere
La frase SELECT...CASE è probabilmente il miglior strumento di programmazione per
riconoscere caratteri o valori. Tenete a mente che è uno degli strumenti usati per
convertire una suoneria RTTTL in note musicali.
In generale, la SELECT...CASE è usata per:



Scegliere una variabile o un’espressione.
Valutare quella variabile o espressione in base a un tipo di carattere .
Eseguire blocchi di codice differenti a seconda di quale tipo di carattere è
riportato in quella variabile.
Ecco la sintassi di SELECT...CASE:
SELECT espressione
CASE condizion(e)
frase (frasi)
{ CASE ELSE
frase (frasi) }
ENDSELECT
Potete provare i due programmi esempio che seguono, per vedere come SELECT...CASE
lavora. ScegliTipoConValori.bs2 considera valori numerici digitati nel terminale di
Debug e dice qual’è la dimensione minima di variabile necessaria a memorizzare quel
valore. ScegliTipoConCaratteri.bs2 dice se il carattere digitato nel terminale di Debug è
maiuscolo o minuscolo, o è una cifra, o un segno di interpunzione.
Ricordate di usare la Finestrella di trasmissione nel terminale di Debug per inviare i
caratteri che digitate al BASIC Stamp. Le finestrelle di trasmissione e ricezione sono
mostrate nella Figura 8-5.
Figura 8-5
Invio di messaggi
al BASIC Stamp
Finestrelle di
Trasmissione →
Digitate un valore tra
0 e 65535 1
BIT
Ricezione →
Digitate un altro valore 10
NIB (Nibble)
Cliccate sulla
finestrella di
Trasmissione
(superiore) e
digitate il valore o i
caratteri che volete
trasmettere al
BASIC Stamp.
Programma esempio: ScegliTipoConValori.bs2
 Digitate ed eseguite ScegliTipoConValori.bs2.
 Nel terminale di Debug, accertatevi che la casella di opzione Echo Off sia bianca
(nessun segno di spunta).
 Cliccate sulla finestrella di trasmissione del terminale di Debug.
 Digitate un valore tra 0 e 65535, e premete il tasto Enter.
Cosa accade se digitate un numero maggiore di 65535? Se digitate il numero 65536, il
BASIC Stamp memorizzerà il numero 0. Se digitate il numero 65537, il BASIC Stamp
memorizzerà il numero 1, e così via. Se un numero è troppo grande per entrare nella
variabile a cui si invia, questo fenomeno è detto overflow.
 Usate la Tabella 8-1 per verificare che il programma esempio prenda le decisioni
giuste sulle dimensioni dei numeri che digitate nel terminale di Debug.
Tabella 8-1: Tipi di variabile e valori che possono memorizzare
Tipo di variable
Bit
Intervallo di valori
Da 0 a 1
Nib
Da 0 a 15
Byte
Da 0 a 255
Word
Da 0 a 65535
' Che cos’è un Microcontrollore - ScegliTipoConValori.bs2
' Digitate un valore e vedete la minima variabile che può ospitarlo.
'{$STAMP BS2}
'{$PBASIC 2.5}
valore
PAUSE 1000
VAR
Word
DEBUG "Digita un valore tra ", CR,
"0 e 65535: "
DO
DEBUGIN DEC valore
SELECT valore
CASE 0, 1
DEBUG "Bit", CR
PAUSE 100
CASE 2 TO 15
DEBUG "Nib (Nibble)", CR
PAUSE 200
CASE 16 TO 255
DEBUG "Byte", CR
PAUSE 300
CASE 256 TO 65535
DEBUG "Word", CR
PAUSE 400
ENDSELECT
DEBUG CR, "Digita un altro valore: "
LOOP
Come lavora ScegliTipoConValori.bs2
Per memorizzare i valori digitati nel terminale di Debug è stata dichiarata una variabile
word.
valore VAR Word
Il comando DEBUGIN prende il numero digitato e lo pone entro la variabile valore.
DEBUGIN DEC valore
La frase SELECT sceglie la variabile valore come quella da cui elaborare i casi.
SELECT valore
Il primo caso è quando la variabile valore è uguale a 0 o ad 1. Se il valore uguaglia uno
qualsiasi di questi numeri, sono eseguiti i comandi DEBUG e PAUSE che lo seguono.
CASE 0, 1
DEBUG "BIT", CR
PAUSE 100
Il secondo caso è se il valore uguaglia un numero qualsiasi compreso tra 2 e 15. Se è
uguale ad uno qualsiasi di quei numeri, sono eseguiti i comandi DEBUG e PAUSE sotto la
CASE.
CASE 2 to 15
DEBUG "NIB (Nibble)", CR
PAUSE 200
Quando tutti i casi sono stati eseguiti, per completare la frase SELECT..CASE è usata la
parola chiave ENDSELECT.
ENDSELECT
Programma esempio: ScegliTipoConCaratteri.bs2
Questo programma esempio valuta quale carattere digitate nella finestrella di
trasmissione del terminale di Debug. Può riconoscere caratteri in maiuscolo e minuscolo,
cifre, ed alcuni segni di interpunzione. Se digitate un carattere che il programma non
riconosce, vi dirà di riprovare (cioè di digitare un carattere differente).




Digitate ed eseguite ScegliTipoConCaratteri.bs2.
Accertatevi che la casella Echo Off sia Bianca (nessun segno di spunta).
Cliccate la finestrella di trasmissione del terminale di Debug per porvi il cursore
Digitate caratteri nella finestra di trasmissione ed osservate i risultati.
' Che cos’è un Microcontrollore - ScegliTipoConCaratteri.bs2
' Programma che può identificare alcuni caratteri: tipo, cifra, segno di
' interpunzione.
'{$STAMP BS2}
'{$PBASIC 2.5}
carattere
PAUSE 1000
VAR
Byte
DEBUG "Digita un carattere: ", CR
DO
DEBUGIN carattere
SELECT carattere
CASE "A" TO "Z"
DEBUG CR, "Maiuscolo ", CR
CASE "a" TO "z"
DEBUG CR, "Minuscolo ", CR
CASE "0" TO "9"
DEBUG CR, "Cifra", CR
CASE "!", "?", ".", ","
DEBUG CR, "Segno di interpunzione", CR
CASE ELSE
DEBUG CR, "Caraetere sconosciuto.", CR,
"Prova uno diverso."
ENDSELECT
DEBUG CR, "Digita un altro carattere ", CR
LOOP
Come lavora ScegliTipoConCaratteri.bs2
Se confrontato con ScegliTipoConValori.bs2, questo programma esempio ha poche
differenze. Prima di tutto, il nome della variabile valore è stato cambiato in
carattere, e la sua dimensione è stata cambiata da word a byte. La ragione è che tutti i
caratteri del PBASIC hanno dimensione byte. La frase SELECT sceglie la variabile
carattere per la valutazione caso per caso.
SELECT carattere
Le virgolette sono usate per dire all’Editor del BASIC Stamp che fate riferimento a
caratteri. Si possono trattare i gruppi di caratteri e segni di interpunzione che seguono
come un intervallo di numeri, poiché il BASIC Stamp li riconosce dal loro equivalente
numerico ASCII — vedere la tabella ASCII nell’Help dell’Editor del BASIC Stamp.
SELECT carattere
CASE "A" TO "Z"
DEBUG CR, "Maiuscolo ", CR
CASE "a" TO "z"
DEBUG CR, "Minuscolo ", CR
CASE "0" TO "9"
DEBUG CR, "Cifra", CR
CASE "!", "?", ".", ","
DEBUG CR, "Segno di interpunzione", CR
C’è soltanto una diversa frase CASE, non usata nell’esempio precedente:
CASE ELSE
DEBUG CR, "Carattere sconosciuto.", CR,
"Prova uno diverso."
Questa frase CASE dice al blocco di codice SELECT cosa fare se nessuno dei casi previsti è
vero. Potete far lavorare questo caso digitando un carattere come % o $.
Il vostro turno – Scelta di caratteri speciali
 Modificate la frase SELECT...CASE in ScegliTipoConCaratteri.bs2 in modo che
visualizzi “Carattere speciale” quando inserite uno di questi caratteri: @, #, $,
%, ’^’ , &, *, (, ), _, or +.
Programma applicativo esecutore di suoneria RTTTL
Qui sotto è riportato il file RTTTL che contiene le informazioni musicali usate nel
programma esempio successivo. Ci sono cinque direttive RTTTL_File DATA ulteriori
che potete provare nel capitolo “Il vostro turno”. Questo programma esegue un motivo
chiamato “Reveille” che è la “sveglia mattutina” suonata negli accampamenti militari
come prima cosa al mattino. Potete averla ascoltata in tantissimi film o spettacoli
televisivi.
RTTTL_File
DATA "Reveille:d=4,o=7,b=140:8g6,8c,16e,16c,8g6,8e,",
"8c,16e,16c,8g6,8e,8c,16e,16c,8a6,8c,e,8c,8g6,",
"8c,16e,16c,8g6,8e,8c,16e,16c,8g6,8e,8c,16e,",
"16c,8g6,8e,c,p,8e,8e,8e,8e,g,8e,8c,8e,8c,8e,8c,",
"e,8c,8e,8e,8e,8e,8e,g,8e,8c,8e,8c,8g6,8g6,c."
Programma esempio: MicroMusicaConRtttl.bs2
Questro programma applicativo è piuttosto lungo, ed è una buona idea scaricare l’ultima
vesrione dalla pagina web www.parallax.com/go/WAM. Scaricare questo programma e
aprirlo con l’Editor del BASIC Stamp dovrebbe farvi risparmiare un bel po’ di tempo.
L’alternativa, naturalmente, è digitare a mano e mettere a punto quattro pagine di codice.
 Con l’editor del BASIC Stamp, aprite il vostro file MicroMusicaConRtttl.bs2,
oppure digitate a mano l’esempio qui sotto con molta attenzione.
 Eseguite il programma, e verificate che il motivo è riconoscibile come la sveglia
mattutina dei militari (Reveille).
 Andate al capitolo “Il vostro turno” e provate altri motive ulteriori (direttive
RTTTL_File DATA).
' Che cos’è un Microcontrollore - MicroMusicaConRtttl.bs2
' Esegue suonerie in formato Nokia RTTTL usando direttive DATA.
'{$STAMP BS2}
'{$PBASIC 2.5}
' -----[ Definizioni I/O]------------------------------------------------PinAltoparlante
PIN
9
' Altoparlante Piezo connesso a P9.
' -----[ Variabili ]------------------------------------------------------contatore
car
indice
VAR
VAR
VAR
Word
Byte
Word
' Contatore tutto-fare.
' Variabile memorizza caratteri.
' Indice per puntare ai dati.
LetteraNota
FreqNota
OttavaNota
VAR
VAR
VAR
Byte
Word
Word
' Memorizza carattere nota.
' Memorizza frequenza nota.
' Memorizza ottava nota.
durata
tempo
VAR
VAR
Word
Word
' Memorizza durata nota.
' Memorizza tempo.
default_d
default_o
default_b
VAR
VAR
VAR
Byte
Byte
Word
' Memorizza durata default.
' Memorizza ottava default.
' Memorizza batt/min default.
' -----[ Dati in EEPROM]--------------------------------------------------RTTTL_File
DATA
"Reveille:d=4,o=7,b=140:8g6,8c,16e,16c,8g6,8e,",
"8c,16e,16c,8g6,8e,8c,16e,16c,8a6,8c,e,8c,8g6,",
"8c,16e,16c,8g6,8e,8c,16e,16c,8g6,8e,8c,16e,",
"16c,8g6,8e,c,p,8e,8e,8e,8e,g,8e,8c,8e,8c,8e,8c,",
"e,8c,8e,8e,8e,8e,8e,g,8e,8c,8e,8c,8g6,8g6,c."
Fatto
DATA
",q,"
Note
DATA
Ottava8
DATA
"p",
"a",
"#",
"b",
"c",
"#",
"d",
"#",
"e",
"f",
"#",
"g",
"#"
Word 0,
Word 3520, Word 3729, Word 3951,
Word 6645
' -----[ Inizializzazione ]-----------------------------------------------contatore = 0
' Inizializza contatore.
GOSUB
GOSUB
GOSUB
GOSUB
GOSUB
GOSUB
'
'
'
'
'
'
TrovaUguali
ProcessaDurata
TrovaUguali
ProcessaOttava
TrovaUguali
OttieneTempo
Trova primo '=' nel file.
Ottiene durata default.
Trova prossimo '='.
Ottiene ottava default.
Trova ultimo '='.
Ottiene tempo default.
' -----[ Codice Program]---------------------------------------------------DO UNTIL car = "q"
GOSUB ProcessaDurata
GOSUB ProcessaNota
GOSUB ControllaSePunto
GOSUB ProcessaOttava
GOSUB SuonaNota
LOOP
'
'
'
'
'
'
'
Cicla fino a 'q' in DATA.
Ottiene durata nota.
Ottiene valore indice nota.
Se punto, durata 3/2.
Ottiene ottava.
Ottiene freq, suona nota, prox.
Fine ciclo principale.
END
' Fine del programma.
' -----[ Subroutine – Trova carattere uguale ]----------------------------TrovaUguali:
DO
READ RTTTL_File + contatore, car
contatore = contatore + 1
LOOP UNTIL car = "="
'
'
'
'
'
Va attraverso i caratteri nel
file RTTTL cercando per un
'='. Incrementa cuntatore
fin quando si trova '=' , poi
ritorna alla chiamata.
RETURN
'
'
'
'
'
-----[ Subroutine - Legge Tempo da testata RTTTL]---------------------Ogni carattere della tastiera ha un numero unico chiamato valore ASCII.
I caratteri 0, 1, 2,...9 hanno i valori ASCII di 48, 49, 50,...57.
Potete sempre convertire dal carattere che rappresenta una cifra al
suo valore sottraendo 48 dalla variabile che memorizza la cifra.
' Potete esaminare questo confrontando
OttieneTempo:
default_b = 0
DO
IF car = ":" THEN
default_b = default_b / 10
EXIT
ENDIF
default_b = default_b + car - 48
default_b = default_b * 10
LOOP UNTIL car = ":"
RETURN
DEBUG DEC 49 e DEBUG 49.
'
'
'
'
'
'
'
'
'
'
'
'
'
'
'
'
Analizza file RTTTL per Tempo.
Converte caratteri in
cifre sottraendo 48
dal valore ASCII di ciascun
carattere. Iterativamente
moltiplica ciascuna cifra per
10 se c’è una altra cifra, poi
aggiunge la cifra più recente
alla colonna dell’’uno.
Per esempio, la stringa
"120" è (1 X 10 X 10)
+ (2 X 10) + 0. Per primo
è convertito il '1', poi
moltiplicato per 10. Poi è
convertito/aggiunto il '2'. Poi
è convertito/aggiunto 0, fatto.
' -----[ Subroutine – Guarda l’ottava ]-----------------------------------ProcessaOttava:
SELECT car
CASE "5" TO "8"
OttavaNota = car - "0"
CASE ELSE
OttavaNota = default_o
ENDSELECT
IF default_o = 0 THEN
default_o = OttavaNota
ENDIF
RETURN
'
'
'
'
'
'
'
'
'
'
'
'
'
'
'
L’ottava si include o meno in
una data nota poiché qualsiasi
nota che viene suonata
nella ottava di default
non specifica la
ottava. Se c’’è un car
da '5' a '8' usate quello,
altrimenti usate default_o.
I caratteri sono convertiti
in cifre sottraendo '0',
che è lo stesso che
sottrarre 48. La prima volta
che è chiamata questa
subroutine, default_o è 0.
Se 0, allora imposta default_o.
' -----[ Subroutine - Trova indice di Nota ]-------------------------------ProcessaNota:
' Imposta valore indice per ricerca
' di frequenza nota basata su
' carattere nota. Se 'p',
SELECT car
' indice è 0. Se da 'a' a 'g',
CASE "p"
' Legge valori carattere in
indice = 0
' tabella DATA e trova accordo.
' Registra valore indice quando
CASE "a" TO "g"
' trova accordo. Se car successFOR indice = 1 TO 12
' sivo è un diesis (#), aggiunge
' 1 al valore di indice per
IF LetteraNota = car THEN EXIT
' aumentare l’’indice (e la
NEXT
' frequenza) di 1 tacca.
' Come le altre subroutine,
SELECT car
CASE "#"
indice = indice + 1
ENDSELECT
ENDSELECT
' aumenta il contatore per ciascun
' carattere che è elaborato.
RETURN
' -----[ Subroutine - Determina Durata Nota]--------------------------------ProcessaDurata:
SELECT car
CASE "1", "2", "3", "4", "8"
durata = car - 48
SELECT car
CASE "6", "2"
durata = durata * 10 + car - 48
ENDSELECT
CASE ELSE
durata = default_d
ENDSELECT
IF default_d <> 0 THEN
durata = 60000/default_b/durata*3
ELSE
default_d = durata
ENDIF
'
'
'
'
'
'
'
'
Controlla se caratteri formano
1, 2, 4, 8, 16 o 32.
Se si, converte da carattere
ASCII a valore sottraendo 48.
Nel caso di 16 o 32, moltiplica
per 10 ed aggiunge la cifra
successiva alla colonna
degli uni.
' Se manca la durata,
' usate il default.
'
'
'
'
Se default_d non è definito
(if default_d = 0), allora
impostate default_d = alla
durata dalla d=#.
RETURN
' -----[ Subroutine – Controlla se '.' Indica 1,5 volte la Durata ]---------ControllaSePunto:
SELECT car
CASE "."
durata = durata * 3 / 2
ENDSELECT
RETURN
'
'
'
'
'
'
Controlla se punto che indica
multiplicare durata per 3/2.
Se trova ‘’.’’, moltiplica per
3/2 e incrementa contatore,
altrimenti, non far niente
e ritornare.
' -----[ Subroutine – Trova Virgola e Suona Note/Durata ]----------------SuonaNota:
'
'
'
'
'
Trova ultima virgola nella
nota appena inserita. Quindi,
prendere la frequenza della
nota da data, e suonarla, o
far pausa se frequenza = 0.
SELECT car
CASE ","
READ Ottava8 + (indice * 2), Word FreqNota
IF FreqNota = 0 THEN
PAUSE durata
ELSE
FREQOUT PinAltoparlante, durata, FreqNota
ENDIF
ENDSELECT
RETURN
Come lavora MicroMusicaConRtttl.bs2
Questo programma esempio è molto divertente da usare, e mostra il genere di codice che
riuscirete a scrivere dopo un po’ di pratica. Però, è stato incluso in questo testo più per
divertimento che per i concetti di codifica che impiega. Se esaminate brevemente il
codice, potete notare che avete già utilizzato tutti i comandi e gli operatori del
programma, eccetto uno!
Ecco l’elenco degli elementi in questo programma che dovrebbero, d’ora in poi, esservi
familiari:











Commenti che vi aiutino a spiegare il vostro codice
Dichiarazioni di costanti e variabili
Dichiarazioni DATA
Comandi READ
Blocchi IF...ELSE...ENDIF
Cicli DO...LOOP sia con WHILE ed UNTIL, che senza
Subroutine con GOSUB, etichette, e RETURN
Cicli FOR...NEXT
Comandi LOOKUP e LOOKDOWN
Comandi FREQOUT e PAUSE
Comando SELECT...CASE

EXIT è un commando nuovo, che consente semplicemente al programma di
“uscire” da un ciclo prima che esso sia stato completato, ed è usato spesso in
frasi IF...THEN.
Il vostro turno – Motivi differenti
 Provate a sostituire la direttiva RTTTL_File DATA nel programma
MicroMusicaConRTTTL.bs2 con ciascuno dei cinque file musicali differenti
riportati qui sotto.
Soltanto una direttiva RTTTL_File DATA per volta! Assicuratevi di sostituire, non
aggiungere, la vostra nuova direttiva RTTTL_File DATA.
 Eseguite MicroMusicaConRTTTL.bs2 per provare ciascuno dei file TTTL.
RTTTL_File
DATA
"TwinkleTwinkle:d=4,o=7,b=120:c,c,g,g,a,a,2g,f,",
"f,e,e,d,d,2c,g,g,f,f,e,e,2d,g,g,f,f,e,e,2d,c,c,",
"g,g,a,a,2g,f,f,e,e,d,d,1c"
RTTTL_File
DATA
"FrereJacques:d=4,o=7,b=125:c,d,e,c,c,d,e,c,e,f",
",2g,e,f,2g,8g,8a,8g,8f,e,c,8g,8a,8g,8f,e,c,c,g6",
",2c,c,g6,2c"
RTTTL_File
DATA
"Beethoven5:d=8,o=7,b=125:g,g,g,2d#,p,f,f,f,2d"
RTTTL_File
DATA
"ForHe'sAJollyGoodFellow:d=4,o=7,b=320:c,2e,e,e,",
"d,e,2f.,2e,e,2d,d,d,c,d,2e.,2c,d,2e,e,e,d,e,2f,",
"g,2a,a,g,g,g,2f,d,2c"
RTTTL_File
DATA
"TakeMeOutToTheBallgame:d=4,o=7,b=225:2c6,c,a6,",
"g6,e6,2g.6,2d6,p,2c6,c,a6,g6,e6,2g.6,g6,p,p,a6",
",g#6,a6,e6,f6,g6,a6,p,f6,2d6,p,2a6,a6,a6,b6,c,",
"d,b6,a6,g6"
Scaricamento di file RTTTL: Altri file RTTTL sono disponibili per lo scaricamento da vari
siti del World Wide Web. Questi file sono contributi di entusiasti di suonerie, molti dei quail
non sono esperti di musica. Alcuni motivi di suonerie telefoniche sono molto buoni, altri
sono appena riconoscibili. Se volete scaricare ed eseguire un maggior numero di file
RTTTL, accertatevi di rimuovere tutti gli spazi che si trovassero fra i caratteri, e poi inserire i
flie di testo tra virgolette.
SOMMARIO
Questo capitolo ha introdotto tecniche per generare suoni e motivi musicali con il BASIC
Stamp e un altoparlante piezoelettrico. Per inviare ad un altoparlante piezoelettrico
segnali alto/basso che generino effetti sonori e/o note musicali si può utilizzare il
comando FREQOUT. Il comando FREQOUT ha argomenti che controllano il Pin I/O cui si
invia il segnale, la Durata del tono musicale, e la frequenza del tono (Freq1). Per suonare
due note contemporaneamente si può usare l’argomento opzionale Freq2.
Si possono realizzare effetti sonori regolando frequenza e durata dei toni e le pause tra
essi. Il valore della frequenza si può anche far variare in un intervallo di valori per creare
una varietà di effetti.
Fabbricare note musicali dipende anche da frequenza, durata, e pause. Il valore
dell’argomento Duration del comando FREQOUT è determinato dal tempo della canzone e
dalla durata della nota (intera, metà, un quarto, ecc.). Il valore Freq1 della nota è
determinato dalla lettera di nota e dalla sua ottava. Le pause fra le note sono utilizzate
per impostare la durata dei comandi PAUSE che le realizzano.
Con una sequenza di comandi FREQOUT si possono suonare semplici canzoni col BASIC
Stamp, ma esistono modi più efficienti per memorizzare e reperire dati musicali.
Le direttive DATA assieme con le loro etichette opzionali Symbol sono state utilizzate per
memorizzare valori byte senza alcun prefisso, e valori word usando il prefisso Word. Per
reperire valori memorizzati in direttive DATA è stato usato il comando READ. Negli esempi
di questo capitolo, l’argomento Location del comando READ ha utilizzato sempre
l’etichetta opzionale Symbol della direttiva DATA per differenziare i diversi tipi di dati.
Alcune etichette Symbol utilizzate sono state Note, Durate, Punti, ed Ottave.
I dati musicali possono essere memorizzati in formati presi a prestito essi stessi dalla
traduzione di spartiti musicali. I dati in stile spartito musicale possono poi essere
convertiti in frequenze con i comandi LOOKUP e LOOKDOWN. Si possono effettuare anche
operazioni matematiche su valori di variabili per cambiare l’ottava di una nota, dividendo
la sua frequenza per una potenza di due. Le operazioni matematiche sono utili anche per
determinare la durata di note o col tempo, oppure con la durata di una nota intera.
E’ stato introdotto il costrutto SELECT...CASE come modo per calcolare una variabile in
base al tipo di carattere. Il costrutto (o frase) SELECT...CASE è particolarmente utile per
esaminare caratteri o numeri quando ci sono molte scelte disponibili, come per esempio
quale potrebbe essere la variabile ospitante, e molti insiemi diversi di azioni che occorre
effettuare basandosi sul valore della variabile. Un programma che converte stringhe di
caratteri che descrivono motivi musicali da vecchi telefoni cellulari (detti file RTTTL) è
stato utilizzato per introdurre un programma più grande che fa uso di tutte le tecniche di
programmazione introdotte in questo testo. Il costrutto SELECT...CASE ha giocato un
ruolo di primo piano in questo programma perché è stato utilizzato per esaminare i
caratteri scelti entro un file RTTTL in base a un tipo di carattere.
Domande
1. Che cosa fa in modo che un suono venga riprodotto con tono alto? Che cosa fa
in modo che venga riprodotto con tono basso?
2. Che cosa fa il comando FREQOUT 15, 1000, 3000? Quale effetto ha ciascuno
dei numeri che contiene?
3. Come potete modificare il comando FREQOUT nella domanda 2 in modo che invii
due frequenze contemporaneamente?
4. Se premete un tasto B6 della tastiera di un pianoforte, quale frequenza invia?
5. Come potete modificare una direttiva DATA o un comando READ se volete
memorizzare e reperire valori word?
6. Potete avere più di una direttiva DATA? Se si, come potete dire ad un comando
READ di ottenere dati dall’una o dall’altra direttiva DATA?
7. Se conoscete la frequenza di una nota in una ottava, cosa dovete fare a quella
frequenza per suonarla nella ottava successiva più alta?
8. Che cosa fa il costrutto SELECT...CASE?
Esercizi
1. Modificate il motivo “Sveglia…” dal programma ToniAzione.bs2 in modo che
la frequenza del tono che suona aumenti di 500 ogni volta che il tono si ripete.
2. Spiegate come modificare MusicaConPiùCaratteristiche.bs2 in modo che
visualizzi un messaggio di attenzione nel terminale di Debug ogni volta che
viene suonata una nota puntata.
Progetti
1. Costruite un generatore di toni controllato da pulsanti. Se si preme un pulsante,
l’altoparlante deve emettere un bip da 2 kHz per 1/5 di secondo. Se si preme
l’altro pulsante l’altoparlante deve emettere un bip da 3 kHz per 1/10 di secondo.
Soluzioni
D1. Il nostro orecchio rileva cambiamenti della pressione dell’aria come toni. Un
tono alto viene da cambiamenti di pressione dell’aria più veloci, un tono basso
da cambiamenti di pressione dell’aria più lenti.
D2. FREQOUT 15, 1000, 3000 invia un segnale di 3000 Hz dal pin P15 per un
secondo (1000 ms). L’effetto di ciascun numero: 15 – pin I/O P15; 1000 – durata
del tono uguale a 1000 ms o un secondo; 3000 – la frequenza del tono, in hertz,
in modo che invii un tono da 3000 Hz.
D3. Usate l’argomento opzionale Freq2. Per eseguire 3000 Hz e ad esempio, 2000
Hz, aggiungiamo semplicemente la seconda frequenza al comando, dopo una
virgola:
FREQOUT 15, 1000, 3000, 2000
D4. 1975.5 Hz, vedi Figura 8-3 a pagina 270.
D5. Usate il modificatore opzionale Word prima di ciascun dato.
D6. Si. Ciascuna direttiva DATA può avere un diverso parametro opzionale Symbol.
Per specificare da quale direttiva DATA ottenere i dati, includere il parametro
Symbol dopo la parola chiave READ. Ad esempio: READ Note, LetteraNota.
In questo esempio, Note è il parametro Symbol della direttiva Data.
D7. Per ottenere una determinata nota nell’ottava superiore successiva, moltiplicate
la frequenza per due.
D8. SELECT...CASE sceglie una variabile o espressione, la vàluta in base al tipo di
carattere, ed esegue blocchi di codice differenti a seconda di quale tipo di
carattere è il valore della variabile.
E1. Questo problema può essere risolto o aumentando manualmente ciascun tono di
500, oppure utilizzando un ciclo FOR...NEXT con un valore STEP di 500.
Utilizzando il ciclo FOR...NEXT:
Aumentando il tono manualmente:
"Aumento
DEBUG "Aumento del tono di sveglia...",DEBUG
del
tono
CR
sveglia...",CR
PAUSE 100
PAUSE 100
FREQOUT 9, 500, 1500
FREQOUT 9, 500, frequenza
PAUSE 500
PAUSE 500
FREQOUT 9, 500, 2000
NEXT
PAUSE 500
FREQOUT 9, 500, 2500
PAUSE 500
FREQOUT 9, 500, 3000
PAUSE 500
di
E2. Modificate le righe che controllano la nota puntata:
Aggiungete un comando DEBUG alla IF...THEN. Non dimenticate la ENDIF.
IF PuntoNota = 1 THEN
DurataNota = DurataNota * 3 / 2
DEBUG "Nota puntata!", CR
ENDIF
P1. Usate il circuito dell’altoparlante piezo dalla Figura 8-2 a pagina 262; e i circuiti
del pulsante dalla Figura 4-26 a pagina 141.
' Che cos’è un
' P4 premuto:
'
' P3 premuto:
'
'{$STAMP BS2}
'{$PBASIC 2.5}
Microcontrollore - Cap8Prog01_GeneraTonoAPuls.bs2
bip a 2 kHz per 1/5 di secondo. 2 kHz = 2000 Hz.
1/5 s = 1000 / 5 ms = 200 ms
bip a 3 kHz per 1/10 di secondo. 3 kHz = 3000 Hz.
1/10 s = 1000 / 10 ms = 100 ms
DO
IF (IN4 = 1) THEN
FREQOUT 9, 200, 2000
FREQOUT 9, 100, 3000
ENDIF
LOOP
' 2000 Hz per 200 ms
' 3000 Hz per 100 ms
Costruire prototipi delle proprie invenzioni · Pagina 305
Capitolo 9: Mattoni (elementi di costruzione)
elettronici
QUEI PICCOLI CHIP NERI
Per trovare esempi di “quei piccoli chip neri” occorrerà solo guardare non più in là del
vostro BASIC Stamp (vedi Figura 9-1). Ciascuno di quei chip ha una funzione speciale. Il
chip in alto a destra è il regolatore di tensione. Questo chip prende la tensione della
batteria e la converte in quasi esattamente 5,0 V, ciò che occorre al resto dei componenti
del BASIC Stamp per funzionare correttamente. Il chip in alto a sinistra è la EEPROM
del modulo BASIC Stamp. I programmi PBASIC sono condensati in numeri detti token
(simboli), che vengono scaricati nel BASIC Stamp. Questi simboli sono memorizzati
nella EEPROM, e potete vederli cliccando Run e poi Memory Map nell’Editor del BASIC
Stamp. Il chip più grosso è detto Interpreter chip.(chip interprete). E’ un
microcontrollore pre-programmato con l’Interprete PBASIC, che va a prendere i simboli
dalla EEPROM e poi interpreta il comando PBASIC rappresentato da quel simbolo.
Quindi esegue il comando, va a prendere il successivo simbolo, e così via. Questo
processo è chiamato fetch and execute (vai a prendere ed esegui).
EEPROM da 2K
memorizza il codice
PBASIC e i dati registrati
→
Regolatore da
5V che
converte il
voltaggio di
input in 5 volt
regolati
←
Figura 9-1
Circuiti
Integrati del
BASIC
Stamp 2
Chip con l’interprete
PBASIC (un
microcontrollore preprogrammato)
→
Le persone parlano dei piccoli chip neri usando il termine “circuito integrato” (IC). Il
circuito integrato è in realtà un piccolo chip di silicio contenuto all’interno del
contenitore di plastica o ceramica nero. A seconda del chip, esso può avere un qualsiasi
numero di transistor tra centinaia e milioni . Un transistor è il mattone base dei circuiti
integrati, e in questo capitolo avrete l’opportunità di fare esperimenti con un transistor.
Altri componenti familiari progettati all’interno dei chip di silicio includono diodi,
resistenze e condensatori (capacità).
Pensate un momento alle attività che avete sperimentato in questo libro fino a questo
punto. L’elenco comprende: commutazione on e off di un LED, lettura di puilsanti,
controllo di servo, lettura di potenziometri, misura di luce, controlli di display, e
produzione di suoni. Sebbene questo sia solo l’inizio, è ancora molto emozionante,
specialmente se si considera che potete combinare queste attività per costruire dispositivi
più complessi. Il nocciolo del sistema che rende possibili tutte queste attività è costituito
soltanto dai tre circuiti integrati mostrati nella Figura 9-1 e da poche altre parti. Solo
questo evidenzia quanto potenti possano essere i circuiti integrati, quando sono progettati
per lavorare assieme.
ESPANDETE I VOSTRI PROGETTI CON CIRCUITI INTEGRATI
PERIFERICI
Esistono migliaia di circuiti integrati progettati per essere usati con i microcontrollori.
Talvolta i costruttori di circuiti integrati diversi fabbricano chip che eseguono la stessa
funzione. Talvolta le caratterisitiche di ciascun chip sono leggermente diverse, e altre
volte i chip sono quasi identici, ma uno può costare un pò meno dell’altro. Ciascuno
delle migliaia di circuiti integrati diversi può essere usato come mattone da costruzione
per molti progetti diversi. Le ditte produttrici pubblicano informazioni su come ciascun
circuito integrato lavori, in documenti chiamati datasheets (fogli di specifiche) e questi
fogli sono disponibili sui loro siti web. I costruttori pubblicano anche delle application
notes (note applicative), che illustrano come usare i loro circuiti integrati in modo unico o
utile, e ciò facilita il progetto di prodotti. I costruttori di circuiti integrati diffondono
queste informazioni sperando che gli ingegneri le useranno per incorporare i loro chip
negli ultimi giocattoli o applicazioni da avere ad ogni costo. Se vengono venduti migliaia
di giocattoli, la ditta vende migliaia dei loro circuiti integrati.
In questo capitolo, farete esperimenti con un transistor e un circuiti integrato di uso
speciale, detto potenziometro digitale. Come ricordato prima, il transistor è il mattone
base dei circuiti integrati. È, inoltre, un mattone base anche per una gran quantità di altri
circuiti. Anche il potenziometro digitale ha una gran varietà di utilizzi. Tenete a mente
che per ciascuna attività svolta finora, esistono probabilmente centinaia di modi diversi in
cui potreste usare questi circuiti integrati.
ATTIVITÀ #1: CONTROLLO DEL FLUSSO DI CORRENTE CON UN
TRANSISTOR
In qusta attività, userete un transistor per controllare la corrente che passa attraverso un
LED. Potrete usare il LED per controllare la corrente, poichè esso brilla più
intensamente quando lo attraversa una corrente grande, e meno intensamente quando una
corrente minore lo attraversa.
Introduzione del transistor
La Figura 9-2 mostra il simbolo schematico e il disegno di parte del transistor 2N3904.
Esistono molti tipi diversi di transistor. Questo è chiamato NPN, con riferimento al tipo
di materiali usati per costruire il transistor e al modo in cui questi materiali sono
incorporati nel silicio. Il modo migliore di iniziare a pensare a un transistor è di
immaginarlo come una valvola usata per controllare la corrente. Transistor differenti
controllano quanta corrente li attraversa con differenti mezzi. Questo transistor controlla
quanta corrente passa entro C (collettore) e fuori da E (emettitore). Esso usa la quantità
di corrente che può attraversare il terminale B (base) per controllare la corrente che passa
da C verso E. Con una piccolissima quantità di corrente permessa in B, un flusso di
corrente circa 416 volte tale quantità fluisce attraverso il transistor entro C e fuori da E.
C
C
B
E
Figura 9-2
Transistor 2N3904
B
2N3904
E
Il foglio di specifiche di parte del 2N3904: Come ricordato prima, i fabbricanti di
semiconduttori pubblicano documenti chiamati fogli di specifiche (datasheet) per le parti che
fabbricano. Questi fogli di specifiche contengono informazioni usate dagli ingegneri per
progettare l’inserimento della parte in un prodotto. Per vedere un esempio di foglio di
specifiche per il 2N3904: collegatevi al sito www.fairchildsemi.com. Digitate “2N3904” nel
campo Search sulla “home page” della Fairchild Semiconductor, e cliccate Go. Uno dei
risultati della ricerca dovrebbe essere un link alla informazione di prodotto del 2N3904.
Seguitelo e cercate il link al Datasheet. Molti browser per web visualizzano il datasheet
aprendolo con Adobe Acrobat Reader.
Parti per l’esempio del transistor
(1) Transistor – 2N3904
(2) Resistenze – 100 kΩ (marrone-nero-giallo)
Costruzione e prova del circuito del transistor
La Figura 9-3 mostra un circuito usabile per controllare manualmente quanta corrente il
transistor fa passare nel LED. Ruotando la manopola del potenziometro, il circuito
rilascerà quantità diverse di corrente al terminale base del transistor. Questo modificherà
la quantità di corrente che il transistor fa passare dal suo collettore al suo emettitore. Il
LED darà una indicazione chiara della modifica brillando più o meno intensamente.
o Assicuratevi che il pin anodo del LED (più lungo) sia connesso a Vdd.
o Controllate due volte il circuito del transistor. Notate che la parte piatta
del transistor è rivolta verso destra nel diagramma di cablaggio.
 Ruotate la manopola del potenziometro e verificate che il LED cambi intensità di
illuminazione in risposta al cambiamento di posizione del terminale mobile del
potenziometro.
Vdd
Vdd
LED
100 k
POT
10 k
Figura 9-3
Circuito con
transistor a
controllo
manuale con
potenziometro
100 k
Vss
Vss
Il vostro turno – Commutazione On/Off del transistor
Se volete soltanto commutare un transistor on ed off, potete usare il circuito mostrato in
Figura 9-4. Quando il BASIC Stamp invia un segnale alto a questo circuito, il transistor
conduce tanta corrente quanta ne passerebbe se aveste regolato il potenziometro per la
massima brillanza del LED. Quando il BASIC Stamp invia un segnale basso a questo
circuito, il transistor smetterà di condurre corrente, e il LED non emetterà alcuna luce.
Qual’è la differenza tra quanto detto e la connessione di un circuito LED a un pin I/O?
I pin I/O del BASIC Stamp limitano quanta corrente devono rilasciare. I transistor hanno
anch’essi delle limitazioni, ma queste sono molto più alte .Nel manuale Process Control
Student Guide, un transistor viene utilizzato per pilotare un piccolo ventilatore a corrente
continua (DC). È utilizzato anche per fornire grandi quantitativi di corrente a una piccola
resistenza utilizzata come elemento riscaldatore. Ciascuna di queste due applicazioni
condurrebbe una tale quantità di corrente da danneggiare rapidamente il BASIC Stamp, ma
il transistor può sopportarla tranquillamente .
 Scrivete un programma che invii segnali alto e basso a P8 due volte al secondo.
SUGGERIMENTO: il programma LedAccesoSpento.bs2 a pagina 45 deve
essere modificato solo per mandare segnali alto/basso a P8 invece che a P14.
Ricordatevi di memorizzarlo con un altro nome prima di fare le modifiche.
 Eseguite il programma e verificate che dà il controllo acceso/spento del LED.
Vdd
Vdd
X3
LED
P8
100 k
100 k
Vss
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vin
Vss
Figura 9-4
Circuito che
da al BASIC
Stamp il
controllo di
corrente
acceso/spento
di un LED
tramite un
transistor
ATTIVITÀ #2: INTRODUZIONE DEL POTENZIOMETRO DIGITALE
In questa attività, rimpiazzerete il potenzionmetro a regolazione manuale con un
potenziometro a circuito integrato regolato in modo digitale. Programmerete poi il
BASIC Stamp per regolare il potenziometro digitale, che regolerà a sua volta la
luminosità del LED allo stesso modo in cui lo faceva il potenziometro manuale della
attività precedente.
Introduzione al potenziometro digitale
La Figura 9-5 mostra una mappa dei pin del potenziometro digitale che userete in questa
attività. Questo chip ha 8 pin, quattro su ciascun lato, spaziati in modo da facilitare il suo
inserimento in una breadboard (separazione tra i pin: 1/10 di pollice). Il costruttore ha
posto un incavo di riferimento sull’involucro plastico in modo che possiate distinguere tra
pin 1 e pin 5. L’incavo di riferimento è un piccolo semicerchio nell’involucro del chip.
Potete usare questo incavo come riferimento dei numeri di pin sul chip. I numeri di pin
sul chip si contano dall’alto, in senso antiorario a partire dall’incavo di riferimento.
Sostituzioni della parte: A volte è necessario per la Parallax sostituire una parte (o
componente). La parte (nuova) funzionerà allo stesso modo della vecchia, ma l’etichetta su
di essa può essere diversa. Se trovate che il potenziometro digitale incluso nel vostro Kit di
parti di “What’s a Microcontroller” non è etichettato AD5220, è assicurato che esso lavorerà
ancora allo stesso modo ed effettuerà correttamente questa attività.
Incavo (tacca)
di riferimento
Figura 9-5
Mappa dei pin del AD5220
1 CLK
Vdd 8
2 U/D
CS 7
3 A1
B1 6
4 GND
W1 5
Usate l’incavo di riferimento per
accertarvi che il chip AD5220 sia col
suo lato destro in alto quando lo
inserite nel vostro circuito sulla
breadboard.
AD5220
Ecco un sommario di ciascuno dei pin dell‘AD5220 e delle sue funzioni:
1. CLK: pin che riceve gli impulsi di clock (segnali basso-alto-basso) per muovere
il terminale mobile (del potenziometro).
2. U/D: pin che riceve un segnale alto per far muovere il terminale mobile (W1) in
avanti verso A1, o un segnale basso per farlo muovere verso B1. Questo pin
imposta soltanto la direzione: il terminale mobile non si muove davvero fin
quando un impulso (un segnale basso – alto – basso) è inviato al pin CLK.
3. A1: terminale A del potenziometro.
4. GND: connessione di massa. La massa, sia sulla scheda Board of Education che
sula scheda BASIC Stamp HomeWork Board, è il terminale Vss.
5. W1: terminale mobile (W) del potenziometro.
6. B1: terminale B del potenziometro.
7. CS: pin di selezione del chip. Applicate un segnale alto a questo pin, e il chip
ignora tutti i segnali di controllo inviati ai pin CLK e U/D. Applicate un segnale
basso a questo pin, ed esso fa agire tutti i segnali di controllo che riceve.
8. Vdd: connettere questo pin a +5 V, che è Vdd sia sulle schede Board of
Education che sulle BASIC Stamp HomeWork Board.
Il foglio specifiche (Datasheet) di parte del AD5220: Per vedere il foglio specifiche di
parte per il chip AD5220: andate al sito www.analog.com. Inserite “AD5220” nel campo
Search della home page dei Dispositivi Analogici (Analog Devices), e cliccate sul pulsante
Search. Cliccate il link al Data Sheet. Cliccate il link che porta la scritta “AD5220:
Increment/Decrement Digital Potentiometer Datasheet”.
Parti del transistor controllato dal pot digitale
(1) Transistor – 2N3904
(2) Resistenze – 100 kΩ (marrone-nero-giallo)
(1) Potenziometro digitale – AD5220
Costruzione del circuito con il potenziomentro digitale
La Figura 9-6 mostra lo schema di un circuito con il potenziometro digitale usato al posto
di un potenziometro a comando manuale, e la Figura 9-7 mostra il diagramma di
cablaggio del circuito. Il BASIC Stamp può controllare il potenziometro digitale
inviando segnali di controllo ai pin P5 e P6.
Vdd
Vdd
Vdd
AD5220
P6
1
CLK
Vdd 8
P5
2
U/D
CS 7
3
A1
B1 6
4
GND
W1 5
Figura 9-6
Schema circuitale
del transistor
controllato dal
potenziometro
digitale
100 k
100 k
Vss
Vss
Vdd
Vin
Vss
X3
Figura 9-7
Diagramma di
cablaggio per la
Figura 9-6
AD5220
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Programmazione del controllo tramite potenziometro digitale
Immaginate che la manopola sul potenziometro manuale dell’esercizio precedente abbia
128 posizioni. Immaginate inoltre che il potenziometro sia a metà del suo intervallo di
movimento. Ciò significa che potete ruotare la manopola di 63 passi in una direzione e di
64 passi nell’altra direzione.
Diciamo che ruotate il potenziometro di un passo in senso orario. Il LED diventerà
appena leggermente più brillante. Sarebbe la stessa cosa inviare un segnale alto al pin
U/D dell’AD5220 e inviare un impulso (alto-basso-alto) al pin CLK.
HIGH 5
PULSOUT 6, 1
Immaginate quindi di ruotare il vostro potenziometro manuale di 3 passi in senso
antiorario. Il LED diventerà appena appena meno brillante. Sarebbe lo stesso inviare un
segnale basso al pin U/D sul AD5220 e inviare tre impulsi al pin CLK.
LOW 5
PULSOUT 6, 1
PAUSE 1
NEXT
Immaginate poi di ruotare il potenziometro completamente in senso orario. Sarebbe lo
stesso che inviare un segnale alto al pin U/D dell’AD5220 ed inviare 65 impulsi al pin
CLK. Ora il LED dovrebbe essere molto brillante.
HIGH 5
PULSOUT 6, 1
PAUSE 1
NEXT
Infine, immaginate di ruotare il vostro potenziometro manuale completamente in senso
antiorario. Il LED non dovrebbe emettere alcuna luce. Sarebbe lo stesso che inviare un
segnale basso al pin U/D, ed applicare 128 impulsi al pin CLK
LOW 5
PULSOUT 6, 1
PAUSE 1
NEXT
Programma esempio: PotDigitaleSuGiu.bs2
Questo programma esempio regola il potenziometro su e giù, da una estremità del suo
intervallo all’altra, facendo sì che il LED diventi gradualmente più brillante, poi
gradualmente meno brillante.
 Digitate ed eseguite PotDigitaleSuGiu.bs2.
' Che cos'è un Microcontrollore - PotDigitaleSuGiu.bs2
' Fa variare il pot digitale pot nel suo intervallo di valori.
' {$STAMP BS2}
' {$PBASIC 2.5}
contatore
VAR
Byte
DO
LOW 5
PULSOUT 6, 1
PAUSE 10
NEXT
HIGH 5
PULSOUT 6, 1
PAUSE 10
NEXT
LOOP
Il vostro turno – Cambiare il ritmo di ripetizione e condensare il codice
Potete aumentare o diminuire il ritmo di ripetizione al quale il LED diventa più o meno
luminoso cambiando l’argomento Duration (Durata) del comando PAUSE.
 Modificate e rieseguite il programma usando PAUSE 20 e notate la differenza nel
ritmo di ripetizione al quale il LED diventa più o meno luminoso.
 Ripetere con PAUSE 5.
Per semplificare questo programma, potete anche utilizzare un comando detto TOGGLE . Il
comando TOGGLE cambia lo stato di un pin I/O del BASIC Stamp. Se il pin I/O stava
inviando un segnale alto, TOGGLE gli fa inviare un segnale basso. Se il pin I/O stava
inviando un segnale basso, TOGGLE gli fa inviare un segnale alto l.
 Memorizzate PotDigitaleSuGiu.bs2 come PotDigitaleSuGiuConToggle.bs2.
 Modificate il programma in modo che sia il programma riportato qui sotto.
 Eseguite il programma e verificate che funzioni allo stesso modo di
PotDigitaleSuGiu.bs2.
 Confroontate il numero di righe di codice che impiega per fare lo stesso lavoro.
Eseguire un programma fuori dalla memoria di programma è un problema che alcune
persone incontrano quando i loro progetti BASIC Stamp diventano più grossi e complicati.
Usare TOGGLE invece di due cicli FOR...NEXT è proprio un esempio, fra molte tecniche
impiegabili, di come fare lo stesso lavoro con metà del codice.
' Che cos'è un Microcontrollore - PotDigitaleSuGiuConToggle.bs2
' Commuta il pot digitale attraverso i suoi valori.
' {$STAMP BS2}
' {$PBASIC 2.5}
contatore
LOW 5
VAR
Byte
DO
PULSOUT 6,5
PAUSE 10
NEXT
TOGGLE 5
LOOP
Guardando il potenziometro digitale al suo interno
La Figura 9-8 mostra un diagramma dell’interno del potenziometro AD5220. L’integrato
AD5220 ha 128 elementi resistivi (resistenze), ciascuno dei quali è di 78,125 Ω (valore
nominale). Questi 128 elementi danno, in complesso, un totale di 10.000 Ω o 10 kΩ.
3
A1
Ad5220
78 
pos. 127
1 CLK
2 U/D
5
7 CS
78 
pos. 126
W1
40 
78 
pos. 125
…
Figura 9-8
Dentro l’AD5220
…
78 
pos. 1
78 
B1
pos. 0
6
Un valore nominale significa un valore scritto sul componente. Le parti come
resistenze e condensatori hanno, di solito, un valore nominale e una tolleranza. Ciascuno
degli elementi resistivi dell‘AD5220 ha un valore nominale di 78,125 , con una tolleranza
del 30% (23,438 ) sopra o sotto il valore nominale.
Tra ogni paio di questi elementi resistivi c’è un interruttore, chiamato presa. Ciascun
interruttore è in realtà un transistor commutato on oppure off per lasciare o non lasciar
passare corrente. Uno solo di questi interruttori per volta può essere chiuso. Se si chiude
uno degli interruttori superiori (come le pos. 125, 126, o 127), è come avere la manopola
del potenziometro manuale girata quasi tutta o completamente in senso orario. Se
vengono chiuse la pos. 0 o la 1, è come avere il potenziometro manuale ruotato quasi
tutto o completamente in senso antiorario.
Immaginate che sia chiusa la Pos. 126. Se volete porre la presa a 125, (aprire la pos. 126
e chiudere la pos. 125), impostate U/D basso, poi inviate un impulso a CLK. Se volete
porre la presa alla Pos 127, impostate U/D alto e fornite 2 impulsi. Se volete portare la
presa in basso a 1, impostate U/D basso e inviate 126 impulsi.
Il programma esempio che segue usa il terminale di Debug per chiedere quale
impostazione di presa volete. Poi decide se impostare il pin U/D alto o basso, e applica il
numero di impulsi corretto per portare la presa dalla sua vecchia impostazione alla nuova.
Ad eccezione dei dati EEPROM, il programma esempio che segue ha anche tutte le
sezioni che vi aspettereste di trovare normalmente in un programma applicativo:








Titolo – commenti che includono il nome del programma, la sua descrizione, e le
direttive Stamp e PBASIC
Dati EEPROM – dichiarazioni DATA che memorizzano elenchi di valori
predefiniti in porzioni della memoria EEPROM non necessarie alla
memorizzazione del programma
Definizioni I/O – direttive PIN che nominano pin I/O
Costanti – dichiarazioni CON che nominano valori presenti nel programma
Variabili – dichiarazioni VAR che assegnano nomi alle porzioni di memoria RAM
del BASIC Stamp per memorizzare valori
Inizializzazione – routine che fa partire il programma col piede giusto. In questo
programma, la presa del potenziometro dev’essere portata giù fino a zero
Main – routine che gestisce il lavoro principale che il programma deve fare
Subroutine – segmenti di codice che fanno lavori specifici, sia tra loro che, in
questo caso, per la routine main (principale)
Programma esempio: PotDigitaleControllatoDaTerminale.bs2
Potete usare questo programma esempio e il terminale di Debug per impostare la presa
del potenziometro digitale. Cambiando l’impostazione della presa del potenziometro
digitale, cambiate la luminosità del LED connesso al transistor controllato dal
potenziometro digitale. La Figura 9-9 mostra un esempio in cui si digita il valore 120
nella finestrella di trasmissione del terminale di Debug mentre il programma è in
esecuzione. Poiché l’impostazione originaria della presa era 65, il LED diventa quasi due
volte più luminoso quando la presa viene regolata a 120.
Figura 9-9
Invio di messaggi
al BASIC Stamp
Finestrelle di
Trasmissione →
L’impostazione della presa è: 65
Ricezione →
Digitate la nuova impostazione
(da 0 a 127): 120
Cliccate la
finestrella di
trasmissione
(superiore) e
digitate il numero
della nuova
impostazione di
presa.
 Digitate ed eseguite PotDigtialeControllatoDaTerminale.bs2.
 Assicuratevi che la casella Echo Off sia vuota (nessun segno di spunta).
 Cliccate sulla finestrella di trasmissione del terminale di Debug per posizionare
il cursore su di essa.
 Digitate nel terminale di Debug valori tra 0 e 127. Accertatevi di premere il
tasto Invio (enter) dopo aver digitato le cifre.
'
'
'
'
-----[ Titolo ]---------------------------------------------------------Che cos'è un Microcontrollore – PotDigitaleControllatoDaTerminale.bs2
Aggiorna il valore di presa del pot digitale in base a input di utente sul
terminale di Debug.
' {$STAMP BS2}
' {$PBASIC 2.5}
' -----[ Dati in EEPROM ]--------------------------------------------------
' -----[ Definizioni I/O ]------------------------------------------------PinUd
PinClk
PIN
PIN
5
6
' Imposta valori dei pin I/O
' connessi a CLK e U/D.
' -----[ Constants ]------------------------------------------------------RitardoImpulsi
RitardoLettore
CON
CON
10
2000
' Ritardo per osservare il calo
' di luce del LED
' -----[ Variabili ]------------------------------------------------------contatore
ImpostazVecchiaPresa
ImpostazNuovaPresa
VAR
VAR
VAR
Byte
Byte
Byte
' Contatore per FOR...NEXT.
' Precedente impostazione presa.
' Nuova impostazione presa.
' -----[ Inizializzazione ]-----------------------------------------------ImpostazVecchiaPresa = 0
ImpostazNuovaPresa = 0
' Inizializza a zero la vecchia
' e la nuova impostazione presa.
LOW PinUd
PULSOUT 6,5
PAUSE 1
NEXT
PAUSE 1000
' Imposta pin U/D per basso.
' Imposta presa a posizione minima.
' Aspetta 1 s prima del primo messaggio
' -----[ Routine Main]----------------------------------------------------
DO
GOSUB Imposta_Nuova_Presa
GOSUB Imposta_Pin_Ud
GOSUB Impulsi_pin_Clk
' Visualizza utente e ottiene input.
' Imposta pin U/D per alto/basso.
' Rilascia impulsi.
LOOP
' -----[ Subroutine ]-----------------------------------------------------Imposta_Nuova_Presa:
' Visualizza istruzioni e ottiene
' input da utente per nuovo valore
DEBUG CLS, "La impostazione della presa è: ",
' impostazione presa.
DEC ImpostazNuovaPresa, CR, CR
DEBUG "Digitate la nuova ", CR, "impostazione (da 0 a 127): "
DEBUGIN DEC ImpostazNuovaPresa
RETURN
Imposta_Pin_Ud:
' Esamina nuovo e vecchio valore presa
' per decidere valore del pin U/D.
IF ImpostazNuovaPresa > ImpostazVecchiaPresa THEN
' Notifica ad utente se i valori sono
HIGH PinUd
' uquali.
ImpostazVecchiaPresa = ImpostazVecchiaPresa + 1
' Incrementa Impulsi_pin_Clk.
ELSEIF ImpostazNuovaPresa < ImpostazVecchiaPresa THEN
LOW PinUd
ImpostazVecchiaPresa = ImpostazVecchiaPresa - 1
' Decrementa Impulsi_pin_Clk.
ELSE
DEBUG CR, "La nuova e la vecchia impostazione", CR,
"sono uguali, prova ", CR,
"di nuovo...", CR
PAUSE RitardoLettore
' Da al lettore il tempo
ENDIF
' per vedere il messaggio.
RETURN
Impulsi_pin_Clk:
'
'
'
'
Rilascia impulse da vecchio a nuovo valore. Rammentate che Imposta_Pin_Ud
ha regolato il valore di ImpostazVecchiaPresa al valore ImpostazNuovaPresa
più 1. Questo evita che il ciclo FOR...NEXT sia eseguito una volta di
troppo.
FOR contatore = ImpostazVecchiaPresa TO ImpostazNuovaPresa
PULSOUT PinClk, 1
PAUSE RitardoImpulsi
NEXT
ImpostazVecchiaPresa = ImpostazNuovaPresa
' Tiene traccia dei valori
' di impostazione presa vecchi e nuovo.
RETURN
SOMMARIO
Questo capitolo ha introdotto i circuiti integrati e il modo in cui si possono usare col
BASIC Stamp. È stato usato un transistor come valvola regolatrice di corrente, ed un
potenziometro digitale per controllare la quantità di corrente che attraversa il transistor.
Si sono esaminati la tacca di riferimento e la mappa dei pin del potenziometro digitale
introdotto, come elementi importanti dei chip elettronici. È stata discussa la funzione di
ciascun pin del potenziometro digitale, e analogamente la struttura interna del dispositivo.
È stato introdotto anche il comando PBASIC TOGGLE come mezzo per risparmiare
memoria di programma.
Domande
1. Quali sono i nomi dei terminali del transistor che avete usato in questo capitolo?
2. Quale terminale controlla la corrente che passa nel transistor?
3. Che cosa potete fare per aumentare o diminuire la corrente che passa nel
transistor?
Esercizio
1. Scrivete un programma che regoli la presa del potenziometro digitale alla
posizione 0 indipendentemente dalla sua impostazione di corrente.
Progetto - Sfida avanzata
1. Aggiungete un fototransistor al vostro progetto e fate in modo che la luminosità
del LED regoli la luminosità vista dal fototransistor. Notate che la soluzione data
è degna di essere letta, poichè mostra un approccio utile a riportare in scala un
input ad un altro output.
Soluzioni
D1. Emettitore, base, e collettore.
D2. La base controlla la corrente che passa attraverso il transistor.
D3. Aumentate o diminuite la corrente consentita nella base del transistor.
E1. Per risolvere questo esercizio, guardate PotDigitaleControllatoDaTerminale.bs2.
La prima cosa che fa, nella sezione Inizializzazione, è di impostare la presa alla
posizione più bassa. Proprio il suo codice è stato usato nella soluzione qui sotto.
' Che cos'è un Microcontrollore - Cap9Es01_ImpostaPresaAZero.bs2
' Ruota la presa sul pot digitale completamente in giù a zero
' {$STAMP BS2}
' {$PBASIC 2.5}
DEBUG "Programms in esecuzione!"
PinUd
PinClk
contatore
PIN
PIN
VAR
5
6
Byte
LOW PinUd
PULSOUT PinClk,5
PAUSE 1
NEXT
' Contatore per FOR...NEXT.
' Pone pin U/D for a Basso.
' Imposta presa alla sua
' posizione più bassa.
P1. Usate il circuito del potenziometro digitale dalla Figura 9-6 a pagina 312 e il
circuito del fototransistor dalla Figura 7-4 a pagina 214.
Questa soluzione si basa su PotDigitaleControllatoDaTerminale.bs2, e incorpora
elementi da FototransistorAnalogicoABinario.bs2 dal Capitolo 7, Attività #5. È
anche applicata un pò di algebra per risolvere un problema di scalatura che adatta
l’intervallo di valori ottenibili dalla misura di RCTIME del fototransistor, a un
intervallo da 0 a 128 per il potenziometro digitale . Tenete a mente che questa è
una soluzione esempio e non è affatto l’unica soluzione o approccio al problema.
La chiamata di subroutine GOSUB Imposta_Nuova_Presa del programma
PotDigitaleControllatoDaTerminale.bs2 è sostituita da altre due chiamate di
subroutine: GOSUB Leggi_Fototransistor e GOSUB Scala_Fototransistor.
Analogamente, la subroutine Imposta_Nuova_Presa è sostituita dalle
Leggi_Fototransistor
e
Scala_Fototransistor.
subroutine
Leggi_Fototransistor è una versione subroutine dei comandi che prendono
la misura di RCTIME del fototransistor e limitano l’intervallo dei suoi valori di
ingresso in FototransistorAnalogicoABinario.bs2. I nomi dei pin, delle costanti
e delle variabili sono stati modificati e, per una visualizzazione di 10-volte-persecondo, il commando PAUSE 100 è stato modificato in PAUSE 1, che è tutto
quanto occorre per caricare il condensatore prima di prendere la misura RCTIME.
Appena questa subroutine avrà memorizzato un valore nella variabile
LetturaLuce, questo sarà compreso tra ValMin (100) e ValMax (4000).
Accertatevi di provare e modificare questi valori per adattarli alle vostre
condizioni di illuminazione.
Il problema che abbiamo adesso è che ci sono soltanto 128 impostazioni di presa,
e 3900 misure possibili per il RCTIME del fototransistor. Per correggere questa
differenza ci occorre dividere la misura RCTIME del fototransistor per un qualche
valore, in modo da adattarla all’intervallo tra 0 e 127. Quindi, sappiano che
occorre dividere l’intervallo dei valori di input per un qualche valore in modo da
farlo cadere nei 128 valori. Si produce un’equazione come questa :
Intervallo Possibii Misure Fototransistor
────────────────────────── = 128 PosizioniPresaPossibili
DivisoreScala
Per risolvere questa equazione, moltiplicate entrambi i lati dell’equazione per
DivisoreScala, e poi dividete entrambi i membri per 128 PosizioniPresaPossibili.
Nel codice, l’intervallo di misure possibili per il fototransistor è ValMax –
ValMin, DivisoreScala è una variabile, e 128 è una costante. Quindi, questo
codice dalla sezione Dichiarazioni e Inizializzazione potrà prevedere un valore di
DivisoreScala del tipo:
DivisoreScala = (valMax – valMin) / 128
Dopo
ciascuna misura RCTIME del fototransistor, la subroutine
Scala_Fototransistor sottrae valMin da LetturaLuce e poi divide la misura
per DivisoreScala. Il risultato accorda l’intervallo di misure di input da 100 a
4000 all’intervallo delle impostazioni della presa di uscita da 0 a 127.
Scala_Fototransistor:
LetturaLuce = (LetturaLuce – valMin) / DivisoreScala
RETURN
Assumendo che ValMin sia 100 e ValMax sia 4000, la variabile LetturaLuce
potrebbe memorizzare 3900 valori possibili. Cosa accadrebbe se l’intervallo di
input fosse da ValMin = 10.000 a ValMax = 13.900? Quando sottraete
ValMin = 10.000, ci sono ancora 3900 valori possibili, e dividendoli per
DivisoreScala la misura si adatterebbe in modo corretto alla corrispondente
impostazione di presa del pot digitale Se il vostro codice non avesse come
prima cosa sottratto ValMin, il valore scalato risultante sarebbe completamente
fuori dell’intervallo da 0 a 128 per il pot digitale.
'
'
'
'
'
'
Che cos'è un Microcontrollore Cap09Pr01_PotDigitaleFotoControllato.bs2
Aggiorna la presa di un pot digitale in base a lettura di un
fototransistor
{$STAMP BS2}
{$PBASIC 2.5}
' -----[ Dichiarazioni
PinUd
PIN
PinClk
PIN
PinFoto
PIN
RitardoImpulsi CON
RitardoLettore CON
valMax
CON
valMin
CON
contatore
VAR
ImpostazVecchiaPresa
ImpostazNuovaPresa
LetturaLuce
VAR
DivisoreScala VAR
e Inizializzazione]----------------------------5
6
2
' Fototransistor su pin P2
10
' Ritardo per oaservare il
2000
' calo di luce del LED
4000
' Max val del fototransistor
100
' Min val del fototransistor
Byte
VAR
VAR
Word
Word
Byte
Byte
'
'
'
'
'
Contatore per ciclo FOR...NEXT.
Precedente impostazione presa.
Nuova impostazione presa.
lettura dal fototransistor
Per scalare valori
' Imposta un valore che può dividere misura RCTIME del fototransistor
' per scalarla ad un intervallo tra 0 e 128
DivisoreScala = (valMax - valMin) / 128
ImpostazVecchiaPresa = 0
ImpostazNuovaPresa = 0
' Inizializza a zero i valori vecchio
' e nuovo di impostazione presa.
LOW PinUd
PULSOUT PinClk,5
PAUSE 1
NEXT
' Imposta pin U/D a basso.
' Imposta presa alla posizione minima.
PAUSE 1000
' 1 sec. prima del 1° messaggio
' -----[ Routine Main]-----------------------------------------------DO
GOSUB Leggi_Fototransistor
GOSUB Scala_Fototransistor
ImpostazNuova Presa = LetturaLuce MIN 1 MAX 127
DEBUG HOME, DEC5 LetturaLuce
GOSUB Imposta_Pin_Ud
' Imposta pin U/D pin per alto/basso.
GOSUB Impulso_pin_Clk
' Eilascia impulsi.
LOOP
' -----[ Subroutine ]------------------------------------------------Imposta_Pin_Ud:
' Esamina valori di presa
IF ImpostazNuovaPresa > ImpostazVecchiaPresa THEN
' nuovo e vecchio per decidere
HIGH PinUd
ELSEIF ImpostazNuovaPresa < ImpostazVecchiaPresa THEN
' il valore di PinUd. Notifica
LOW PinUd
' a utente se i valori sono
ENDIF
' uguali.
RETURN
Impulso_pin_Clk:
' Rilascia impulsi da valori
FOR contatore = ImpostazVecchiaPresa TO ImpostazNuovaPresa
' vecchio o nuovo.
PULSOUT PinClk, 1
PAUSE RitardoImpulsi
NEXT
ImpostazVecchiaPresa = ImpostazNuovaPresa ' Tiene traccia dei valori
RETURN
' nuovo e vecchio di impostaz. presa.
Leggi_Fototransistor:
HIGH PinFoto
PAUSE 1
RCTIME PinFoto, 1, LetturaLuce
LetturaLuce = LetturaLuce MAX valMax MIN valMin
RETURN
Scala_Fototransistor:
LetturaLuce = (LetturaLuce - valMin) / DivisoreScala
RETURN
Capitolo 10: Costruire prototipi delle proprie
Invenzioni
Questo testo ha introdotto i principi base per integrare un computer in progetti ed
invenzioni. Ingredienti di un comune circuito in prodotti di uso quotidiano, con i quali
ora avete un po’ di esperienza, includono: luci indicatrici, pulsanti, servo, quadranti a
disco, visualizzatori digitali, sensori di luce, altoparlanti, transistor, e altri circuiti
integrati. Adesso avete anche fatto l’esperienza di connettere questi circuiti ad un
microcontrollore BASIC Stamp e potete scrivere codice sia per provarli, sia per integrarli
in piccole applicazioni.
A questo punto, sarete interessati a impiegare le vostre nuove capacità per inventare
qualcosa, o per imparare di più, o forse per entrambe le cose. Quel che avete imparato in
questo libro può portarvi ben avanti sulla strada del fabbricare prototipi di un gran
numero di invenzioni diverse. In questo capitolo, userete un sistema di micro allarme
come esempio di prototipo di un dispositivo molto familiare. Lungo la strada,
adopererete alcune importanti tecniche e abitudini di prototipizzazione, che includono:







Suggerimenti per un rapido sviluppo delle vostre idee di progetto e invenzioni
Un esempio di come costruire e provare ciascun sotto-sistema del prototipo
Esempi di come incorporare codice di prova nel codice del vostro progetto
Buone pratiche per commentare il codice e le varie versioni di file
Esempi di uso di parti familiari, come sostituti di dispositivi con interfacce simili
Suggerimenti e trucchi per superare progetti precedenti
Dove reperire in seguito più progetti Stamps in Class e dispositivi interessanti
APPLICARE LE PROPRIE CONOSCENZE AD ALTRE PARTI E
COMPONENTI
Il circuito di un pulsante dall’attività 1 del capitolo 3 è un esempio di semplicissimo
dispositivo di input che converte una condizione fisica (se qualcuno ha premuto un
pulsante o no) in un segnale alto o basso rilevabile ed elaborabile dal BASIC Stamp.
Avete usato i pulsanti anche in applicazioni che controllavano il lampeggiare di una luce,
le posizioni di un servo e i toni di un altoparlante. Ci sono molti sensori che rilevano una
condizione fisica diversa dal “contatto” e che inviano inoltre segnali alti e bassi
monitorabili da un pin I/O del BASIC Stamp. Alcuni esempi comprendono sensori di
gas, di moto, e suoni, e ne esistono molti, molti altri ancora. Poiché adesso avete
esperienza del far controllare al BASIC Stamp il circuito di un pulsante, controllare un
suono o un sensore di movimento è cosa molto simile, e certamente un passo successivo
ragionevole .
Un’altra tecnica presente in questo manuale è la misura del decadimento RC con il
comando RCTIME, per rilevare la posizione della manopola di un potenziometro e i livelli
di luce con un fototransistor ed un LED assieme. Questi esempi sono proprio la punta di
un iceberg in termini di sensori usabili in un circuito di decadimento RC. Altri esempi
comprendono umidità, temperatura, e pressione, e questo è ancora soltanto il principio.
La luce di un indicatore LED fornisce ancora un altro esempio di circuito rappresentativo
di una gamma di circuiti con funzioni molto diverse. Il circuito a LED è controllato
dall’uscita alta/bassa di un pin I/O del BASIC Stamp. Con circuiti aggiuntivi di supporto,
potete usare segnali alto/basso per muovere motori elettrici in avanti e indietro,
accendere/spegnere luci, accendere/spegnere elementi riscaldatori, ed altro.
Ora, pensate a tutti gli altri dispositivi che avete sperimentato in questo manuale.
Ciascuno di essi è solo un esempio in un elenco di dispositivi con interfacce simili usabili
per realizzare prototipi di ogni tipo di invenzioni.
REALIZZARE IL PROTOTIPO DI UN MICROSISTEMA ANTIFURTO
In questo capitolo, useremo parti del kit “What’s a Microcontroller” (“Che cos’è un
microcontrollore”) per realizzare il prototipo di un piccolissimo sistema antifurto che
potreste utilizzare in un tavolo, un cassettone, una cassetta degli attrezzi, o in uno
stanzino. Potrebbe essere utile a coloro, fratellastri o colleghi, sospettati di prendere a
prestito il vostro materiale senza chiedere il permesso. Con questo prototipo,
investigheremo anche su altre parti e componenti che potrete incorporare nel vostro
sistema antifurto, per farlo funzionare con gli stessi principi delle parti di kit che vi sono
familiari, ma che potrebbero dare al vostro kit molta efficienza in più. Partendo da qui,
vedremo il modo di trovare, comprendere, provare ed incorporare altre parti con le quali
potreste non avete mai lavorato prima.
ATTIVITÀ #1: DALL‘IDEA ALLA PROVA DEL CONCETTO
Molti prodotti partono come idea, in alcuni casi un‘invenzione che potrebbe essere
“veramente brillante,” e in altri casi è proprio quello che ci vuole per risolvere un
problema. Questa idea può essere sviluppata in un concetto con disegni e specifiche, e un
po’ di lavoro di progetto preliminare. Il passaggio successivo è tipicamente lo sviluppo
di un prototipo funzionante. Potrebbe non essere bello, ma dovrà mostrare in modo
affidabile la fattibilità di un dispositivo che operi secondo il concetto e le specifiche
previste. In società che sviluppano prodotti, questa prova di concetto è tipicamente
richiesta per ottenere l’approvazione della direzione aziendale e il finanziamento per
continuare a sviluppare il prodotto.
Idea, concetto, e descrizione funzionale
Diciamo che si debba realizzare un armadietto con uno sportello incernierato e un
cassetto, e vi occorra un piccolissimo sistema antifurto. Oppure, forse volete progettare
un armadietto speciale con antifurto incorporato. La Figura 10-1 mostra uno schizzo del
modo in cui si può utilizzare un potenziometro e un contatto elettrico simile ad un
pulsante per rilevare se viene aperto sia lo sportello, sia il cassetto. Lo schizzo è simile
ad un diagramma concettuale, che focalizza l’attenzione soltanto sul comunicare che cosa
fa il prodotto o l’invenzione.
LED
Potenziometro ----Pulsante ---------------
Piezoaltoparlan
te
Figura 10-1
Schizzo
concettuale di
un
microsistema
antifurto per un
armadietto
La descrizione funzionale è importante . Quando avete un’idea migliore di ciò che si
suppone inizialmente che il vostro dispositivo debba fare, evitate che possano verificarsi
problemi se dovete riprogettare il dispositivo per incorporarvi qualcosa cui non avevate
pensato. I progettisti e le società che creano comuni dispositivi per utenti debbono stare
molto attenti ad interpellare la propria clientela per comprenderne le aspettative. Specie
per dispositivi di progettazione ordinaria, la loro riprogettazione può essere altamente
costosa e lunga.
Ecco un esempio di una breve descrizione funzionale usabile per il nostro semplice
dispositivo: Sviluppare un prototipo di circuito e del suo programma per un micro
sistema di allarme che possa sorvegliare uno sportello incernierato e un cassetto. Se
inserito, dovrà suonare un allarme se vengono aperti lo sportello e/o il cassetto. Un LED
di stato dovrà dare luce verde quando l’allarme non è inserito, e luce rossa quando è
inserito. Un prototipo dovrà essere inserito e disinserito su controllo di un computer. Si
dovrà incorporare un ritardo di tempo per consentire all’utente la chiusura dell’armadietto
dopo che il dispositivo è stato inserito.
Specifica
Oltre alla descrizione funzionale, una specifica tiene tipicamente in considerazione quanti
più aspetti è possibile del dispositivo proposto, inclusi: costo, consumo di corrente,
alimentazione (di tensione), dimensioni, peso, volume dell’altoparlante, e molti altri
dettagli.
Progetto iniziale
Spesso, il progetto iniziale comporta il confronto delle proprie idee con approcci che
”potrebbero“ risolvere il problema, e molte di queste idée debbono essere verificate per
scoprire se sono realizzabili nella realtà. Altre parti del progetto potrebbero comportare
parti e pratiche di progetto completamente standard o del tutto comuni. Il nostro micro
allarme cade in questa categoria, almeno per quanto concerne il prototipo. Si potrebbe
montare un pulsante nell’armadietto, in modo che quando si chiude il cassetto, questo
preme il pulsante. Per lo sportello incernierato, si potrebbe attaccare un potenziometro
che giri con lo sportello e possa sentire la posizione dello sportello. Il LED bicolore è un
indicatore familiare, e il piezo-altoparlante è certamente un noto rivelatore di allarme.
Quindi, ora sappiamo quali circuiti occorrono per il nostro micro prototipo di allarme per
l’armadietto: LED bicolore, pulsante, potenziometro e piezoaltoparlante. Ecco un elenco
dei capitoli e attività dove è stato presentato ciascuno di questi circuiti:




LED Bicolore: Cap. 2, Attività 5
Pulsante:
3,
1
Potenziometro:
5,
4
Piezoaltoparlante:
8,
1
Elenco delle parti per l’allarme di un armadietto:
Tornando indietro a ciascuno dei capitoli appena elencati e mettendo assieme tutte le
parti si ottiene il seguente elenco di parti:
(3) Resistenze – 220 Ω (rosso-rosso-marrone)
(1) Pulsante – normalmante aperto
(1) Piezo-altoparlante
(1) Condensatore – 0.01 µF
Schema allarme dell’armadietto
Lo schema in Figura 10-2 è organizzato per dare a tutti i componenti abbondanza di
spazio sulla breadboard, pertanto non tutte le connessioni dei pin I/O sono le stesse di
quelle che erano nei capitoli precedenti. Dovrete tenere a mente questo fatto quando
raccogliete esempi di codice dai capitoli precedenti per provare ciascun circuito.
Figura 10-2: Schema del prototipo del sistema di allarme
LED
bicolore
ATTIVITÀ #2: COSTRUZIONE E PROVA SINGOLA DI CIASCUN
CIRCUITO
Ogni volta che potete, provate singolarmente ciascun sottosistema prima di tentare di farli
lavorare assieme. Se seguite questa regola, i vostri progetti procederanno senza ulteriori
intoppi, e ciò risparmierà una gran quantità di tempo per la prova e messa a punto. Per
esempio, se si costruiscono tutti i circuiti ma non si provano, le persone hanno una
tendenza naturale a passare troppo tempo ad esaminare il codice (dei programmi) e si
dimenticano di controllare ciascun circuito. Quindi, il risparmio di tempo più importante
in questa procedura è accertarsi che non ci siano errori nei circuiti tentando di ingannare
se stessi nel pensare che ci siano invece errori di codifica.
Costruzione e prova di ciascun circuito
Questa attività mostra come ci si focalizza sui singoli sottosistemi costruendo e provando
ciascun circuito. Una volta costruito e provato il circuito del pulsante, costruiremo e
proveremo il circuito dell’altoparlante. Dopo aver ripetuto questa procedura con il
potenziometro e il LED bicolore, i circuiti saranno tutti “dati per buoni” e pronti per
ricevere i codici di alcune applicazioni.
 Trovate il codice di prova nel capitolo 3, attività #1 che potete adattare alla prova
del circuito con pulsante della Figura 10-2.
 Modificate i riferimenti ai pin I/O in modo che operino col circuito in Figura
10-2.
 Provate il codice e correggete qualsiasi malfunzionamento o errore di cablaggio
prima di continuare.
 Ripetete questo stesso procedimento per:
o Circuito del piezoaltoparlante dal capitolo 8, attività #1
o Circuito del potenziometro dal capitolo 5, attività #4
o Circuito del LED bicolore dal capitolo 2, attività #5
 Accertatevi di salvare ciascun programma modificato sotto nuovo nome,
preferibilmente in una cartella separata, denominata per esempio “ Capitolo 10
CEUM.”
Il vostro turno – Prova del sistema
Ora che tutti i circuiti sono stati provati e tutti i programmi di prova salvati nel vostro PC,
è tempo di costruire un test del sistema con visualizzazione di messaggi di prova (debug)
che dicano quale circuito si sta provando mentre il codice di prova è in esecuzione.
Questo è un esercizio utile, dato che i sistemi di allarme in commercio hanno modalità di
funzionamento in auto-test e diagnostica che utilizzano tutte le loro caratteristiche in una
sola routine.
 Combinate gli elementi del programma di prova in un singolo programma che:
o Parta visualizzando il colore del LED bicolore nel terminale di Debug
mentre aggiorna il colore...
o Quindi visualizzi un messaggio che dica che sta funzionando
l’altoparlante piezo mentre questo emette suoni...
Finalmente entri in un ciclo che riporta ripetutamente lo stato del
sensore del pulsante azionato dal cassetto e quello del sensore del
potenziometro dello sportello incernierato nel terminale di Debug.
 Effettuate la prova e correggete tutti i malfunzionamenti prima di continuare.
o
ATTIVITÀ #3: ORGANIZZAZIONE DI COMPITI DI CODIFICA IN PICCOLE
PARTI
Allo stesso modo in cui ciascun circuito dev’essere costruito e provato prima di farli
lavorare tutti assieme, ciascuna delle caratteristiche del codice dovrà anch’essa essere
sviluppata e provata da sola prima di incorporarla in una applicazione più grande.
ProtoMicroAllarme(Sv-009).bs2 è un esempio di programma che, nel suo modo di
funzionare, realizza una prova di concetto. La sua interfaccia utente col terminale di
Debug è principalmente il centro dell’applicazione, e il sistema di allarme cicla
correttamente attraverso i suoi vari modi o stati di funzionamento, incluse le condizioni di
allarme non inserito, inserimento, allarme inserito, e azione delì’allarme.
A questo punto, la subroutine Inserisce_allarme alla fine del programma è ancora in
costruzione. Ha già in posizione il codice che fa agire l’allarme se il pulsante è rilasciato,
cosa che indica che il cassetto è stato aperto, ma non sorveglia ancora lo sportello
incernierato. Il codice di controllo del potenziometro va aggiunto alla subroutine
Controlla_Sensori che misura la sua posizione . Se la sua posizione è oltre una certa
soglia, ad esempio 15, la variabile stato dovrà essere modificata a Attivato.
Rimangono due compiti aggiuntivi: l’accensione del LED bicolore a verde quando
l’allarme non è inserito, e a rosso quando l’allarme è inserito. Questi compiti rimanenti
sono indicati dai commenti nelle righe di codice, del tipo:
' Da_fare: LED bicolore verde
...
' Da_fare: LED bicolore rosso
...
' Da_fare: Controllare se potenziometro è oltre valore
' di soglia. Se si, allora, attivare allarme
 Digitate a mano ProtoMicroAllarme(Sv-009).bs2 nell’Editor del BASIC Stamp
(raccomandato), o scaricatelo da www.parallax.com/go/WAM ed apritelo con
l’Editor del BASIC Stamp.
 Esaminate il programma e notate come ciascuna subroutine sia modulare, e
faccia un determinato lavoro. Questo fatto fa parte dell’organizzare i compiti di
codifica in piccole porzioni.
 Se non ricordate come usare le finestrelle di trasmissione e ricezione del
terminale di Debug, rivedetevi la Figura 9-9 a pagina 317.
 Caricate ProtoMicroAllarme(Sv-009).bs2 nel BASIC Stamp e nella finestrella di
trasmissione del terminale di Debug digitate il carattere A per inserire l’allarme,
e il carattere D per disinserire l’allarme. Il sistema compie un breve conto alla
rovescia prima di inserire l’allarme. Accertatevi di premere e tenere premuto il
pulsante prima che l’allarme sia stato inserito.
 Mentre l’allarme è inserito, rilasciate il pulsante. Avrete la possibilità di
disinserire l’allarme dopo pochi secondi dal suono dell’allarme stesso.
 Inserite nuovamente l’allarme. Questa volta, digitate “D” per disinserire
l’allarme prima di rilasciare il pulsante.
' -----[ Titolo ]-----------------------------------------------------------'Che cos'è un Microcontrollore - ProtoMicroAllarme(Sv-009).bs2
'Prova il sistema di allarme di un armadietto.
' {$STAMP BS2}
' {$PBASIC 2.5}
' Target = BASIC Stamp 2
' Linguaggio = PBASIC 2.5
' -----[ Costanti ]---------------------------------------------------------NonInserito
CON 0
' Stati sistema allarme
Inserimento
CON 1
Inserito
CON 3
Attivato
CON 4
' -----[ Variabili ]--------------------------------------------------------secondi
VAR Word
' Memorizza conto secondi
contatore VAR Byte
' Per contare
car
VAR Byte
' Memorizza caratteri
stato
VAR Nib
' Memorizza stato sistema allarme
' -----[ Inizializzazione ]-------------------------------------------------PAUSE 1000
' Aspetta 1 secondo
DEBUG "Programma in esecuzione..."
' Visualizza messaggio esecuzione
stato = NonInserito
' Inizializza stato allarme
' -----[ Routine Main]------------------------------------------------------DO
' Ciclo principale (Main)
SELECT stato
' Valuta stato caso per caso
CASE NonInserito
' Se stato = non inserito
' Da_fare: LED bicolore verde
GOSUB Chiede_di_Inserire
'
chiama Chiede_di_Inserire
CASE Inserimento
' Se stato = Inserimento
GOSUB Inserisce_Allarme
'
chiama Inserisce_Allarme
CASE Inserito
' Se stato = Inserito
' Da_fare: LED bicolore rosso
GOSUB Controlla_Sensori
'
Chiama Controlla_Sensori
GOSUB Chiede_di_Disinserire
'
Chiama Chiede_di_Disinserire
CASE Attivato
' Se stato = Attivato
GOSUB Allarme_Attivato
'
Chiama Allarme_Attivato
ENDSELECT
LOOP
' Fatta valutazione car
' Ripete ciclo main
' =====[ Subroutine ]======================================================
' -----[ Subroutine – Chiede_di_Inserire ]-----------------------------------Chiede_di_Inserire:
DEBUG CLS, "Digita A per inserire", CR, ">" ' Visualizza messaggio
GOSUB Ottieni_Input_Utente
' Chiama Ottieni_Input_Utenete
RETURN
' Ritorno da Chiede_di_Inserire
' -----[ Subroutine – Chiede_di_Disinserire ]--------------------------------Chiede_di_Disinserire:
DEBUG CLS, "Digita D per disinserire", CR, ">" ' Visualizza messaggio
GOSUB Ottieni_Input_Utente
' Chiama Ottieni_Input_Utente
RETURN
' Ritorna da Chiede_to_Disinserire
' -----[ Subroutine – Inserisce_Allarme]-------------------------------------Inserisce_Allarme:
DEBUG CLS, "Chiudi armadietto.",
' Avverte utente di chiudere armadietto
CR, "Avete"
FOR secondi = 8 TO 0
' Conta alla rovescia secondi rimasti
DEBUG CRSRX, 9, DEC secondi, CLREOL, ' Visualizza tempo rimanente
" secondi rimasti..."
PAUSE 1000
' Aspetta 1 secondo
NEXT
' Ripete conto alla rovescia
stato = Inserito
' Pone variabile stato a Inserito
RETURN
' Ritorno da Inserisce_Allarme
' -----[ Subroutine - Allarme_Inserito ]-------------------------------------Allarme_Inserito:
DO
' Ciclo Inserito
GOSUB Chiede_di_disinserire
' Controlla input utente
GOSUB Controlla_Sensori
' Controlla sensori
LOOP UNTIL stato <> Inserito
' Ripete fin quando stato non inserito
RETURN
' Ritorno da Allarme_Inserito
' -----[ Subroutine - Allarme_Attivato]-------------------------------------Allarme_Attivato:
DO
' Ciclo Allarme Attivato
DEBUG CLS, "Allarme attivato!!!"
' Visualizza avviso
' Suona 15 toni di allarme
FREQOUT 6, 100, 4500
PAUSE 100
NEXT
' 3 sec. per disinserimento utente
IF stato <> Attivato THEN EXIT
GOSUB Chiede_di_Disinserire
NEXT
LOOP UNTIL stato <> Attivato
' Ripete fin quando disattivato
' -----[ Subroutine - Ottieni_Input_Utente ]--------------------------------Ottieni_Input_Utente:
car = 0
' Cancella variabile car
SERIN 16, 84, 500, Tempo_Finito, [car] ' Aspetta 0,5 sec. per premi testo
GOSUB Elabora_Car
' Se tasto, chiama Elabora_Car
Tempo_Finito:
' Se non è tasto, salta chiaamata
RETURN
' Ritorna da Ottieni_Input_Utente
' -----[ Subroutine - Elabora_Car ]-----------------------------------------Elabora_Car:
SELECT car
' Valuta car caso per caso
CASE "A", "a"
' Se "A" o "a"
stato = Inserimento
'
Cambia var stato a Inserimento
CASE "D", "d"
' Altrimenti, se "D" or "d"
stato = NonInserito
'
Cambia var stato a NonInserito
CASE ELSE
' altrim. se non "A", "a", "D", "d"
DEBUG "Carattere errato, prova di nuovo" '
Visual. messaggio errore
PAUSE 2000
'
Dà a utente 2 sec. per leggere
ENDSELECT
' Fatta valutazione carattere
RETURN
' Ritorno da Elabora_Car
' -----[ Subroutine - Controlla_Sensori ]-----------------------------------Controlla_Sensori:
' Da_fare: Controlla se Potenziometro è sopra il valore di soglia.
' Se si, allora, attiva allarme
IF IN0 = 0 THEN stato = Attivato
' Puls. rilasciato? Attiva allarme.
RETURN
' Ritorno da Controlla_Sensori
Nuove tecniche di codifica nel codice esempio
Date un’occhiata al secondo ciclo FOR...NEXT nella subroutine Allarme_Attivato:
IF stato <> Attivato THEN EXIT
GOSUB Chiede_di_Disattivare
NEXT
Se una chiamata della subroutine Chiede_di_Disattivare produce un cambiamento
nella variabile stato, la frase IF...THEN usa EXIT per uscire fuori dal ciclo
FOR...NEXT prima che siano fatte le sei ripetizioni del ciclo stesso.
Un altro comando nuovo detto SERIN appare nella subroutine Ottieni_Input_ Utente.
DEBUG e DEBUGIN sono versioni speciali dei comandi più generali SEROUT e SERIN. Per
vedere come lavora questo comando, provate a sostituire il comando DEBUG "Programma
in esecuzione..." con SEROUT 16, 84, ["Programma in esecuzione..."]. A
differenza dei comandi DEBUG e DEBUGIN, SEROUT e SERIN possono comunicare con
qualsiasi pin I/O, o con il pin 16 per la comunicazione con il terminale di DEBUG. Essi
hanno anche codici speciali usabili per scegliere il tasso di baud, descritti nelle tabelle
Baud Rate dei comandi SERIN e SEROUT nel manuale BASIC Stamp.
Ottieni_Input_Utente:
car = 0
SERIN 16, 84, 500, Tempo_Finito, [car]
GOSUB Elabora_Car
Tempo_Finito:
RETURN
La subroutine Ottieni_Input_Utente inizia con l’impostare la variabile car a 0 per
cancellare qualsiasi vecchio valore che car potrebbe aver memorizzato. Poi, essa esegue
il comando SERIN, Con il valore opzionale di Timeout impostato a 500 ms (mezzo
secondo), e l’etichetta opzionale di timeout impostata a Tempo_Finito, che è due righe
più sotto. Se il comando SERIN riceve un carattere entro 500 ms, memorizza il risultato
nella variabile car e si sposta alla riga successiva, che richiama la subroutine
Elabora_Car. Se non ottiene un carattere entro 500 ms, salta invece a Tempo_Finito,
che lo porta oltre la chiamata di subroutine.
Il vostro turno – Passo successivo verso la prova di concetto
È adesso il momento di ottenere che il programma funzioni come prova di concetto .
 Memorizzate una copia di ProtoMicroAllarme(Sv-009).bs2 col nome
ProtoMicroAllarme(Sv-010).bs2
 Usate segmenti del vostro codice già provato nell’Attività #2 per completare i tre
punti etichettati “Da_fare”.
 Provate il vostro codice modificato, e quando lavora in modo corretto, salvate
una copia del codice come ProtoMicroAllarme(Sv-011).bs2
ATTIVITÀ #4: DOCUMENTAZIONE DEL PROPRIO CODICE!
ProtoMicroAllarme(Sv-011).bs2 non è del tutto completo poichè occorre ancora un pò di
documentazione e altri cambiamenti per rendere il programma facile da modificare e
manutenere. Ad esempio, nella subroutine Allarme_Attivato, il comando FREQOUT 6,
100, 4500 ha quello che alcuni codificatori chiamerebbero “numeri del mistero.”
Numeri del mistero sono valori usati in modo che un osservatore casuale potrebbe non
riuscire a discernere facilmente. Potreste riscrivere questo comando come FREQOUT
PinAltoparlante, TempoBeep, TonoAllarme. Potete poi aggiungere una sezione
Direttive Pin sopra l’area delle Costanti, e dichiarare PinAltoparlante PIN 6. Inoltre,
nella sezione Costanti, dichiarare TempoBeep CON 100, e TonoAllarme CON 4500.
Non tutte le costanti di un determinato programma debbono avere un nome. Tenete a
mente che i numeri del mistero sono valori usati in modo che l’osservatore casuale
potrebbe non riuscire a discernere facilmente il loro significato. Un altro esempio dalla
subroutine Allarme_Attivato è:
'3 sec. per disinserimento utente.
I numeri 1 e 6 non sono numeri del mistero poichè è chiaro che essi fanno ripetere il ciclo
FOR...NEXT sei volte, e il commento alla destra della FOR indica che sei ripetizioni
durano tre secondi. Non tutti i supervisori possono essere d’accordo con questa
interpretazione, ed alcuni potrebbero proclamare con calore che i numeri 1 e 6 sono
realmente numeri del mistero. Se ultimate il vostro codice sul posto di lavoro e il vostro
capo è un pignolo del nominare tutte le costanti, è probabilmente buona idea aderire
proprio a qualsiasi stile di codifica venga richiesto.
 Scorrete ProtoMicroAllarme(Sv-011).bs2 e documentate i numeri del mistero
dichiarando le direttive pin e le costanti, e sostituendo i loro nomi ai numeri nel
programma.
 Una eccezione alle direttive PIN è l’argomento Pin del comando SERIN, che deve
essere dichiarato come una costante e non come un pin. Gli argomenti Pin
servono per i pin I/O e vanno da P0 a P15. L’argomento Pin 16 forza il
comando SERIN ad ascoltare il pin SIN del modulo BASIC Stamp, che è
connesso alla porta di programmazione della vostra scheda.
Un’altra area dove la documentazione di ProtoMicroAllarme(Sv-011).bs2 è ancora
debole è nei commenti che spiegano ciascuna routine e subroutine. Ciascuna subroutine
dovrebbe avere commenti che spiegano cosa fa, le variabili da cui dipende per fare il suo
lavoro, e le variabili che la subroutine usa per memorizzare i risultati prima della RETURN.
Ecco un esempio di buona documentazione aggiunta all’inizio della subroutine
Elabora_Car.
'
'
'
'
'
'
'
-----[ Subroutine - Elabora_Car ]--------------------------Aggiorna la variabile stato in base ai contenuti della
variabile car. Se car contiene "A" o "a", nella variabile
stato viene memorizzata la costante Attivato. Se car
contiene "D" o "d", in stato viene memorizzata la costante
NonAttivato.
Elabora_Car:
'... codice contenuto qui omesso
RETURN
' Ritorno da...
 Aggiornate le descrizioni tra i titoli delle subroutine e le loro etichette, e ripetete
lo stesso aggiornamento anche per la routine main.
 Quando avete finito, memorizzate una copia del vostro codice con il nome
MicroAllarmeProvaDiConcetto(v1.0).bs2.
Salvate copia e incrementate il numero di versione dopo ciascun cambiamento
Assicuratevi di continuare a salvare copie del vostro codice con ogni piccola modifica.
Ciò rende facile fare piccoli passi indietro al codice che lavora, se i vostri cambiamenti
causano problemi. Per esempio, prima della vostra successiva modifica, salvate il file
come MicroAllarmeProvaDiConcetto(v1.01).bs2, o forse perfino v1.01a. Quando la
vostra caratteristica è stata implementata completamente, scegliete un passo di revisione
ragionevole. Per revisione piccola, provate v1.1; per revisione grande, date v2.0.
ATTIVITÀ #5: DOTATE LA VOSTRA APPLICAZIONE DI NUOVE
FANTASTICHE FUNZIONALITÀ
Come accennato prima, ciascun circuito con cui avete operato in questo testo è in realtà
un esempio preso da un gruppo di componenti e moduli con cui il BASIC Stamp può
interagire nello stesso modo. La Figura 10-3 mostra alcune sostituzioni di parti che
potreste fare per convertire il vostro sistema di sicurezza con mini-contenitore in un
sistema che proteggerà un oggetto situato all’aperto. Questo sistema modificato all’uopo
può invece rilevare movimenti nella stanza, e rilevare anche se qualcuno solleva l’oggetto
che volete proteggere:


Pulsante: uscita alto-basso → sostituite con Sensore di Movimento PIR
Potenziometro: resistenza variabile → sostituite con Sensore FlexiForce
Il sensore PIR rileva le variazioni di configurazione della luce infrarossa nell’area
circostante, e invia un segnale alto per indicare che è stato rilevato movimento, o un
segnale basso per indicare nessun movimento. La resistenza del sensore FlexiForce varia
con la forza applicata al punto rotondo alla sua estremità (ad esempio un oggetto che si
siede su di esso), quindi può essere misurata in un circuito RC con il comando RCTIME.
Figura 10-3: Sensori per aggiornare il nostro mini sistema di allarme
Sensore PIR di
movimento
Sensore FlexiForce
 Andate nel sito www.parallax.com e digitate “motion detection” (rilevazione di
movimenti) nel campo Search (ricerca), quindi cliccate il pulsante Go (vai).
 Trovate il sensore PIR tra i risultati della ricerca e andate alla sua pagina di
prodotto.
 Scaricate la documentazione del sensore PIR (file .pdf), e opzionalmente
osservate la video clip sul sensore PIR. Il file PDF sarà nella sezione della
pagina dedicata ai Download.
 Leggete le spiegazioni della documentazione, gli schemi, e il codice di esempio
PIR_Simple.bs2. Potreste sostituire questo sensore a un pulsante?
 Tornate ai risultati della vostra ricerca (o indietro alla home page Parallax) e
digitate pressure (pressione) nel campo Search. Poi seguite il link del sensore
FlexiForce.
 Trovate e “scucite” (un-zip) la documentazione e il codice sorgente (.zip) del
FlexiForce .
 Nella cartella scucita, aprite e leggete la documentazione, gli schemi, e il codice
sorgente FlexiForce Simple.bs2. Potreste sostituire questo sensore ad un
potenziometro ?
Per avere un esempio passo-passo che illustri come possiate incorporare i
miglioramenti di questa attività e della successiva nella vostra applicazione Micro
Allarme, seguite il link Stamps in Class “Mini Projects” al sito:
www.parallax.com/Education.
ATTIVITÀ #6: COME SUPERARE LE DIFFICOLTÀ DI PROGETTO
Ora che avete quasi finito con Che cos’è un microcontrollore?, uno dei passi successivi
più importanti da affrontare è trovare risposte ai compiti che non sapete ancora come
risolvere col vostro microcontrollore. Ecco i passi generali:
Passo 1: Cercare componenti o circuiti che possano risolvere il vostro problema.
Passo 2: Leggere sul componente/circuito, e trovare come lavora. Fare
particolare attenzione a come il BASIC Stamp avrà bisogno di interagire
con il componente/circuito.
Passo 3: Controllate se sia disponibile il codice esempio per il circuito o il
componente. Ciò renderà estremamente più facile incorporarlo nella
vostra applicazione.
Il prossimo passo nel vostro progetto è visualizzare lo stato del sistema senza la
connessione al computer. Ecco un esempio di come potete trovare e valutare un
componente per la vostra applicazione.
 (Passo 1) Andate al sito www.parallax.com e inserite il termine “display” nel
campo Search. Dalla home page, vi può occorrere di fare click sul pulsante Go
invece di premere semplicemente Enter sulla tastiera. Andate alle pagine di
prodotto dei vari elementi risultanti dalla ricerca e vedete se ne trovate uno che
sia relativamente economico e capace di visualizzare una coppia di righe di testo.
Se avete deciso che il LCD Seriale 2 x 16 Parallax in Figura 10-4 è un buon candidato,
siete sulla strada giusta. Comunque, quasi tutti i display sono una buona scelta.
Figura 10-4
Parallax 2x16 Serial LCD
(LCD Seriale 2x16
Parallax)
 (Passo 2) andate alla pagina di prodotto del LCD. seriale 2x16 Parallax Se non
lo avete già fatto, leggete la descrizione del prodotto. Poi, trovate il link al file
PDF di documentazione (Parallax Serial 2x16 LCD’s PDF Documentation).
Sarà nella sezione Downloads & Resources della pagina, probabilmente sotto la
voce “Parallax Serial 2x16 LCD Documentation v2.0 (pdf).” Il numero di
versione 2.0 potrebbe esser più alto al momento in cui fate questo tentativo.
 (Passo 3) Controllate se c’è codice di esempio nel PDF di documentazione del
LCD seriale 2x16 Parallax e se ci siano anche link al codice nella sezione
Downloads & Resources della pagina web del prodotto . Cercate un programma
esempio grazioso, breve e semplice che visualizzi un messaggio di testo perché
di solito fornisce un buon punto di partenza.
Dopo la breve introduzione a SERIN e SEROUT che ha seguito il programma esempio di
questo capitolo, il codice esempio per il LCD seriale Parallax, che fa leva sul SEROUT,
potrebbe apparirvi piuttosto familiare.
Se seguite il link Smart Sensors and Applications, potete scaricare il testo Smart
Sensors and Applications (in Italiano Sensori Intelligenti e loro applicazioni), che ha un
intero capitolo sul controllo di questo display con il BASIC Stamp 2.
Tre esempi tra quanti?
I sensori PIR e FlexiForce e il LCD seriale Parallax sono tre esempi di moduli e
componenti usabili per aumentare di molto la funzionalità del vostro prototipo. Questi tre
sono soltanto una goccia nel secchio, a confronto di quanti ne siano disponibili.
La Figura 10-5 mostra alcuni moduli e componenti ulteriori, e rappresenta anch’essa
soltanto un piccolo campione. Gli esempi nella figura sono: (a) modulo RF per
comunicazioni radio (RF module for radio com), (b) giroscopio (gyro) per rilevare
velocità di rotazione, (c) bussola (compass) per trovare direzioni, (d) sensore di
vibrazione (vibration sensor), (e) accelerometro (accelerometer) per rilevare variazioni di
inclinazione e velocità, (f) sensore ultrasonico (ultrasonic sensor) per rilevare distanze,
(g) sensore di intensità luminosa (light intensity sensor), (h) controllore di servo (servo
controller), (i) controllore di motore CC (DC motor controller), (j) matrice Darlington
(Darlington array) per pilotare bobine di motori passo-passo, e (k) motore passo-passo
(stepper motor). Potete trovare tutti questi dispositivi nel sito www.parallax.com con una
ricerca su parola chiave. Ad esempio, per trovare di più sull’elemento (f), digitate
“ultrasonic sensor” nel campo Search della home page di Parallax e poi fate click sul
pulsante Go.
_____________________________
Nota – abbiamo mantenuto tra parentesi (in corsivo) i termini inglesi per facilitare la
ricerca sul sito Parallax dei corrispondenti elementi.
Figura 10-5: Altri esempi di moduli e accessori
Controllo di Motori
Sensori
Comunicazioni
b
e
h
j
a
c
f
k
i
d
g
Il vostro turno – Investigazione di un maggior numero di risorse
Se avete in mente un progetto e vi occorre trovare un circuito e il suo codice (di
programma) per supportare una delle caratteristiche del vostro progetto, la procedura di
ricerca appena discussa vi fornirà un buon punto di partenza, ma essa trova soltanto le
pagine di prodotto sul sito www.parallax.com, e c’è un gran numero di domande sul
progetto cui le pagine di prodotto non daranno necessariamente risposte.
Fortunatamente, ci sono molte più risorse, che includono:





Testi PDF Stamps in Class
PDF di documentazione di prodotto Parallax
Dadi e Volt delle colonne BASIC Stamps
Risposte a domande ed articoli sui forum.parallax.com
Articoli su BASIC Stamp pubblicati su Internet
Quando state cercando componenti e informazioni sul modo di usarli col BASIC Stamp,
siete nella categoria di “application information” (“informazioni applicative”). Quando
cercate informazioni applicative, è meglio iniziare con il sito web del costruttore, poi
espandere la ricerca per includervi forum, e se ancora non avete trovato una buona
soluzione, espandete ulteriormente la ricerca a tutto il World Wide Web. La Figura 10-6
mostra un esempio di ricerca su parola chiave con Google, che ricerca i termini“infrared”
(“infrarosso”) e “remote” (“comando a distanza”, o telecomando) nei documenti PDF e
nelle pagine di prodotto del sito www.parallax.com. La parte importante qui è che
Google cerca documenti PDF invece di cercare soltanto pagine di prodotto. Assicuratevi
di non porre spazi nella scritta site:www.parallax.com.
Figura 10-6
Ricerca con Google nel
sito www.parallax.com
Potete modificare la ricerca per includere domande e risposte sui forum di supporto
Parallax cambiando “www” in “forums” come segue:
infrared remote site:forums.parallax.com
Questo ricerca tutte le domande, risposte e articoli brevi che contengono le parole
“infrared” e “remote” nei forums.parallax.com. Per trovare un’applicazione specifica per
il BASIC Stamp, cambiate la vostra ricerca nei termini descritti sotto. Assicuratevi che le
parole BASIC Stamp siano tra virgolette perché ciò filtrerà i risultati raccolti tra la posta.
Ecco un riassunto delle sequenze di ricerca di Google per “BASIC Stamp” infrared
remote
 infrared remote site:www.parallax.com
o Cerca i termini “infrared” e “remote” nei PDF e nelle pagine di prodotto
del sito www.parallax.com
 infrared remote site:fourms.parallax.com
o Cerca i termini “infrared” e “remote” in discussioni al sito
forums.parallax.com
 “BASIC Stamp” infrared remote
o Cerca in tutto il web le parole “infrared” e “remote” nella stessa pagina
o nei PDF con la frase “BASIC Stamp.”
Il prossimo passo per il progetto del Micro Allarme è una tastiera (keypad), ma la
documentazione e gli esempi che trovate con una semplice ricerca di pagina di prodotto
al sito parallax.com è risultata scarsa e sprovvista di circuiti esempio e relativo codice.
Poiché servirà una ricerca ulteriore , proviamo una ricerca con Google nel sito Parallax
che trovi tutti i riferimenti alla parola keypad. Ricordate, la ricerca con Google include i
documenti PDF.
 Andate al sito www.google.com.
 Digitate “keypad site:www.parallax.com” nel campo Search e poi premete Enter.
I risultati possono richiedere un pò di pazienza e tenacia nel passarli al setaccio, e ci
saranno molte pagine di risultati. C’è di solito abbastanza da scegliere in ciascuno dei
risultati di ricerca per ottenere alcuni contesti per ciascun link. Questo darà una certa
idea di quali risultati tralasciare e quali osservare più in dettaglio. Dopo poche pagine,
potreste trovare e seguire un link ad un Kit delle parti per un IR Remote (telecomando ad
infrarossi), mostrato nella Figura 10-7. Potrebbe non essere la soluzione che aspettavate,
ma dopo aver esaminato il prezzo, la documentazione e il codice esempio, potrebbe
costituire un buona scelta potenziale di tastiera del vostro micro sistema di sicurezza
potenziato.
Figura 10-7: Kit delle parti per un telecomando a IR
Se, dopo tutto questo, ancora non avete trovato l’informazione che cercavate, è ora di
chiedere ai forum.parallax.com. Quando fate una domanda nei forum, essa sarà vista da
esperti di una varietà di rami, e da insegnanti, hobbysti, e studenti. L’esperienza
collettiva dei Forum Parallax dovrebbe aiutarvi a superare le difficoltà di qualsiasi
progetto!
Ostacoli di progetto da memoria e velocità del processore
In alcuni casi, i programmi per i progetti più grandi possono raggiungere una lunghezza
sufficiente a superare la memoria di programma del BASIC Stamp 2. Questo ostacolo di
progetto può essere superato, in alcuni casi, riscrivendo codice che faccia più lavoro con
un numero di comandi minore. Un’altra opzione è aggiornarsi ad un modello di BASIC
Stamp con memoria di programma più grande. In altri casi, il progetto potrebbe
comportare la memorizzazione di più valori di variabili di quante ne possa memorizzare
il BASIC Stamp 2. Ci sono inoltre modelli di BASIC Stamp 2 caratterizzati da memoria
RAM di servizio per i valori delle variabili. Altri progetti potrebbero aver bisogno di fare
più compiti in un tempo minore di quanto il BASIC Stamp 2 è progettato per dare, perciò
alcuni modelli di BASIC Stamp 2 sono progettati con velocità di elaborazione maggiori.
La Figura 10-8 mostra tutti i modelli diversi di BASIC Stamp. Per avere dettagli su uno
di questi, seguite il link “Compare BASIC Stamp Modules” (“Confronta i modelli di
BASIC Stamp”) al sito www.parallax.com/basicstamp.
Figura 10-8: La linea completa dei Modelli di BASIC Stamp
Da sinistra: BS1, BS2, BS2e, BS2sx, BS2p24, BS2p40, BS2pe, BS2px
A buon mercato, ma ancora capace, perfetto per progetti piccoli o spazi stretti.
Ideale per principianti con una vasta base di risorse di codice esempio; è il
cuore del programma Stamps in Class.
BS2e:
Perfetto per utenti BS2 cui occorra più spazio per il programma e le variabili.
BS2sx: Supporta l’insieme dei comandi BS2 con maggior spazio per variabili e
programma, a più del doppio della velocità di esecuzione.
BS2p24: In aggiunta alla maggior velocità e al maggior spazio per le variabili, comandi
speciali supportano il polling I/O, i LCD di caratteri (alfabetici) e i protocolli
I2C e 1-wire.
BS2p40: Tutte le caratteristiche del BS2p24 con un banco di 16 pins I/O aggiuntivi.
BS1:
BS2:
Supporta l’insieme di comandi del BS2p24 con un consumo di potenza più
basso e una maggior memoria, per applicazioni di acquisizione dati alimentate
a batteria.
BS2px: Il modello più veloce di BASIC Stamp: supporta tutti i comandi BS2p24, più
caratteristiche speciali di configurazione I/O.
Una cosa da tenere a mente se vi aggiornate a un modello di BASIC Stamp più veloce
sono le differenze di unità per i comandi sensibili al tempo come RCTIME e FREQOUT.
Poiché i modelli differenti di processor eseguono a velocità diverse, le unità per Duration
e Frequency e gli altri argomenti potrebbero essere differenti. Ad esempio, quando il BS2
esegue FREQOUT 6, 100, 4500, invia un tono di allarme di timbro alto a P6 per 100 ms
(1/10th di secondo) ad una frequenza di 4500 Hz. Lo stesso comando eseguito dal BS2px
invia un tono che dura soltanto 16,6 ms ad una frequenza di 27.135 Hz, che è a tono così
alto da non essere udibile per alcun orecchio umano! Per la descrizione completa di
come ciascun comando lavori su ciascun modello, e per suggerimenti sulla conversione
di programmi BS2 perché eseguano in modo corretto su altri modelli, si veda l’aiuto del
Editor del BASIC Stamp.
BS2pe:
Elaborazione parallela ad alte prestazioni
Alcune applicazioni complesse richiedono agilità di elaborazione e memoria ben oltre le
capacità della linea BASIC Stamp 2. Questi sono i tipi di progetto per i quali è
appositamente progettato il microcontrollore Propeller (Propulsore). Questo
microcontrollore con prestazioni uniche ha otto processori a velocità molto più alta in un
unico chip, assieme a 32 pin I/O e ad un’ampia memoria di programma e RAM. I
processori possono funzionare tutti contemporaneamente, sia indipendentemente l’un
l’altro, sia in modo cooperativo, condividendo l’accesso alla memoria globale e il clock
(orologio) di sistema. Ciascun processore ha inoltre la sua propria memoria, e un
hardware aggiuntivo per eseguire compiti complessi come il monitoraggio dello stato dei
pin I/O ad alta velocità o la generazione di segnali per un display televisivo o di
computer.
Il kit didattico Propeller mostrato nella Figura 10-9 è un buon modo di iniziare col
microcontrollore Propeller. Questo kit non è necessariamente il migliore dei passi
successivi dopo Che cos’è un microcontrollore? (What’s a Microcontroller?) La
prossima attività contiene alcune buone raccomandazioni per i passi del prossimo
libro/kit. Comunque, quando notate che i vostri progetti diventano più ambiziosi e con
maggiori sfide, ricordatevi del microcontrollore Propeller e del kit didattico Propeller.
Figura 10-9
Kit didattico Propeller
(a sinistra) e
Piattaforma PE (a
destra)
ATTIVITÀ #7: COSA IMPARARE DOPO?
Ora che avete quasi completato il testo Che cos’è un Microcontrollore (What’s a
Microcontroller?), è tempo di pensare a cosa imparare dopo. Prima di continuare,
prendetevi un momento per considerare a cosa siete principalmente interessati. Alcune
delle categorie generali su cui fare ulteriori ricerche comprendono:






Robotica
Elettronica
Sensori
Automazione
Progetti di hobbistica
Scienze della terra e misura del clima
Questa attività fa l’inventario delle risorse che potete usare per muovervi in ciascuna di
queste categorie.
Le risorse, i kit, e i componenti di cui si parla in questa attività sono correnti al
momento in cui è stato scritto questo capitolo (autunno 2009). Possono rendersi disponibili
versioni più recenti e migliori delle risorse, dei kit, e dei componenti che sostituiranno quelli
presentati qui . Per informazioni aggiornate, controllate il sito www.parallax.com .
Continuazione di Che cos’è un microcontrollore
La Figura 10-10 mostra i libri e i kit che sono il miglior seguito di questo libro. Robotica
con il Boe-Bot (Robotics with the Boe-Bot) è molto divertente e costituisce una grande
esperienza didattica poichè vi permette di applicare molte delle tecniche di questo libro
ad applicazioni di robotica con il robot semovente Boe-Bot®. Sensori intelligenti e loro
applicazioni (Smart Sensors and Applications) è stato scritto per essere la seconda parte
di “Che cos’è un Microcontrollore.” Ha un altro nome poiché tutti i bei sensori e display
a cristalli liquidi mostrati al centro della Figura 10-10 hanno coprocessori che
comunicano con il BASIC Stamp. I coprocessori li rendono sensori “intelligenti”.
Understanding Signals (Comprendere i segnali) è un libro importante perché vi consente
di “vedere” le interazioni tra il BASIC Stamp e i circuiti con un oscilloscopio Parallax
che collegate alla porta USB del vostro computer.
Figura 10-10: Seguito alla grande, dopo Che cos’è un microcontrollore?
Kit del Robot Boe-Bot
Sensori intelligenti e
Applicazioni - Parti e
Testo
Comprendere i
segnali - Parti e
Testo
Ulteriori kit e testi di Stamps in Class
La Figura 10-11 mostra un diagramma di flusso che riassume tutti i kit e testi di Stamps
in Class disponibili al momento di questa stesura. E’ accessibile tramite il link Stamps in
Class Program Overviews and Flowchart al sito www.parallax.com/Education, e potete
fare clic su ciascuna delle immagini per visitare la pagina di prodotto per il libro e il kit
che lo accompagna. Che cos’è un microcontrollore? è in alto a sinistra nella figura. Da
lì, il diagramma di flusso indica che potete sia saltare a Robotics with the Boe-Bot sia a
qualsiasi testo/kit delle serie Sensors o Signals.
Scarico dei testi completi in PDF: Potete scaricare l’intero PDF a colori di ciascun libro
Stamps in Class dal sito www.parallax.com. Cliccate su una qualsiasi delle illustrazioni nel
diagramma per navigare alla pagina Testo + Kit, e troverete il link al PDF nella sezione
Downloads della pagina.
Figura 10-11
Diagramma di
flusso
Stamps in Class
Se la categoria cui siete interessato è:





Robotica, allora il passo successivo è certamente Robotics with the Boe-Bot.
Sensori, invenzioni, o progetti di hobbistica, allora il passo successivo sarà
Sensori intelligenti e applicazioni (Smart Sensors and Applications).
Elettronica (segnali), allora il passo successivo sarà Understanding Signals.
Automazione, allora il passo successivo sarà Process Control.
Scienza della terra e misura del clima, allora il passo successivo sarà Applied
Sensors (originariamente Earth Measurements).
Risorse aggiuntive Stamps In Class
In aggiunta e oltre al contenuto dei libri di testo Stamps in Class, ci sono dei “Mini
Progetti” Stamps in Class con i link nel sito www.parallax.com/Education. Alcuni
progetti utilizzano solo le parti in stock da un determinato kit, ma mostrano nuovi modi di
usarli, oltre a introdurre nuovi concetti. Molti di questi progetti sono simili a capitoli
completi di libri Stamps in Class con attività, schemi, diagrammi di cablaggio, e listati di
codice completi che si possono scaricare dal sito. Alcuni hanno perfino tutorial video che
li accompagnano . La Figura 10-12 è presa dal video del progetto “Build Your Own Mini
Timer” (Costruisci il tuo mini-timer), che può essere realizzato con le sole parti che avete
utilizzato in questo libro. Se state cercando maggiori informazioni o ispirazione creativa,
li potreste trovare qui.
Figura 10-12: Esempio di “Mini Progetto” Stamps in Class
SOMMARIO
Questo libro ha introdotto una varietà di circuiti e tecniche, che sono tutte mattoni
elementari di prodotti commerciali comuni, come pure di invenzioni. Questo libro ha
introdotto anche tecniche per mettere assieme i vari mattoni con il microcontrollore
BASIC Stamp. Questo capitolo mostra come incorporare queste tecniche e i mattoni in
un prototipo, ed ha raccomandato anche i passi successivi per apprendere di più nella
vostra area di interesse.
L’approccio per far interagire il BASIC Stamp con un determinato circuito può essere
applicato a una varietà di altri circuiti e moduli, per realizzare una gamma ancor più vasta
di compiti. Due esempi applicati al prototipo di micro-allarme sono stati: (1) un sensore
di movimento con un’interfaccia simile al pulsante e (2) un sensore di pressione con
un’interfaccia simile al potenziometro.
Mentre sviluppate il codice per la vostra applicazione, accertatevi di memorizzare spesso
il vostro lavoro sotto nomi di revisione incrementali (con suffissi -1, -2, ecc.).
Assicuratevi, inoltre, di usare nomi significativi per i pin I/O e numeri con le direttive
PIN e CON. Infine, aggiungete abbondanti commenti al vostro codice, che spieghino cosa
fa e come lo fa. Le subroutine debbono includere commenti che spieghino cosa fa la
subroutine, assieme a tutte le sue variabili e ai valori che queste usano per fare il loro
lavoro, e alle variabili che conservano i risultati quando la subroutine è stata eseguita.
Questo capitolo ha introdotto anche una varietà di tecniche di ricerca per implementare
caratteristiche del vostro prototipo. Perfino se siete digiuni di come far lavorare una
caratteristica particolare, potete usare la ricerca di termini per trovare componenti ,
circuiti, ed esempi di codice utili. I libri di testo Stamps in Class e i relativi kit
caratterizzano una ricchezza di circuiti e tecniche di progetto utili, e sono di grande aiuto
per apprendere di più nel campo della robotica, dei sensori, dell’elettronica,
dell’automazione, della scienza della terra, ed altro ancora. Tutti i testi che
accompagnano i kit Stamps in Class sono scaricabili gratuitamente.
Ora che avete raggiunto la fine di questo libro, prendetevi il tempo di pensare a quattro
cose: (1) le tecniche che avete appreso, (2) la vostra prossima invenzione, progetto o
prototipo, (3) come ciò che avete appreso qui possa essere applicato ad essa, e (4) ciò che
volete imparare dopo.
 Ora, è tempo di iniziare il vostro prossimo progetto o prototipo.
 Accertatevi di mantenere lo studio e l’apprendimento di nuove tecniche man
mano che procedete.
 Divertitevi e buona fortuna!
Appendice A: Elenco delle Parti e opzioni del kit · Pagina 353
Appendice A: Elenco delle parti e Opzioni del Kit
Che cos’è un microcontrollore Kit parti e testo #28152, Solo parti #28122
Parti e quantità soggettte a cambiamenti senza informazioni preventive
Parte Parallax #
Descrizione
Quantità
150-01020
Resistenza, 5%, 1/4W, 1 k
10
150-01030
4
150-01040
2
150-02020
2
150-02210
Resistenza, 5%, 1/4W, 220 
6
150-04710
Resistenza, 5%, 1/4W, 470 
6
152-01031
Potenziometro - 10 k
1
200-01031
Condensatore, 0.01 F
2
200-01040
Condensatore, 0.1 F
2
201-01080
Condensatore, 1000 F
1
201-03080
Condensatore 3300 F
1
28123
Testo What’s a Microcontroller? (solo in #28152)
1
350-00001
LED – Verde – T1 3/4
2
350-00005
LED – Bicolore – T1 3/4
1
350-00006
LED – Rosso – T1 3/4
2
350-00007
LED – Giallo – T1 3/4
2
350-00027
Display LED a 7 segment i
1
350-00029
Fototransistor, 850 nm, T1 3/4
1
400-00002
Pulsante – Normalmente aperto
2
451-00303
Capocorda a 3 Pin – Maschio/Maschio
1
500-00001
Transistor – 2N3904
1
604-00010
potenziometro digitale 10 k
1
800-00016
Cavallotti di filo da 3” – Sacchetto di 10
2
900-00001
Piezo Altoparlante
1
900-00005
Servo Standard Parallax
1
OPZIONI KIT COMPLETO
Sono disponibili parecchie opzioni di kit che includono una scheda di sviluppo con
microcontrollore BASIC Stamp 2 e tutti i componenti elettronici per completare le
attività descritte in questo testo:

Il kit attività BASIC Stamp (#90005) include:
o Scheda BASIC Stamp HomeWork con BS2 montato in superficie
o Adattatore da USB a Seriale con cavo USB da A a Mini-B (#28031)
o Parti e testo What’s a Microcontroller? (#28153)

Il kit presentazione BASIC Stamp (Seriale #27207 o USB #27807) include:
o Scheda Board of Education (Seriale #28150 o USB #28850)
o Modulo microcontrollore BASIC Stamp 2 (#BS2-IC)
o Cavo per programmazione (Seriale #800-00003 o USB da A a Mini-B
#805-00006)
o Parti e testo What’s a Microcontroller? (#28152)
o Manuale BASIC Stamp (#27218)


Il kit parti & testo What’s a Microcontroller (#28152). PIU’
Il kit complete Board of Education (Seriale #28103 o USB #28803), include:
o Scheda Board of Education (Seriale #28150 o USB #28850)
o Modulo microcontrollore BASIC Stamp 2 (#BS2-IC)
o Cavo per programmazione (Seriale #800-00003 o USB da A a Mini-B
#805-00006)
o Cavallotti di filo (1 pacco di 10)
Nota per gli Insegnanti: Sono disponibili sconti quantità per tutti i kit elencati sopra; per
i dettagli si veda la pagina di prodotto di ciascun kit al sito www.parallax.com. In
aggiunta, è disponibile separatamente in pacchi di 10 la scheda BASIC Stamp
HomeWork Board, come soluzione economica per l’uso in classi, che costa molto meno
del kit Board of Education + modulo BASIC Stamp 2 (#28158). Vi preghiamo di
contattare il Parallax Sales Team al numero telefonico gratuito (888) 512-1024 per il
prezzo di quantità più grandi.
Appendice B: Aggiunte su elettricità · Pagina 355
Appendice B: Aggiunte su elettricità
Cos’è un elettrone? Un elettrone è una delle tre parti fondamentali di un atomo; le altre
due sono il protone e il neutrone. Uno o più protoni e neutroni si incollano assieme nel
centro della molecola in un’area detta nucleo. Gli elettroni sono molto piccoli in confronto a
protoni e neutroni, ed orbitano attorno al nucleo. Gli elettroni si respingono l’un l’altro,
mentre elettroni e protoni si attraggono l’un l’altro.
Cos’è la carica ? La tendenza di un elettrone a respingere un altro elettrone e ad attrarre
un protone vicino è detta carica negativa . La tendenza di un protone a respingere un altro
protone ed attrarre un elettrone è detta carica positiva . Quando una molecola ha più
elettroni che protoni, si dice che è carica negativamente. Se una molecola ha meno elettroni
che protoni, si dice che è carica positivamente. Se una molecola ha elettroni e protoni in
numero uguale, si dice che ha carica neutra.
Che cos’è il voltaggio (o tensione)? Voltaggio è come dire pressione elettrica. Quando
una molecola carica negativamente è vicina a una molecola carica positivamente, l’elettrone
extra sulla molecola carica negativamente tenta di portarsi dalla molecola carica
negativamente a quella carica positivamente. Le batterie contengono un composto con
molecole cariche negativamente separato da un composto con molecole cariche
positivamente. Ciascuno di questi composti è connesso a uno dei terminali della batteria; il
composto carico positivamente è connesso al terminale positivo (+), e il composto negativo
è connesso al terminale negativo (-).
Il volt è una misura della pressione elettrica, e si abbrevia con una V maiuscola. Potete già
esservi familiarizzati con la batteria a nove volt (9 V) usata per alimentare la scheda Board
of Education o la HomeWork Board. Altre batterie usate molto comunemente includono le
batterie a 12 V presenti nelle automobili e le batterie AA da 1.5 V usate in calcolatrici, giochi
palmari ed altri dispositivi.
Cos’è la corrente? La corrente è una misura del numero di elettroni che in un secondo
passano attraverso un circuito. Talvolta le molecole si legano in una reazione chimica che
crea un composto (carico in modo neutro). Altre volte, l’elettrone lascia la molecola carica
negativamente e si unisce ad una molecola carica positivamente attraversando un circuito
come quello che avete appena costruito e provato. La lettera usata più comunemente per
indicare la corrente negli schemi elettrici e nei libri è la “I.” maiuscola
Cos’è un amp? Un amp (abbreviazione di ampere) è l’unità base di corrente, e la
notazione per amp è la maiuscola “A.” A confronto con i circuiti che state usando con il
BASIC Stamp, un amp è una quantità di corrente molto grande. E’ un valore conveniente
per descrivere la quantità di corrente che una batteria di automobile fornisce ai fari
abbaglianti, al ventilatore che raffredda il motore dell’automobile, e ad altri dispositivi di alta
potenza. Il Milliamp (mA) e il microamp (μA) sono misure più convenienti per discutere la
corrente che alimenta il modulo BASIC Stamp e la corrente tra i pin I/O e i circuiti. 1 mA =
1/1,000 A, e 1 μA = 1/1,000,000 A.
Cos’è la resistenza? Resistenza è la tendenza di un elemento di un circuito a resistere al
flusso di elettroni (la corrente) dal terminale negativo di una batteria al terminale positivo.
L’ohm è la misura base di una resistenza. E’ stato già introdotto e si abbrevia con la lettera
greca omega ().
Cos’è un conduttore? Un filo di rame non ha quasi resistenza, ed è detto conduttore.
Pagina 356 ·Che cos’è un microcontrollore?
ATTIVITÀ BONUS: LEGGE DI OHM, VOLTAGGIO, E CORRENTE
Questa attività applica alcune delle definizioni appena discusse.
Parti per la Legge di Ohm
(1) Resistenza – 1 kΩ (marrone-nero-rosso)
Circuito di prova
Il valore di resistenza di Ri in Figura B-1 può essere cambiato. Una resistenza più bassa
consente che una maggior corrente attraversi il LED, e questo avrà una luce più brillante.
Valori di resistenza più alti faranno apparire il LED a luce meno intensa poiché non
consentono che nel circuito passi altrettanta corrente.
 Scollegate Potenza alla vostra Board of Education o HomeWork Board ogni
volta che modificate il circuito.
 Costruite il circuito in Figura B-1 iniziando con una resistenza da 220 Ω.
 Modificate il circuito sostituendo la resistenza da 220 Ω con una resistenza da
470 Ω. La luce del LED è meno brillante?
 Ripetete usando la resistenza da 1 kΩ, poi quella da 2 kΩ, controllando ogni
volta il cambio di luminosità.
Vdd
X3
Vdd
R1 R2 R3 R4
Ri
LED
Vss
R1 = 220 
R2 = 470 
R3 = 1 k
R4 = 2 k
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
X2
Vin
Vss
+
Figura B-1
Controllo di corrente
con un LED
Se state usando una batteria da 9 V, potete confrontare anche la luminosità di una diversa
sorgente di voltaggio, Vin. Vin è connesso direttamente al terminale + della batteria da 9
V, e Vss è connesso direttamente al terminale negativo della batteria. Nel nostro sistema,
Vdd è 5 V stabilizzato. Questa è circa la metà del voltaggio della batteria da 9 V.
 Se non state usando una batteria da 9 V, fermatevi qui e saltate alla sezione
Calcolo della corrente qui sotto. Altrimenti, continuate.
 Iniziate col circuito mostrato in Figura B-1, ma usate una resistenza da 1 kΩ.
 Prendete nota di quanto sia brillante la luce del LED.
 Scollegate potenza.
 Modificate il circuito: scollegate il filo della resistenza da Vdd e connettetelo a
Vin.
 Quando ricollegate di nuovo potenza, il LED è più brillante? Quanto più
brillante?
NON provate a fare l’esperimento Vin con una resistenza da 220 o 470 , queste
fornirebbero al LED più corrente di quanto ne possa sopportare.
Calcolo della corrente
Il Manuale del BASIC Stamp ha alcune regole su quanta corrente i pin I/O possano
fornire ai circuiti. Se non seguite queste regole, potete finire per danneggiare il vostro
BASIC Stamp. Le regole hanno a che fare con quanta corrente un pin I/O può liberare e
quanta corrente può liberare un gruppo di pin I/O .
Regole di corrente per i pin I/O del BASIC Stamp

Un pin I/O può “originare” fino a 20 mA. In altre parole, se mandate un segnale
HIGH ad un pin I/O, non dovrebbe alimentare il circuito del LED con più di 20 mA.

Se ricablate il circuito del LED in modo che il BASIC Stamp faccia accendere il
LED quando mandate il comando LOW, un pin I/O può “erogare” fino a 25 mA.

I pin da P0 a P7 possono fornire soltanto fino a 40 mA. Analogamente quelli da
P8 a P15. 40 mA è anche la corrente di alimentazione I/O del regolatore
(alimentatore stabilizzato) da 5 V del modulo BASIC Stamp 2, pertanto la corrente
totale che viene emessa da tutti i pin I/O non dovrà mai superare 40 mA. Se
avete molti circuiti a LED, vi occorreranno resistenze più grandi perché i circuiti
non conducano troppa corrente.

Per maggiori informazioni, consultate la tavola di descrizione Pin del BASIC
Stamp 2 nel Manuale BASIC Stamp.
Se sapete come calcolare quanta corrente userà il vostro circuito, potrete allora decidere
se è OK far brillare i vostri LED tanto intensamente. Ciascun componente ha regole per
ciò che fa con voltaggio, resistenza, e corrente. Per il diodo a emissione di luce, la regola
è un valore chiamato tensione di conduzione del diodo. Per la resistenza, la regola è detta
Legge di Ohm. Ci sono anche regole per quanta corrente e voltaggio si sommino nei
circuiti. Queste regole si chiamano Leggi di Kirchhoff per voltaggio e corrente .
Vdd – Vss = 5 V Il voltaggio (pressione elettrica, o tensione) tra Vdd e Vss è 5 V. Questo
voltaggio si chiama tensione stabilizzata, ed opera quasi nello stesso modo di una batteria
che fornisce esattamente 5 V. (Le batterie non hanno tensione tipica di 5 V, anche se
quattro batterie ricaricabili al nickel-cadmio da 1.2 V in serie possono sommarsi fino a 4.8
V) Le schede Board of Education e BASIC Stamp HomeWork Board hanno entrambe
alimentatori stabilizzati a 5 V che convertono le tensioni fornite dalle batterie da 6 a 9 V in
tensione stabilizzata da 5 V per gli zoccoli Vdd sopra la breadboard. Il BASIC Stamp ha
anche lui uno stabilizzatore-regolatore di tensione incorporato che converte l’input di 6 o 9 V
in 5 V per i suoi componenti.
Vin – Vss = 9 V Se state usando una batteria da 9 V, il voltaggio da Vin a Vss è 9 V. State
attenti. Se state usando un alimentatore stabilizzato alimentato dalla rete elettrica (con
presa a muro), anche se dice 9 V, può andare a tensioni fino a 18 V.
Terra e/o riferimento si riferisce al terminale negativo di un circuito. Quando si va al
BASIC Stamp e alla Board of Education, Vss è considerato il riferimento di terra. E’ di zero
volt, e se state usando una batteria da 9 V, è il terminale negativo di quella batteria. Il
terminale positivo della batteria è 9 V. Vdd è 5 V (sopra il riferimento Vss di 0 V), ed è un
voltaggio speciale fatto da un chip regolatore di tensione per dare potenza elettrica al BASIC
Stamp.
Legge di Ohm: V = I × R La tensione (o voltaggio) misurata ai capi dei terminali di una
resistenza (V) è uguale alla corrente che passa attraverso la resistenza (I) moltiplicata per il
valore della resistenza (R).
Tensione di conduzione del diodo : è la tensione tra l’anodo e il catodo di un diodo
mentre la corrente passa dall’anodo al catodo. Per il LED verde nel circuito di Figura 2-6 a
pagina 35, potete assumere che la tensione di conduzione ai capi del LED è di circa 2,1 V
per amore dei calcoli fatti sul circuito. Se il LED è giallo, assumete 2,0 V, e se il LED è
rosso, assumete 1,7 V. Queste tensioni varieranno leggermente con la quantità di corrente
che passa nel circuito. Minori resistenze in serie e/o maggiori voltaggi applicati al circuito
produrranno un flusso di corrente più alto. Maggiori resistenze in serie e/o minori voltaggi
applicati produrranno un flusso di corrente più basso.
Legge di Kirchhoff semplificata per il voltaggio: il voltaggio usato uguaglia il
voltaggio fornito. Se alimentate un circuito con 5 V, il numero di volt che tutte le sue parti
usano, è stato al meglio una tensione fino a 5 V.
Legge di Kirchhoff semplificata per la corrente: la corrente in ingresso uguaglia la
corrente in uscita. La corrente che entra in un circuito LED da Vdd è la stessa quantità di
corrente che lo lascia attraverso Vss. Analogamente, se collegate tre LED al BASIC Stamp,
e ciascun circuito LED conduce 5 mA, ciò vuol dire che il BASIC Stamp deve alimentare tutti
i circuiti con una corrente totale di 15 mA.
Calcolo di esempio: un circuito, due circuiti
Il calcolo di quanta corrente conduca il circuito di un LED rosso si svolge in due tempi:
1. Prevedete quale sia il voltaggio ai capi della resistenza
2. Usate la legge di Ohm per prevedere la corrente che attraversa la resistenza.
La Figura B-2 mostra come calcolare il voltaggio ai capi della resistenza. Il voltaggio
fornito è a sinistra, ed è 5 V. I voltaggi usati da ciascun componente sono alla destra del
circuito. Il voltaggio che non conosciamo all’inizio è VR, il voltaggio attraverso la
resistenza. Ma sappiamo che il voltaggio attraverso il LED sta per assumere il valore di
circa 1,7 V (la tensione di conduzione diretta del diodo che emette luce rossa). Sappiamo
anche che il voltaggio ai capi delle parti deve assommare in totale a 5 V per la Legge di
Kirchhoff sul Voltaggio. La differenza tra 5 V e 1,7 V è 3,3 V, quindi questo dev’essere
il voltaggio ai capi della resistenza, VR.
VR  1.7 V  5 V
VR  5 V  1.7 V
VR  3.3V
Figura B-2
Voltaggio ai
capi del
circuito, della
resistenza, e
del LED
Kilo è il prefisso metrico per 1000. Il modo usato nelle unità di misura per dire 1000 è
kilo, e si abbrevia con la lettera k minuscola. Invece di scrivere 1000 , potete scrivere 1
k. In ciascun modo, si pronuncia un-kilo-ohm. Analogamente, 2000  si scrive 2 k.
Milli è il prefisso metrico per 1/1000, e si abbrevia con la lettera m minuscola. Se il
BASIC Stamp alimenta il circuito di un LED con 3,3 millesimi di un amp, ciò vuol dire 3,3
milliamps, o 3,3 mA.
Cos’è un mA? Pronunciato milliamp, è la notazione per un millesimo-di-un-amp. La “m”’ in
mA è la notazione metrica per milli, che sta per 1/1000. La “A” in mA sta per amp. Mettete
le due cose assieme, ed avrete milliamp, e questo è molto utile a descrivere la quantità di
corrente emessa dal BASIC Stamp e che fluisce nel circuito connesso ad esso.
Ora che abbiamo calcolato la tensione ai capi della resistenza, la Figura B-3 mostra un
esempio di come usare quel valore per calcolare la corrente che passa attraverso la
resistenza. Iniziate con la legge di Ohm: V = I × R. Conoscete i valori di V (3,3 V) ed R
(470 Ω). Ora, tutto ciò che dovete fare è risolvere per I (la corrente).
V  IR
3.3V  I  470 Ω
3.3 V
I
470 Ω
I  0.00702 V
Ω
I  0.00702 A
7.02
I
A
1000
I  7.02 mA
Figura B-3
Calcolo della
corrente che
attraversa la
resistenza
Si, è vero ! 1 A = 1 V/ (Un amp è un volt per ohm).
Quanta corrente è 7,02 mA? È la quantità di corrente che il circuito LED in Figura B-2
conduce. Potete sostituire la resistenza da 470  con una resistenza da 220 : il circuito
condurrà circa 15,0 mA, e il LED avrà luce più brillante. Se usate una resistenza da 1000 ,
il circuito condurrà 3,3 mA, e il LED avrà luce meno brillante. Una resistenza da 2000 
farà illuminare il LED ancora di meno, e la corrente sarà 1,65 mA.
Diciamo che volete fare in modo che un pin I/O accenda contemporaneamente due LED .
Questo significa che il BASIC Stamp, al suo interno, dovrà alimentare i circuiti come
mostra la Figura B-4. La corrente del circuito supererà il limite di 20 mA del pin I/O?
Verifichiamo. Ricordate che la versione semplificata della legge di Kirchhoff’ sulla
corrente dice che la corrente totale emessa dall’alimentatore dev’essere uguale alla
corrente fornita a tutti i circuiti. Ciò significa che I in Figura B-4 deve uguagliare il totale
delle due correnti che vengono emesse. Sommate semplicemente le due correnti emesse,
e otterrete in risposta 14,04 mA, che potete arrotondare a 14,0 mA. Poiché questa
emissione di corrente è ancora sotto il limite di 20 mA del pin I/O, ci si può connettere
con sicurezza ad un pin I/O e commutare acceso/spento con il BASIC Stamp.
I  I 1  I 2  ... I i
I  7.02 mA  7.02 mA
I  14.04 mA  14.0 mA
Figura B-4
Corrente
totale
fornita ai
due circuiti
a LED
Il vostro turno – Modifica del circuito
 Ripetete l’esercizio in Figura B-2, ma usate Vin – Vss = 9 V invece di Vdd – Vss
= 5 V.
Assumendo che la tensione di conduzione diretta non cambi, la risposta è VR =
7,3 V. La tensione misurata sulla resistenza sarà probabilmente leggermente
inferiore a causa di una maggior tensione di conduzione diretta del LED per la
maggior corrente che attraversa il circuito.
 Ripetete l’esercizio in Figura B-3, ma usate una resistenza da 1 kΩ.
Risposta: I = 3,3 mA.
 Usate VR = 7,3 V per fare l’esercizio in Figura B-3 con una resistenza da 1 kΩ.
Risposta: I = 7,3 mA.
 Ripetete l’esercizio mostrato in Figura B-4 con una delle resistenze da 470 Ω e
l’altra da 1 kΩ.
Risposta: I = 7,02 mA + 3,3 mA = 10,32 mA.
Appendice C: Sommario del formato RTTTL· Pagina 363
Appendice C: Sommario del formato RTTTL
Questo è un sommario inteso come aiuto a dare un senso al formato RTTTL. Le
specifiche complete del RTTTL si possono trovare pubblicate in vari siti web. Con un
qualsiasi motore di ricerca, usate le parole chiave “RTTTL specification” (“specifiche
RTTTL”) per rivedere le pagine web che riportano le specifiche.
Ecco un esempio di suoneria in formato RTTTL :
TakeMeOutToTheBallgame:d=4,o=7,b=225:2c6,c,a6,g6,e6,2g.6,2d6,p,
2c6,c,a6,g6,e6,2g.6,g6,p,p,a6,g#6,a6,e6,f6,g6,a6,p,f6,2d6,p,2a6
,a6,a6,b6,c, d,b6,a6,g6
Il testo che precede il primo carattere “:” (due punti) è ciò che il telefono cellulare
visualizza come nome del motivo-suoneria In questo caso, la suoneria si chiama:
TakeMeOutToTheBallGame:
(Portami alla partita)
Tra il primo e e il secondo carattere “:”, sono presenti le impostazioni predefinite per la
canzone usando d, o, e b. Ecco cosa significano queste lettere:
d – durata
o – ottava
b – battute per minuto o tempo.
In TakeMeOutToTheBallGame, le impostazioni predefinite sono:
d=4,o=7,b=225:
Le note della melodia sono inserite dopo il secondo carattere “:”, separate da virgole. Se
è usata proprio la lettera che rappresenta la nota (C sta per Do), quella nota sarà suonata
per la durata predefinita nell’ottava predefinita. Per esempio, la seconda nota in
TakeMeOutToTheBallGame è:
,c,
Poiché non ci sono altre informazioni, sarà suonata per la durata preimpostata della nota
da ¼ (d=4) (minima), nella settima ottava (o=7).
Una nota può avere fino a cinque caratteri tra le virgole; ecco cosa specifica ciascun
carattere:
,durata
nota
diesis
punto
ottava,
Ad esempio:
,2g#.6,
…significa suona la mezza nota G-diesis per 1 ½ la durata di una semi-nota, e suonala
nella sesta ottava.
Ecco alcuni esempi da TakeMeOutToTheBallGame:
,2g.6, – mezza nota, G, puntata, sesta ottava
,a6, – durata predefinita di un quarto di nota, nota A suonata in sesta ottava
,g#6, – durata un quarto, nota G, diesis (denotato da #), sesta ottava
Il carattere:
,p,
…sta per pausa, ed è usato per le pause (i riposi). Senza altre informazioni extra, la p
suona per la durata predefinita di un quarto di nota. Potete anche suonare un riposo di
valore metà nota usando:
,2p,
Ecco un esempio di un riposo puntato:
,2p.,
In questo caso, il riposo durerebbe metà nota più un quarto di nota.
Indice · Pagina 365
Indice
-$$ (Formattatore esadecimale), 222
-%% (Formattatore binario), 195
-*-
Apostrofo, 45
Area per i prototipi, 34
Argomenti, 42
ASCII, 293
Automazione, 350
-B-
** (Operatore Moltiplicazione Alta), 287
*/ (Operatore Moltiplicazione Media, 90, 287
-?? (simbolo = x formattatore), 48
-µµF (microfarad), 155
Base
di fototransistor, 215
di Transistor, 308
BASIC Stamp, 13, 345
BASIC Stamp Editor, 17
BASIC Stamp, confronto dei modelli, 345
-AAttivo-alto vs. attivo basso, 74
AD5220, potenziometro digitale, 311
Algoritmo, 92
Allarme armadietto, progetto-, 327
Alphabet Song, 274
Altoparlante piezoelettrico, 261
Amp, 355
AND, 82
Annidamento di subroutine, 234
Annidato, ciclo - 266
Anodo, 32
di display a 7 segmenti, 184
LED, 32
Batteria, 37
Battimento, 268
Bemolle, nota - (Flat), 270
Benamino Franklin, 38
Bicolore (LED), 54
Binario, 61
% (Formattatore binario), 195
Bit, 48, 193
dimensione di variabile, 48
Blocco di codice, 82
Booleani, 65
Breadboard, 34, 35, 311
BS1, 345
BS2, 345
BS2e, 345
Codice di commento, 45
BS2p24, 345
Collettore
BS2p40, 346
BS2pe, 346
di Transistor, 308
BS2px, 245, 346
Colore, spettro di- 211, 212
BS2sx, 345
COM, porta- 44
Bus, parallelo, 191
Commutare, 65
Byte, 48, 193
Comunicazione, prodotti di-, 341
dimensione di variable, 48
-CCadmio, solfuro di-, 211
Caratteri di controllo. Vedi DEBUG, caratteri di
controllo
Carica, 355
Carica negativa, 355
Catodo, 32
Catodo comune in display a 7 segmenti,
184
LED, 32
Catodo comune, 184
Chip Interprete, 305
Ciclo, 127, 261
Ciclo annidato, 249
Circuito aperto, 66
Circuito chiuso, 68
CLREOL, 180
CMOS, 65
Codice
blocco di-, 82
sovraccarico di-, 89
Condensatore (capacità), 155
- Ceramico, Simbolo di schema e disegno
di parte, 163
- Elettrolitico, 155
condensatore elettrolitico, simbolo di
schema e diagramma di parte, 156
capacità di giunzione, 251
polarità di- – terminali identificatori, 156,
157
- usati in parallelo, 239
Conduttore, 355
Costanti, 174
Costruire prototipi, 325
Concetto, prova di -, 326
Controllare, 65
Controllo di Processo, 350
Conteggio, 45, 87
Conversione da esadecimale a decimale, 220
Corrente, 30, 38, 355
Milliamp, 360
CR, 27
CRSRUP, 139
-D-
Diodo, tensione di conduzione, 359
Dadi e Volt delle colonne BASIC Stamps, 342
Dispositivo, parallelo, 191
DATA, 272
DIRH, 193
Datalogging (raccolta dati), 218
Display a 7 segmenti, 183, 184, 183–185
DCD, 286
DO…LOOP, 43, 87, 133
DEBUG, 39
DTMFOUT, 268
DEBUG, Caratteri di controllo, 139
Dual Tone Multi Frequency, 268
CLREOL, 180
-E-
CR, 27
Eco, 131
CRSRUP, 139
Editor (del BASIC Stamp), 17
HOME, 80
EEPROM, 218
DEBUG, Formattatori, 139
Elaborazione parallela, 346
$ (Formattatore esadecimale), 222
Elettrolitico, condensatore-, 155
% (Formattatore binario), 195
Elettrone, 37, 38, 355
? (simbolo = x formattatore), 48
Emettitore
DEC (Formattatore decimale), 129, 222
DEBUGIN, 129
di Transistor, 308
DEC, 129, 222
END, 68
Decimale
Errore di intervallo di variabile, 131
- formattatore DEC, 222
Errore di rollover a 16-bit, 131
- numeri, 198, 219
Esadecimale, formattatore - $, 222
Descrizione funzionale, 327
Esadecimali, numeri -, 183
Diagramma concettuale, 327
Esadecimale a decimale, conversione da -,
220
Diagramma di temporizzazione , 112
Diesis, nota - (sharp), 270
Diodo, 32
Diodo emettitore di luce (Light Emitting Diode).
Vedi LED
Diodi emettitori di luce, 32
Esplorazione (polling), 84
Esplorazione, esempio di -, 87
Etichetta, 232
EXIT, 299, 335
-FFarad, 177
Fetch and execute (Vai a prendere ed esegui),
305
Finestrella di Ricezione, 130
HOME, 80
HomeWork board
scheda- e divisore di tensione del circuito
RCTIME, 168
-I-
Finestrella di Trasmissione, 129-130
I/O pin (vedi Pin I/O)
Flat, nota - (bemolle), 270
IF…ELSEIF…ELSE, 79
FlexiForce, Sensore- , 339
IF…THEN, 82
FOR…NEXT, 45, 133
IF…THEN…ELSE, 75
Formattatore decimale DEC, 222
IN3, 71
Formattatori, DEBUG. Vedi DEBUG,
Formattatori
Incavo di riferimento, 311
Fotoresistenza, 211
Fototransistor, 210
Frazioni, 90
FREQOUT, 263, 267
Frequenza, 264
Funzionale, descrizione -, 327
-G-
Interi, matematica con - , 287
Interferenza, 268
Interprete, chip -, 305
Isteresi, 244
-J-KKCL (Kirchhoff Current Law, legge di Kirchhoff
sulla corrente), 358
Giunzione, capacità di -, 251
kHz, 263
Google, 343
Kilo, 360
GOSUB, 231
Kirchhoff, Leggi di - (semplificate)
GOTO, 232
Corrente, 359
Grado, 109
Voltaggio, 359
Grafico, tracciamento- di dati
software per il ----, 228
-Hhertz, 261, 263
HIGH, 42, 197
Kit delle parti di un telecomando a IR, 324
KVL, (Kirchhoff Voltage Law legge di Kirchhoff
sul voltaggio) 358
-LLCD, Display a- , 320
LCD Seriale 2x16, 340
LED, 29
Microsecond, 113
Bicolore, 54
Milli, 360
Come sensore di luce, 250
Millepiedi, Progetto, 16
Disegno di parte e simbolo di schema del
-, 33
Millisecondo, 42, 113
Legge di Ohm, 246, 359
Mini-timer, progetto - video di "Costruisci il tuo ", 350, 351
Leggi di Kirchhoff su Voltaggio e Corrente, 358
Misuratore di Luce, 229
Linguaggio per trasferire testi di suonerie
(RTTTL), 288
Motore, controllore di-, 341
LOOKDOWN, 201, 202
LOOKUP, 198
LOW, 42, 197
Luce, Misuratore di -, 229
Luce solare, 216
Luce Visibile, 210
Lunghezza d'onda, 211
-MmA, 360
Main, -routine (routine principale), 237
Massa (o Terra, Ground) 33, 359
Matematica, 287
Matematiche, Operazioni, 285
Memoria
Mappa di - (Memory Map), 218
Sovrascrivere il programma, 222
Mappa di memoria, 218, 222
Metriche, unità di misura -, 360
Microcontrollore, 13
Microcontrollore Propeller, 346
Microfarad, 155
Movimento,. Sensore PIR di -, 338
Musica
Punto (nota puntata), 281
Riposi (Pause), 275
Tempo, 277
Mistero, numeri del-, 336
-NNanometro, 211
Naturali, tasti -, 270
nc, 185
Negativa, carica -, 355
Neutro, 37
Neutrone, 355
Nib, 48
dimensione di variabile -, 48
Non collegato, 185
Nominale, valore -, 317
NPN, transistor -, 307
Nucleo, 355
Numeri
a Base 10, 198
a Base16, 198
dispositivo, 191
a Base 2, 71
Parallelo, condensatori in -, 239
Binari, 71, 193
Parallela, elaborazione -, 346
Decimali, 198
PAUSE, 42
Esadecimali, 198
PBASIC, Linguaggio-
Numeri binari, 71, 193, 195
AND, 82
Numeri decimali, 198, 219
Argomenti, 42
Numeri del mistero, 336
Bit, 48
Nuts and Volts, vedi Dadi e Volt
Byte, 48
-O-
CLREOL, 180
Offset, 171
CR, 27
Ohm, 355
CRSRUP, 139
Ohm, Legge di -, 246, 359
DATA, 272
Omega Ω, 30
DCD, 286
ON GOSUB, 232
DEBUG, 39
ON GOTO, 232
DEBUGIN, 129
Onde sonore (sound waves), 263, 268
DEC, 129, 222
Operatori PBASIC, vedi PBASIC, operatori
DIRH, 193
Operazioni matematiche, 285
DO…LOOP, 43, 87, 133
OR, 82
DTMFOUT, 268
Ottava, 270
END, 68
OUTH, 193
EXIT, 299, 335
Overflow, 290
FOR…NEXT, 45, 133
-PParallax, Servo Standard
FREQOUT, 263, 267
GOSUB, 231
Diagramma di parte, 101
GOTO, 232
Precauzione, 102
HIGH, 42, 197
Parallelo
bus, 191
HOME, 80
IF…ELSEIF…ELSE, 79
IF…THEN, 82
*/ (Moltiplicazione Media) , 90, 287
IF…THEN…ELSE, 75
DCD, 286
IN, 71
Ordine di esecuzione, 285
LOOKDOWN, 201, 202
Parentesi, 285
LOOKUP, 198
Piezo, vedi Piezoelettrico
LOW, 42, 197
Piezoelettrico, Altoparlante -, 261
Nib, 48
PIN (Direttiva - ), 175
ON GOSUB, 232
Pin I/O, protezione di -, 73
ON GOTO, 232
Pin I/O
OR, 82
Direzione (proprietà) di default, 196
OUTH, 193
registri DIRH e OUTH, 193
PAUSE, 42
Pin Input/Output Vedi Pin I/O
PIN, 175
Pin, mappa dei -, 184, 311
PULSOUT, 112-113
PIR. Sensore - di Movimento, 338
RANDOM, 91
Polling, vedi Esplorazione
RCTIME, 161, 213
Porta COM, 44
READ, 221
Porta COM Virtuale, 22
RETURN, 231
Positiva, carica- 355
SELECT…CASE, 289
Potenziometro, 151
SERIN, 335
AD5220 (- digitale), 311
SEROUT, 335
Presa, potenziometro, 317
STEP, 133
Principale, routine - (Main routine), 237
TOGGLE, 315
Processo, Controllo di - (Process Control), 350
UNTIL, 87, 133
Progetto millepiedi, 16
WHILE, 133
Progetto mini-timer - video di "Costruisci il tuo ", 350, 351
Word, 221
WRITE, 221, 222
PBASIC, Operatori
** (Moltiplicazione Alta), 287
Prodotti per comunicazioni, 342
Programma
Cicli, - annidati, 266
Sovrascrittura, 222
Programmi, Listati dei-
LampeggiaEntrambiILed.bs2, 53
LedAccesoSpento.bs2, 42
Cap01Pr01_Aggiungi1234.bs2, 28
LedAccesoSpentoDieciVolte.bs2, 47
Cap01Pr02_ PrimoProgrVostroTurno.bs2,
28
LedControllatoAPulsante.bs2, 76
Cap02Pr01_Conteggio.bs2, 64
LeggiMisureDiLuceDaEeprom.bs2, 225
LeggiPotConRcTime.bs2, 164
Cap03Pr01_TempoReazioneDueGiocator
i.bs2, 96
LeggiStatoPulsante.bs2, 72
Cap04Pr01Sol1_IntBlocco.bs2, 147
MemorizzaMisureDiLuceInEeprom.bs2,
222
Cap04Pr01Sol2_IntBlocco.bs2, 148
MicroMusicaConRtttl.bs2, 295
Cap05Pr01_ControlloServoConPot.bs2,
179
MisuratoreDiLuce.bs2, 235
Cap06Pr01_FishAndChips.bs2, 208
MusicaConPiuCaratteristiche.bs2, 282
Cap07Pr01_Controllo_Scuri.bs2, 258
NoteEDurate.bs2, 277
Cap07Pr02_ Controllo_Scuri_Extra.bs2,
259
PotDigitaleControllatoDaTerminale.bs2,
318
Cap08Pr01_GeneraTonoAPuls.bs2, 304
PotDigitaleSuGiu.bs2, 314
Cap09Es01_ImpostaPresaAZero.bs2,
321
PotDigitaleSuGiuConToggle.bs2, 315
Cap9Pr01_PotDigitaleFotoControllato.bs2
, 323
ProvaLedBiColore.bs2, 59
CentraServo.bs2, 113
CicliAnnidati.bs2, 266
ControlloAPulsanteDiDueLed.bs2, 79
ControlloServoAPulsanti.bs2, 143
ControllaServoConDebug.bs2, 131
ControlloServoConPot.bs2, 173
ControlloServoConPotEUsoDIrettive.bs2,
175
ProtoMicroAllarme(Dev-009).bs2, 333
ProvaFototransistorBinario.bs2, 249
ProvaFototransistor.bs2, 215
ProvaPiezoConFreqout.bs2, 247
ProvaSecondoLed.bs2, 52
ProvaSegmentoConAltoBasso.bs2, 192
RallentaSegnaliServoPerLed.bs2, 122
RcTimerEsplorato.bs2, 159
RicercaInversaSemplice.bs2, 202
CoppiaDiToni.bs2, 268
RicercaSemplice.bs2, 193
DoReMiFaSolLaSiDo.bs2, 271
ScegliTipoConCaratteri.bs2, 292
FototransistorAnalogicoABinario.bs2, 242
ScegliTipoConValori.bs2, 291
SubroutineSemplici.bs2, 232
Resistenza (componente), 30, 41
TempoReazione.bs2, 85
come protezione di pin I/O , 41
ToniAzione.bs2, 268
Disegno di parte e simbolo di schema, 31
TrePosizioniServo.bs2, 122
protezione pin I/O, 73
TwinkleTwinkle.bs2, 274
Rinforzo (Pull-up) e Indebolimento (Pulldown), 73
VelocitiaServo.bs2, 137
VisualizzaCifre.bs2, 193
VisualizzaCifreConRicerca.bs2, 199
VisualizzaQuadrante.bs2, 204
Prova di concetto, 326
Propeller, microcontrollore, 346
Protone, 355
Prototipi, Costruire - , 325
Prototipi, area per i -, 34
Pseudo codice, 76
Pseudo random, 92
Resistenze di Pull-up e Pull-down, 73
PULSOUT, 112-113
Punto, in musica, 281
Pulsante, 66
Attivo-alto, 74
-RRaccolta dati (Datalogging), 218
RANDOM, 91
Valori con Codice Colori, 31
Variabile, Flexiforce, 338
Variabile, potenziometro digitale, 311
Variabile, potenziometro, 151
Resistenza (proprietà fisica), 355
Riposi o pause, in musica, 275
RETURN, 231
Reveille (sveglia mattutina), 294
Ringing Tone Text Transfer Language, 288
Robotica con il Boe-Bot, 347
Rollover, errore di -, 131
Routine principale (Main routine), 237
RTTTL, 288
-SScalatura o riduzione in scala, 171
Schema (di circuito, 38
Simbolo schematico, 31
Schmitt, trigger di -, 245
RCTIME, 161, 213
Seed value for pseudo random numbers, 86,
87
READ, 221
SELECT…CASE, 272
Ricevere, 65
Sentire, 65
Riferimento, 359
Sensore FlexiForce, 339
Riferimento, incavo di-, 311
Sensore PIR.di Movimento, 338
Sensori (prodotti), 341
Etichetta, 232
Sensori Applicati (Applied Sensors), 349
Limite di annidamento, 234
Seriale, 2x16 LCD - , 340
SERIN, 335
SEROUT, 335
Servo
Avvertenza su alimentazione, 108
Avviso di precauzione, 102
Diagramma di Temporizzazione, 112
Servo Standard Parallax, vedi Parallax
Servo, ponticello tra i connettori del-, 103
Sharp, note - (diesis), 270
Simboli di programma, 218, 222, 305
Sistema incorporato, 13
Smart Sensors and Applications, 350
Smart Sensors and Applications, Testo -, 341
Software per tracciamento grafico di dati, 228
Sound waves. Vedi Onde sonore
Sovraccarico di codice, 89
Sovrapposizione, 268
Sovrascrivere il programma, 222
Specifica, 328
StampPlot LITE, 228
Suoni di Azione, 264
-TTake Me Out To The Ball Game (canzone per
suoneria), 363
Tasti naturali, 270
Telecomando, Kit di parti per - IR, 344
Tempo, 277
Terminale di Debug
Finestrelle di Trasmissione e Ricezione,
129-130
Terra (pianeta-), Misure dei clima, 350
Terra (pianeta-), Scienza della -, 350
Terra (o Massa, Ground) 33, 359
Testo "Smart Sensors and Applications", 349
Temporizzazione, diagramma di-, 112
TOGGLE, 315
Tolleranza, 32, 317
Tracciamento grafico di dati
software per il ----, 228
Transistor, 212, 308
Simbolo di schema e disegno di parte,
308
Stamps in Class. diagramma di flusso -, 349
Transistor NPN, 307
Stamps in Class, Mini Progetti, 350
Transistor-transistor logic (TTL), 245
STEP, 133
Trasmettere, 65
Subroutine, 231
Trigger di Schmitt, 245
Annidamento di -, 234
TTL, 65
Chiamata, 233
Twinkle Twinkle Little Star, 273-274
-U-
Vdd, 359
UNTIL, 87
Video tutorials, 350
USB drivers, 22
Video di Build Your Own Mini Timer project,
351
-VVai a prendere ed esegui (Fetch and execute),
305
Vin, 359
Virtuale, Porta COM -, 22
Valore nominale, 317
Visibile, Luce -, 210
Variabile, errore intervallo di -, 131
Volt, 355
Variabile, resistenza -, 339
Voltaggio, 38, 355
potenziometro (a rotazione), 151
Voltaggio, circuito per la caduta di, 157
potenziometro (digitale), 311
Voltaggio, divisore di -, 168
Variabili, 48
Bit, 48
Vss, 359
-W-
Byte, 48
WHILE, 133
DIRH, 193
Word (parola), 48
Inizializzazione, 86
Dimensione variabile, 48
Memorizzazione in RAM, 224
WORD, modificatore -, 221
Nib, 48
WRITE, 221, 222
OUTH, 193
Overflow, 290
Parola (word), 47
Regole per i nomi, 47
-ZZoccoli (Sockets), 34
-ΩΩ omega, 30
Le parti e le quantità sono soggette a cambiamento senza preavviso. Le parti possono
essere diverse da quanto mostrato in questa figura. Se avete domande su quanto ricevuto,
vi preghiamo di segnalarcelo all’indirizzo e-mail [email protected].

Che cosa è un Microcontrollore?

Transcript

Documenti analoghi

MWU SELV - TCI professional led applications

KAMELEON - KARMA ITALIANA Srl

TUNZE® LED

MP 39 K2 SELV - TCI professional led applications

KU2 SELV - TCI professional led applications

Voltmetro a led per Yaesu FT 857 / FT 897

Ma cosa abbiamo ascoltato negli ultimi 30 anni?

scarica dettaglio RLed72/100

SLIM/U SELV NEW - TCI professional led applications

1° COPPA di kata JUDO KIAI ATENA – PORTOGRUARO