Sensori Intelligenti e loro Applicazioni

Transcript

Sensori Intelligenti e loro
Applicazioni
Guida per lo Studente
VERSIONE 1.0
GARANZIA
La Parallax Inc. garantisce i suoi prodotti esenti da difetti nei materiali e nella mano d’opera per un periodo di 90
giorni dalla data di ricezione del prodotto. Se riscontrate un difetto, Parallax Inc., a sua scelta, riparerà o sostituirà la
merce, o rimborserà il prezzo di acquisto. Prima di rispedire il prodotto alla Parallax, telefonateci per ottenere un
numero di Autorizzazione al Rientro della Merce (RMA). Scrivete il numero RMA all’esterno della scatola utilizzata
per rispedire la merce alla Parallax. Vi preghiamo di accludere assieme alla merce i seguenti dati::il vostro nome, il
numero di telefono, l’indirizzo di spedizione e una descrizione del problema riscontrato. La Parallax restituirà il
vostro prodotto o il prodotto in sostituzione con lo stesso metodo di spedizione utilizzato per inviare il prodotto alla
Parallax.
GARANZIA DI RIMBORSO DEL DENARO ENTRO 14 GIORNI
(Garanzia Soddisfatti o rimborsati)
Se, entro 14 giorni dalla data di ricezione del prodotto, trovate che esso non soddisfa le vostre necessità, potete
restituirlo per essere totalmente rimborsati. La Parallax Inc. rimborserà il prezzo di acquisto del prodotto, ad
eccezione dei costi di spedizione/trattamento. Questa garanzia è nulla se il prodotto è stato modificato o danneggiato.
Si veda il precedente capitolo Garanzia qui sopra per le istruzioni sulla restituzione di un prodotto alla Parallax.
COPYRIGHT E MARCHI DI FABBRICA
Questa documentazione ha il copyright 2006 della Parallax Inc. Scaricando dal sito o utilizzando una copia stampata
di questo documento o software acconsentite che esso dovrà essere utilizzato esclusivamente con prodotti Parallax.
Qualsiasi altro utilizzo 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 utilizzi commerciali è espressamente vietata dalla Parallax Inc. La duplicazione per uso didattico
è consentita, alle condizioni seguenti: il testo, oppure qualsiasi sua parte, non può essere duplicato per utilizzo
commerciale; può essere duplicato soltanto per scopi educativi quando si utilizzi unicamente assieme a prodotti
Parallax, e l’utente può esigere dallo studente soltanto i costi di riproduzione.
Questo testo è disponibile in forma stampata dalla Parallax Inc. Poiché noi stampiamo il testo come volume, il
prezzo al consumatore è spesso inferiore alle tariffe al dettaglio ordinarie richieste per la duplicazione.
BASIC Stamp, Stamps in Class, Board of Education, Boe-Bot, SumoBot, SX-Key e Toddler sono marchi registrati
della Parallax, Inc. HomeWork Board, Propeller, Ping))) Parallax, e il logo Parallax sono marchi di fabbrica della
Parallax, Inc. Se decidete di utilizzare i marchi di fabbrica della Parallax Inc. nella vostra pagina web o in materiali
stampati, dovrete affermare che "(marchio di fabbrica) è marchio di fabbrica (registrato) della Parallax Inc.” fin dalla
prima comparsa del nome del marchio di fabbrica in ciascun documento stampato o pagina web. Altri nomi di
marche e prodotti sono marchi di fabbrica o marchi di fabbrica registrati dei loro rispettivi proprietari.
ISBN 1-928982-39-5
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 qualsiasi danno a
persone, compresi i danni di vita e salute, che risultino dall’utilizzo di qualsiasi nostro prodotto. Vi assumete la
responsabilità completa per la vostra applicazione BASIC Stamp, indipendentemente dal fatto che essa possa essere
di minaccia per la vostra vita.
RD
3 RISTAMPA
FORUM DI DISCUSSIONE SU INTERNET (WEB)
Manteniamo in attività sul web forum di discussione per persone interessate a prodotti Parallax. Questi elenchi sono
accessibili dal sito www.parallax.com:
•
•
•
•
•
Propeller chip – Questo elenco è di uso specifico dei nostri clienti che usano i chip e i prodotti Propeller
(Propulsori, eliche).
BASIC Stamp – Questo elenco è largamente utilizzato da ingegneri, hobbisti e studenti che
condividono i loro progetti BASIC Stamp e pongano domande sull’argomento.
®
Stamps in Class – Elenco creato per insegnanti e studenti, dove i sottoscrittori discutono l’utilizzo del
curriculum Stamps in Class curriculum nei loro corsi. L’elenco fornisce una opportunità sia agli
studenti che agli insegnanti di fare domande e ottenere risposte.
Insegnanti Parallax – Un forum private riservato esclusivamente agli insegnanti e a coloro che
contribuiscono allo sviluppo del Stamps in Class. La Parallax ha creato questo gruppo per ottenere una
risposta ai nostri curricula e per fornire un luogo dove gli educatori sviluppino ed ottengano le loro
Guide per l’Insegnante.
Robotica – Progettato per I robot Parallax, questo forum vuole essere un dialogo aperto tra gli entusiasti
di robotica. Gli argomenti trattati comprendono l’asseblaggio, il codice sorgente, gli ampliamenti, e gli
aggiornamenti manuali.
®
•
•
®
®
Qui si discute in dettaglio dei robot Boe-Bot , Toddler
(principiante),
SumoBot (lottatore di Sumo), HexCrawler (che striscia a esagono) e QuadCrawler (che striscia a
quadrato).
Microcontrollori SX e codice SX – Discussione della programmazione di un microcontrollore SX con il
linguaggio assemblatore SX Parallax – Strumenti chiave e compilatori di terze parti BASIC e C.
Javelin Stamp – Discussione su applicazioni e progetti che utilizzano il Javelin Stamp, un modulo
Parallax, programmato utilizzando un sottoinsieme del linguaggio di programmazione Java della Sun
Microsystems.
ERRATA
Anche se si fa un grosso sforzo per assicurare la correttezza dei nostri testi, possono ancora essere riscontrati errori.
Se trovate un errore , vi preghiamo di comunicarcelo inviando una e-mail all’indirizzo [email protected]. Ci
sforziamo continuamente di migliorare tutti i nostri materiali e la nostra documentazione didattici, e rivediamo
frequentemente i nostri testi. 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. Vi preghiamo di controllare la pagina del
download gratuito per il singolo prodotto, per controllare se esiste un file di Errata.
We maintain active web-based discussion forums for people interested in Parallax products. These lists are accessible
from www.parallax.com:
Indice· Pagina i
Indice
Prefazione ..................................................................................................................iii
Introduzione e nota dell’autore ....................................................................................... iii
Panoramica v
Prima di iniziare ..............................................................................................................v
La serie didattica dei testi Stamps In Class ................................................................... vi
Traduzioni in altre lingue ............................................................................................... vii
Contributi speciali .......................................................................................................... vii
Capitolo 1: Il display LCD seriale Parallax .............................................................1
Display LCD nei Prodotti ............................................................................................... 2
Il display seriale LCD Parallax – Il vostro terminale mobile di debug .............................2
Attività #1: Connessione e prova del LCD ......................................................................4
Attività #2: Visualizzazione di semplici messaggi ...........................................................8
Attività #3: Applicazione di Timer ..................................................................................18
Attività #4: Caratteri personalizzati e animazione del LCD .......................................... 20
Attività #5: Scorrimento di un testo attraverso il display .............................................. 27
Sommario ...................................................................................................................36
Capitolo 2: Il sensore ultrasonico di distanze Ping))).......................................... 43
Come lavora il sensore Ping)))? ................................................................................ 43
Attività #1: Misura del tempo di eco ............................................................................. 44
Attività #2: Misure in centimetri .................................................................................... 48
Attività #3: Misure in pollici ........................................................................................... 51
Attività #4: Misure in movimento .................................................................................. 54
Attività #5: Effetto della temperatura sulla velocità del suono ...................................... 62
Sommario ..................................................................................................................65
Capitolo 3: L’accelerometro Memsic a due assi ...................................................69
L’accelerometro MX2125 – Come lavora .................................................................... 71
Attività #1: Connessione e prova di inclinazione del MX2125 ..................................... 72
Attività #2: Misure in movimento .................................................................................. 75
Attività #3: Riduzione in scala (scalatura) e spostamento (rispetto all’origine) dei
valori di ingresso (offset) …………….……………………………………… 80
Attività #4: Dimensionamento a 1/100 g ....................................................................... 88
Attività #5: Misure di rotazione verticale a 360° ........................................................... 90
Attività #6: Misura dell’inclinazione dalla posizione orizzontale ................................. 105
Sommario ................................................................................................................ 119
Capitolo 4: Il modulo bussola Hitachi HM55B ....................................................127
Interpretazione delle misure della bussola ..................................................................127
Pagina ii · Sensori intelligenti e loro applicazioni
Attività #1: Connessione e prova del modulo bussola ................................................128
Attività #2: Taratura del modulo bussola ....................................................................136
Attività #3: Prova della taratura ...................................................................................146
Attività #4: Miglioramento delle misure della bussola tramite media dei valori ...........152
Attività #5: Misure in movimento .................................................................................158
Sommario ................................................................................................................170
Capitolo 5: Fondamenti base di gioco con l’accelerometro ............................. 179
Attività #1: Visualizzazione di caratteri grafici PBASIC ...............................................180
Attività #2: Memorizzazione e suo ripristino con la EEPROM ....................................192
Attività #3: Inclinazione dle grafico a bolle...................................................................202
Attività #4: Controllo di gioco ......................................................................................210
Sommario ................................................................................................................221
Capitolo 6: Ulteriori progetti con l’accelerometro ............................................. 227
Attività #1: Misura del’altezza di edifici, alberi e altro . ................................................227
Attività #2: Registrazione e riproduzione ....................................................................230
Attività #3: Utilizzo della EEPROM per cambiare modo di funzionamento .................236
Attività #4: Registrazione a distanza dei dati di accelerazione ...................................240
Attività #5: Studio della accelerazione di un’automobile RC (a distanza) ...................248
Attività #6: Studio del trucco di accelerazione di uno Skate-board .............................259
Attività #7: Distanza in bicicletta .................................................................................267
Sommario ................................................................................................................276
Capitolo 7: Grafici a barre LCD per distanza e inclinazione ............................. 285
Attività #1: Scorrimento di caratteri personalizzati ......................................................285
Attività #2: Grafici a barre orizzontali per la distanza nel sensore Ping))) ................2968
Attività #3: Grafici a barre a due assi per l’inclinazione dell’accelerometro ................306
Sommario ................................................................................................................319
Appendice A: Tavola del Codice ASCII................................................................ 329
Appendice B: Documentazione del LCD seriale Parallax ................................. 331
Appendice C: Definizione dei caratteri esadecimali .......................................... 345
Appendice D: Elenco dei componenti ................................................................ 349
Indice ....................................................................................................................... 353
Prefazione · Pagina iii
Prefazione
INTRODUZIONE E NOTA DELL’AUTORE
La prima volta che ho visto utilizzare il termine "sensori intelligenti" è stato nel testo
Applied Sensors di Tracy Allen (noto attualmente col titolo Earth Measurements). Tracy
ha applicato attivamente questo termine al termometro digitale DS1620, che incorpora
alcuni circuiti elettronici che semplificano le misure di temperatura del microcontrollore.
In aggiunta, il termometro può ricordare le impostazioni che riceve da un
microcontrollore e persino funzionare autonomamente da controllore di un termostato.
In contrasto con i sensori intelligenti, i sensori primitivi sono dispositivi o materiali con
alcune proprietà elettriche che cambiano in funzione di un determinato fenomeno fisico.
Un esempio di sensore primitivo tratto da What's a Microcontroller? è il fotoresistore al
solfuro di cadmio. La sua resistenza cambia al variare dell’intensità della luce. Con un
circuito e un programma adatti, il microcontrollore può effettuare misure di luce. Altri
esempi di sensori primitivi di uso comune sono i sensori di temperature con uscita in
corrente/voltaggio, i trasduttori di microfoni, e perfino il potenziometro, che è un sensore
di posizione rotativa.
All’interno di ciascun sensore intelligente sono presenti uno o più sensori primitive e i
relativi circuiti di supporto. La cosa che rende “intelligente” un sensore intelligente è
l’elettronica aggiunta, incorporata nel sensore . L’elettronica rende questi sensori capaci
di fare una delle cose elencate qui di seguito:
•
•
•
•
•
Pre-elaborare i valori delle loro misure in quantità significative
Comunicare le loro misure tramite segnali digitali e protocolli di comunicazione
Organizzare le azioni di sensori e circuiti primitivi in modo che “acquisiscano” le
misure
Prendere decisioni e iniziare azioni basate su condizioni “sentite”, indipendenti
dal microcontrollore
Ricordare impostazioni di taratura o di configurazione
Durante il mio primo contatto con un sensore intelligente, ho pensato tra me e me, "Uau,
un kit completo di questi sensori intelligenti con un libro potrebbe essere REALMENTE
interessante! Certamente spero che qualcuno faccia un kit e un libro del genere quanto
prima..." Poco sapevo del fatto che "quanto prima" sarebbe finito per essere quasi sei
anni più tardi, e che il "qualcuno" sarebbe capitato che fossi io. E se uno dei miei capi mi
Pagina iv · Sensori intelligenti e loro applicazioni
avesse detto prima che il kit doveva contenere un accelerometro, un rilevatore di percorso
ad ultrasuoni, una bussola digitale e un LCD seriale per misure in movimento, avrei
potuto semplicemente scollarmi. Dal momento che soltanto di recente era stato possibile
per noi mettere assieme un gruppotanto imponente di componenti in un singolo kit, avrei
dovuto dire che valeva la pena di aspettare.
Nel mantenersi all’altezza delle rimanenti opere didattiche sullo Stamps in Class, questo
libro rappresenta una raccolta di attività (esercitazioni), alcune delle quali riguardano
applicazioni di base, altre applicazioni più avanzate e alcune sono applicazioni
dimostrative o blocchi costruttivi per vari prodotti e/o invenzioni. La prima metà del
libro presenta ciascun sensore, assieme ad alcune misure in movimento visualizzate dal
LCD. Successivamente, la seconda metà del libro riporta una quantità di applicazioni che
possono essere direttamente sperimentate, come giochi video con inclinazioni, strumenti
di misura personalizzati, e dispositivi diagnostici per impieghi in hobby e sport. Il limite
di pagine per mantenere questi libri all’interno delle nostre scatole di confezionamento è
350, ed è stato davvero difficile mantenere questo valore. Si possono trovare attività
aggiuntive sui sensori intelligenti per il robot Boe-Bot nel forum Stamps in Class al sito
www.parallax.com.
Mentre questo libro copre i fondamenti di base e dimostra alcune applicazioni di ò fare
esempio, esso sfiora abbastanza superficialmente quanto si può fare con questi
dispositivi. Lo scopo principale di questo libro è fornire alcuni “mattoni” e idee per
progetti e invenzioni future da fare in classe.. ad esempio, dopo aver completato il
capitolo 3, Kris Magri, revisore editoriale del nostro libro, mise la sua Board of
Education con l’accelerometro e il LCD sul cruscotto della sua auto, e adesso la sua auto
ha un misuratore dell’accelerazione in pianura oltre al tachimetro. Con poche modifiche
al codice del programma, si può rendere questo un sistema di allarme di ribaltamento per
un veicolo a 4 ruote motrici. Dopo aver osservato un dispositivo di osservazione
meccanico utilizzato per predire il verificarsi di valanghe in aree montagnose basandosi
sull’inclinazione delle colline, Ken Gracey si mise all’opera e costruì la versione digitale
in una sola notte con le stesse parti installate sul cruscotto dell’auto di Kris.
I misuratori di accelerazione e rischio di valanghe da cruscotto sono soltanto due degli
esempi romanzeschi del gran numero di applicazioni, progetti e invenzioni che il kit e il
testo sui Sensori Intelligenti possono suggerire. Ci piacerebbe vedere cosa fate col
vostro kit sul forum Stamps in Class. Non importa se pensate che il vostro progetto
risulti semplice, unico, banale o quant’altro. Spendete pochi minuti per inviare quello
che avete fatto con questi sensori intelligenti al sito http://forums.parallax.com/forums/
Prefazione · Pagina v
→ Stamps in Class. Assicuratevi di includere qualche istantanea, una breve descrizione e
preferibilmente lo schema e il programma PBASIC.
Divertitevi con questo kit e con il libro, e noi aspettiamo di vedere le vostre invenzioni
sul forum Stamps in Class.
PANORAMICA
Il kit di sensori intelligenti contiene quattro dispositivi che, quando si utilizzano con il
BASIC Stamp e la scheda Board of Education o la scheda HomeWork, possono essere i
mattoni costruttivi di una gran varietà di invenzioni e progetti di studenti. Ecco l’elenco
dei dispositivi:
•
•
•
•
LCD seriale 2x16 Parallax
Rilevatore (sensore) Ultrasonico di distanze Ping)))
Accelerometro Memsic 2125 a due assi
Modulo bussola Hitachi HM55B
Oltre a fornire sia le apparecchiature che le informazioni sui modi di usarle nei progetti
degli studenti, questo testo ha evidenziato due argomenti principali che forniscono teoria,
esempi, e calcoli richiesti, utilizzabili per effettuare una gran varietà di misure, con
fisica/ingegneria e concetti di trigonometria. Questi argomenti evidenziati sono:
•
•
Tecniche matematiche per convertire i valori grezzi dei sensori in misure che
siano significative perché espresse in sistemi di unità di misura usati
abitualmente
Interpretazione dei campi vettoriali gravitazionale e magnetico su un sistema di
assi Cartesiani sensibili.
PRIMA DI INIZIARE
Per effettuare gli esperimenti presenti in questo testo, vi occorre la vostra scheda (o
basetta) Board of Education, o la HomeWork, connessa al vostro computer; inoltre,
occorre aver installato il software editore BASIC Stamp, e aver verificato che ci sia
comunicazione tra il vostro computer e il vostro BASIC Stamp. Per istruzioni dettagliate,
vedere il testo Che cos’è un microcontrollore? (What’s a Microcontroller?) disponibile
per essere scaricato gratuitamente dal sito www.parallax.com. Avrete anche bisogno dei
componenti contenuti nel Kit Componenti dei Sensori Intelligenti. Vedere l’appendice D
per l’elenco completo dei requisiti di sistema, software e hardware.
Pagina vi · Sensori intelligenti e loro applicazioni
LA SERIE DIDATTICA DEI TESTI STAMPS IN CLASS
La serie di testi e kit Stamps in Class fornisce risorse affidabili per insegnare elettronica e
ingegneria. Tutti i libri elencati sono disponibili per lo scarico gratuito dal sito
www.parallax.com. Le versioni citate qui sotto sono quelle correnti al momento della
stampa di questo testo. Vi preghiamo di controllare i nostri siti web www.parallax.com o
www.stampsinclass.com per trovare le ultime revisioni; noi facciamo continuamente ogni
sforzo per migliorare il nostro programma didattico.
Guide per lo Studente Stamps in Class:
Cos’è un microcontrollore? (What’s a Microcontroller?) è il testo raccomandato come
testo introduttivo della serie didattica Stamps In Class. Alcuni studenti partono, invece
con Robotica con il Boe-Bot (Robotics with the Boe-Bot), anch’esso scritto per i
principianti.
“What’s a Microcontroller?”, Student Guide, Version 2.2, Parallax Inc., 2004
“Robotics with the Boe-Bot”, Student Guide, Version 2.2, Parallax Inc., 2004
“Robotica con il Boe-Bot”, Guida per lo studente, Vers. 2.1, Parallax Inc., 2002
Potete proseguire con altri argomenti del vostro progetto didattico, oppure desiderate
esplorare i nostri altri Kit di Robotica.
Kit di Progetto didattico:
I seguenti testi e kit forniscono una varietà di attività utili per hobbyisti, inventori e
progettisti di prodotti interessati a sperimentale una vasta gamma di progetti.
“Smart Sensors and Applications”, Student Guide, Version 1.0, Parallax Inc.,
2006
“Sensori intelligenti e loro applicazioni”, Guida per lo Studente, Versione 1.0,
Parallax Inc., 2009
“Process Control”, Student Guide, Version 1.0, Parallax Inc., 2006
“Applied Sensors”, Student Guide, Version 1.3, Parallax Inc., 2003
“Basic Analog and Digital”, Student Guide, Version 1.3, Parallax Inc., 2004
“Understanding Signals”, Student Guide, Version 1.0, Parallax Inc., 2003
Prefazione · Pagina vii
Kit di Robotica:
Per fare esperienza con la robotica, prendete in considerazione di continuare con le
seguenti guide per lo studente Stamps in Class, ciascuna delle quali ha un corrispondente
kit di robot:
“IR Remote for the Boe-Bot”, Student Guide, Version 1.1, Parallax Inc., 2004
“Applied Robotics with the SumoBot”, Student Guide, Version 1.0, Parallax
Inc., 2005
“Advanced Robotics: with the Toddler”, Student Guide, Version 1.2, Parallax
Inc., 2003
Riferimenti
Questo libro è il riferimento essenziale per tutte le Guide per lo Studente Stamps in Class.
E’ accompagnato dalle informazioni sulla serie di moduli microcontrollori BASIC
Stamp, il nostro editor BASIC Stamp, e i nostril linguaggi di programmazione PBASIC.
“Manuale del BASIC Stamp”, Versione 2.2, Parallax Inc., 2005
TRADUZIONI IN ALTRE LINGUE
I testi didattici Parallax possono essere tradotti in alter lingue con il nostro permesso
(scrivere per e-mail a [email protected]). Se pianificate di fare qualsiasi
traduzione vi preghiamo di prendere contatto con noi, così potremo fornirvi correttamente
in formato MS Word documenti, immagini, etc. Abbiamo anche un gruppo di discussione
privato per i traduttori Parallax al quale potrete unirvi. Ciò vi assicurerà di essere
mantenuto al corrente sulle nostre frequenti revisioni dei testi.
CONTRIBUTI SPECIALI
La Parallax Inc. è lieta di presentare i membri della sua Squadra Didattica: Direttore di
Progetto Aristides Alvarez, Illustratore Tecnico Rich Allred, Progettista Grafico Larissa
Crittenden, Revisore Tecnico Kris Magri, e Editor Tecnico Stephanie Lindsay. In
aggiunta, si ringrazia il cliente Steve Nicholson per l’esecuzione di prova della maggior
parte delle attività. Come sempre, ringraziamenti speciali vanno a Ken Gracey, il
fondatore del programma educativo Stamps in Class della Parallax Inc..
Pagina viii · Sensori intelligenti e loro applicazioni
Capitolo 1: Il display LCD seriale Parallax · Pagina 1
Capitolo 1: Il Display Seriale LCD Parallax
Visualizzare in formato leggibile le informazioni che un sensore invia ha molti usi, e in
alcune applicazioni, è tutto ciò che conta. Il termometro digitale è un esempio comune
che si può trovare in molte famiglie. Dentro ciascun termometro digitale, c’è una sonda
per la temperatura, un microcontrollore, e un display (visualizzatore) a cristalli liquidi
(LCD) per visualizzare le misure. Il microcontrollore BASIC Stamp e il LCD seriale
Parallax mostrati in Figura 1-1 possono fornire gli elementi microcontrollore e display
per questo tipo di prodotto. Questo allestimento è inoltre molto buono per la
visualizzazione di misure in movimento, rendendo possibile scollegare la vostra scheda
dal PC e dal Terminale di Debug e collaudare sul campo il vostro sensore intelligente.
Figura 1-1: BASIC Stamp, Board of Education, e LCD Seriale Parallax
Le attività in questo capitolo introducono alcune caratteristiche di base del LCD Parallax,
come la connessione del LCD al BASIC Stamp, la sua accensione e spegnimento, il
posizionamento del suo cursore, e la visualizzazione di testo e cifre. I capitoli successivi
vi insegneranno a creare ed animare caratteri personalizzati e visualizzare messaggi che
scorrono.
Pagina 2 · Sensori intelligenti e loro applicazioni
DISPLAY LCD NEI PRODOTTI
I prodotti mostrati nella Figura 1-2 hanno tutti un display a cristalli liquidi. Essi sono di
facile lettura, e quelli più piccoli consumano una potenza molto piccola. Pensate a quanti
prodotti possedete con display a cristalli liquidi. Pensate anche, mentre eseguite queste
attività nei vari progetti BASIC Stamp, ai prototipi e alle invenzioni che avete incontrato
nel vostro lavoro, e a come un LCD seriale può enfatizzare o aiutare il completamento di
tali progetti.
Figura 1-2: Esempi di prodotti con Display LCD
In senso orario da sinistra in alto: telefono cellulare, unità GPS portatile, calcolatore,
multimetro digitale, orologio da ufficio, notebook, oscilloscopio, telefono da ufficio.
IL DISPLAY SERIALE LCD PARALLAX – IL VOSTRO TERMINALE
MOBILE DI DEBUG
Se avete lavorato con uno qualsiasi degli altri testi Stamps in Class, vi sarà probabilmente
familiare che strumento di valore possa essere il terminale di Debug. Il terminale di
Debug è una finestra che potete utilizzare per far visualizzare al vostro computer i
messaggi che riceve dal BASIC Stamp. E’ utile in modo particolare per visualizzare i
messaggi diagnostici e i valori variabili, e rende agevole isolare le pecche dei programmi.
E’ inoltre uno strumento molto maneggevole per provare i circuiti, i sensori e altro
ancora.
Il terminale di Debug ha uno svantaggio, cioè la connessione tramite un cavo seriale.
Considerate quante volte non sia stato conveniente dover avere la vostra scheda connessa
al computer per provare un sensore, oppure cercare cosa sta “vedendo” il robot Boe-Bot
con i suoi rilevatori di oggetti a infrarossi in un’altra stanza. Sono tutte situazioni cui si
può porre rimedio con il LCD seriale Parallax mostrato in Figura 1-3. Non appena avrete
costruito un circuito di controllo di un sensore sulla Board of Education, potrete utilizzare
una batteria e il LCD seriale Parallax per prendere le impostazioni lontani quanto vorrete
dalla vostra stazione di programmazione, visualizzando nel frattempo le misure del
sensore e altre informazioni diagnostiche.
Figura 1-3
LCD Seriale
Parallax (2×16)
Il LCD Seriale Parallax 2×16 ha due righe larghe sedici caratteri per la visualizzazione di
messaggi. Il display è controllato dal BASIC Stamp tramite messaggi seriali. Il BASIC
Stamp invia questi messaggi da un singolo piedino di I/O pin connesso all’ingresso seriale
del LCD. Ce ne sono due versioni, standard e retro-illuminato:
Versione
# di Parte Parallax
Standard
27976
Retro-illuminato
27977
LCD Seriali oppure Paralleli
Il tipo più frequente di LCD è il LCD Parallelo. Esso richiede tipicamente un minimo di 6
piedini I/O per il controllo da parte del BASIC Stamp. Inoltre, fin quando non utilizziate un
BASIC Stamp 2p, 2pe, o 2px, il codice per controllarli tende ad essere più complesso del
codice per il LCD seriale.
Il LCD seriale è in realtà soltanto un LCD parallelo con un microcontrollore extra. Il
microcontrollore extra sul LCD seriale converte i messaggi seriali dal BASIC Stamp in
messaggi paralleli che controllano il LCD parallelo.
ATTIVITA’ #1: CONNESSIONE E PROVA DEL LCD
Assieme alle connessioni elettriche e ad alcuni semplici programmi PBASIC di prova per
il LCD Seriale Parallax, questa attività vi presenta il comando SEROUT. Essa serve anche
a dimostrare come il commando DEBUG sia soltanto un caso particolare di SEROUT. ciò è
particolarmente utile per lavorare con il vostro LCD seriale perché potete prendere molti
degli argomenti del commando DEBUG e utilizzarli con il comando SEROUT per controllare
e preformare le informazioni che il vostro LCD visualizza.
Componenti richiesti
(1) LCD seriale Parallax 2×16
(3) Cavallotti di filo
In aggiunta al LCD seriale Parallax e ai tre fili, sarà particolarmente importante avere la
documentazione del LCD seriale Parallax (inclusa in questo testo come Appendice B).
Sebbene siano appena poche pagine, essa contiene un lungo elenco di valori che dovrete
inviare al vostro LCD per fargli eseguire funzioni simili a quelle che avete utilizzato con
il terminale di Debug. Il controllo del cursore, i ritorni carrello, i comandi cancella
schermo e così via, hanno tutti i loro codici speciali. In alcuni casi, questi codici sono
identici a quelli per il terminale di Debug; in altri casi, sono del tutto differenti.
Costruzione del circuito per il LCD seriale
Connettere il LCD seriale Parallax al BASIC Stamp è meravigliosamente semplice, come
mostra la Figura 1-4. Vi serve di fare soltanto tre connessioni: una per la alimentazione,
una per la terra, e una per il segnale. Il piedino RX del LCD è quello del segnale e dovrà
essere connesso ad un piedino I/O del BASIC Stamp. In questa attività, utilizzeremo il
piedino P14. Il piedino GND (terra) del LCD dovrà essere connesso a Vss sulla Board of
Education, e il piedino 5 V del LCD dovrà essere connesso a Vdd.
ATTENZIONE: Gli errori di cablaggio possono danneggiare questo LCD.
La Rev D e i modelli precedenti di questo LCD avevano cinque piedini. Se avete un
modello a 5 piedini, vi preghiamo di vedere la Figura B-1 a pagina 335 per verificare i
piedini corretti da utilizzare nei circuiti descritti in questo libro.
La versione a cinque piedini NON è compatibile nei piedini con i modelli Scott
Edwards o Matrix Orbital. Se avete utilizzato in precedenza altre marche di LCD seriali,
state in guardia perché la piedinatura del LCD è diversa. Non fate l’errore di utilizzare lo
stesso cablaggio utilizzato per gli altri modelli.
√
√
√
√
√
Togliete energia alla vostra Board of Education.
Connettete lo zoccolo Vss della Board of Education al piedino GND del LCD.
Connettete lo zoccolo P14 della Board of Education's al piedino RX del LCD,
come mostrato in Figura 1-4.
Connettete lo zoccolo Vdd della Board of Education al piedino 5V del LCD
Non ridate ancora energia.
Figura 1-4: Schema elettrico e Diagramma di cablaggio
LCD Parallax
Prova del LCD Seriale
Il LCD seriale Parallax ha un modo per la prova automatica (auto-prova) che potrete
utilizzare per assicurarvi che è in ordine di lavoro e che il suo contrasto è predisposto in
modo adeguato. La Figura 1-5 mostra la parte posteriore (inferiore) del modulo LCD. Gli
interruttori etichettati SW1 e SW2 servono per il modo auto-prova e per la regolazione
della velocità di trasmissione, e inoltre è presente un potenziometro per la regolazione del
contrasto, etichettato “INCREASE CONTRAST” (“AUMENTA CONTRASTO”).
Figura 1-5
Moduleo LCD –
Vista posteriore
√
√
√
√
√
L’alimentazione della vostra scheda deve essere ancora spenta.
Trovate SW1 e SW2 sul lato inferiore del modulo LCD mostrato in Figura 1-6 .
Ponete SW1 off.
Ponete SW2 off.
Ridate adesso l’alimentazione.
Figura 1-6
Porre gli interruttori
della velocità di
trasmissione al
modo auto-prova
√
Quando ridate tensione, il LCD deve visualizzare il testo "Parallax, Inc." sulla
riga superiore (Riga 0) e "www.parallax.com" sulla riga inferiore (Riga 1), come
potrete anche vedere nella Figura 1-3. Se lasciate il LCD in questo modo per un
po’, apparirà un carattere familiare retaggio dei video giochi del 1980, che
mangerà tutto il testo.
√
Se il display appare scuro o sembra vuoto, c’è un potenziometro di regolazione
del contrasto mostrato nella Figura 1-7 che potrete girare con un cacciavite. Se il
display è già chiaro e tutti i caratteri appaiono bene, probabilmente non dovrete
regolarlo. Se i caratteri sono troppo poco visibili, o appaiono in scatole grigie, la
regolazione del potenziometro dovrebbe aiutarvi.
√
Se occorre, regolate il potenziometro del contrasto.
Figura 1-7
Potenziometro di
regolazione del
contrasto
Regolazione del LCD per ricevere messaggi dal BASIC Stamp
La comunicazione seriale comporta una velocità di trasmissione (in baud) .Questa è il
numero di bit per secondo (bps) che colui che invia trasmette, e chi riceve deve essere
pronto a ricevere i dati alla stessa velocità in baud. Nelle attività di questo capitolo, il
BASIC Stamp sarà programmato per inviare messaggi al LCD a 9600 bps. Potrete
regolare gli stessi interruttori che avete utilizzato per la auto-prova del LCD per
impostare la velocità di trasmissione.
√
√
√
√
Togliete l’alimentazione alla Board of Education.
Lasciate lo SW1 in posizione OFF.
Ponete lo SW2 in ON come mostrato in Figure 1-8.
Adesso ridate l’alimentazione.
Lo schermo del display rimarrà vuoto fin quando non programmate che il BASIC Stamp
2 controlli il display.
Figure 1-8
Interruttori della
velocità di
trasmissione a
9600 bps
La Figura 1-9 mostra la tabella dei modi stampata sulla parte posteriore del LCD seriale
Parallax. Se volete inviare un messaggio a velocità diverse da quella prevista, (2400 o
19.200 bps), utilizzate questa tabella e regolate SW1 e SW2 di conseguenza.
Figura 1-9
Predisposizione
degli interruttori
per la velocità di
trasmissione
ATTIVITA’ #2: VISUALIZZAZIONE DI SEMPLICI MESSAGGI
Come accennato prima, i comandi che inviano testo, numeri, caratteri di formato e codici
di controllo (caratteri di controllo) ad un LCD seriale sono collegati al comando DEBUG.
Infatti, il commando DEBUG è soltanto una versione speciale di un comando più generale
chiamato SEROUT. Il comando SEROUT ha parecchi usi, alcuni dei quali comprendono
l’invio di messaggi agli LCD seriali, ad altri moduli BASIC Stamp, e a computer.
In questa attività, programmerete il BASIC Stamp per far visualizzare al LCD messaggi
di testo e valori numerici. Come primo passo verso le animazioni, modificherete anche i
programmi per far lampeggiare testo e numeri on e off. Il comando SEROUT sarà il vostro
strumento per effettuare queste operazioni. Utilizzerete il comando SEROUT per inviare al
LCD Parallax seriale testo, numeri, codici di controllo e caratteri di formato. Come
vedrete presto, il testo, i numeri, e i caratteri di formato sono identici a quelli che avete
utilizzato con il comando DEBUG. I codici di controllo sono un po’ diversi ma, con un pò
di pratica, risulteranno altrettanto facili da usare di CR, CLS, HOME, e CRSRXY. (Se non
avete familiarità con CRSRXY, potrete imparare di più su di esso nel Capitolo 5, Attività
#1.)
La versione minima della sintassi del comando SEROUT appare come questa:
SEROUT Piedino, BaudMode, [ Elemento Dati, {Elemento dati, ...} ]
Nei nostril programmi, l’argomento Piedino deve essere 14 visto che il piedino RX (ricevi
dato) del LCD è connesso al piedino I/O P14 del BASIC Stamp.
L’argomento BaudMode è un valore che dice al BASIC Stamp quanto velocemente dovrà
mandare i dati seriali, e determina di conseguenza alcune caratteristiche del segnale
seriale. Il programma di aiuto dell’Editor del BASIC Stamp ha delle tabelle che danno i
valori BaudMode per le velocità di trasmissione e i segnali più comuni. Ne segue che 84 è
l’argomento BaudMode per la velocità di 9600 bits per secondo (bps), 8 bit dati, nessuna
parità, segnale vero. Questo è esattamente ciò che il LCD seriale Parallax è progettato
per ricevere.
Gli argomenti Elemento datI possono essere testo tra virgolette come "Ciao". Possono
essere anche caratteri di controllo come CR, CLS, o valori, con o senza caratteri di formato
come DEC, BIN, e ?. Se essi sono inviati con caratteri di formato, saranno inviati come i
caratteri che rappresentano il valore. Se sono inviati senza caratteri di formato, saranno
inviati come valori, come 22, 12, e 13. Possiamo inviare valori senza formato come
questi al LCD, che li interpreterà come codici di controllo.
Ancora sul commando SEROUT
Se volete provare ad usare il terminale di Debug con il SEROUT invece del DEBUG, prima di
tutto apritelo dalla barra degli strumenti via Run → Debug → New. Successivamente,
scegliere Run → Identify per vedere quale porta sta utilizzando il vostro BASIC Stamp.
Quindi, nel terminale di Debug, impostate la porta Com perché corrisponda a quella del
BASIC Stamp. Notare che potete anche cambiare la velocità di trasmissione del terminale di
Debug e gli altri parametri di comunicazione.
C’è ancora una quantità di cose da apprendere sul comando SEROUT. Sia il Manuale
BASIC Stamp Manual che la Guida ala Sintassi PBASIC dell’Editor del BASIC Stamp danno
una copertura estesa del comando SEROUT. Il manuale BASIC Stamp Manual è disponibile
per lo scarico gratuito dal sito www.parallax.com → Downloads → Documentation. Se il
vostro Editor BASIC Stamp supporta la versione PBASIC 2.5, probabilmente avrete già la
guida della Sintassi PBASIC. Per accedervi, scegliete semplicemente l’indice dal menu di
aiuto dell’Editor BASIC Stamp Editor.
Semplici Messaggi di testo e Codici di Controllo
Al contrario del terminale di Debug, il LCD seriale dev’essere acceso tramite un
commando dal BASIC Stamp. Per attivare il suo display (schermo), il LCD deve
ricevere il valore 22 dal BASIC Stamp. Ecco il comando PBASIC che invia il valore 22
al LCD seriale:
SEROUT 14, 84, [22]
Usato in questo modo, 22 è un esempio di un codice di controllo del LCD. Ecco un
elenco di alcuni ulteriori codici di controllo di base:
•
•
•
•
12 cancella lo schermo del display. Nota: va sempre seguito dal commando
PAUSE 5 per dare al LCD tempo per cancellare lo schermo.
13 è il ritorno carrello; esso manda il cursore alla riga successiva.
21 spegne il LCD.
22 accende il LCD.
Comandi per accendere e spegnere la retro-illuminazione (solo per il LCD retroilluminato):
Alcuni LCD hanno la retro-illuminazione in modo che si possa leggerli al buio. Se avete la
versione retro-illuminata del LCD seriale Parallax (numero di componente 27977), potete
controllare la retro-illuminazione con questi valori:
•
17 accende la retro-illuminazione.
•
18 spegne la retro-illuminazione.
In PBASIC, CR è una costante predefinita di valore 13. Ogni volta che si utilizza la
costante CR in un comando DEBUG, questo invia il valore 13 al terminale di debug. Il
terminale di debug muove il cursore all’inizio della riga successive ogni volta che riceve il
valore 13. In questo caso, i due comandi qui sotto sono equivalenti:
SEROUT 14, 84, ["Vedi il testo?", CR, "Il LCD lavora!"]
SEROUT 14, 84, ["Vedi il testo?", 13, "Il LCD lavora!"]
Mentre questa equivalenza lavora con CR, non lavora con altre costanti PBASIC
predefinite. Ad esempio, CLS, che è una costante predefinita con il numero 0, non
cancella lo schermo del LCD. L’equivalente di CLS per il LCD seriale Parallax è 12.
Analogamente, HOME, costante predefinita con il valore 1, non invia il cursore a inizio
pagina “home”, sul primo carattere in alto a sinistra nel display LCD. Il codice di controllo
128 fa questo per il LCD seriale Parallax.
Programma di esempio - ProvaMessaggiLcd.bs2
√
Digitate, memorizzate, ed eseguite ProvaMessaggiLcd.bs2. Verificate che esso
visualizzi il messaggio "Vedi il testo?" sulla Riga 0 e "Il LCD lavora!" sulla Riga
1, come nella Figura 1-10.
' Sensori Intelligenti e loro Applicazioni - ProvaMessaggiLcd.bs2
' Visualizza un messaggio di prova sul LCD seriale Parallax.
' {$STAMP BS2}
' {$PBASIC 2.5}
' Dispositivo scelto = BASIC Stamp 2
' Linguaggio = PBASIC 2.5
SEROUT 14, 84, [22, 12]
PAUSE 5
' Inizializza il LCD
SEROUT 14, 84, ["Vedi il testo? Il ", 13, ' Messaggio di testo, rit. carrello
" LCD lavora!"]
' altro testo sulla Riga 1.
END
' Fine programma
Figura 1-10
Visualizzazione
di testo
Vedi il testo ?
Il LCD lavora!
Se il LCD non visualizza in modo corretto: Controllare almeno due volte il proprio
cablaggio, il programma scritto, e le impostazioni degli interruttori nel retro del LCD. Inoltre
tentare di scollegare e collegare le batterie della vostra Board of Education. Se necessario,
rivedere le istruzioni, marcate con un segno di spunta, che hanno portato a questo
programma, e verificare che ciascuna di esse sia stata completata in modo corretto.
Il vostro turno – Codici di controllo per far lampeggiare il Display
Ricordate che 22 accende il display, e 21 lo spegne? Potete usare questi codici di
controllo per far lampeggiare il testo (acceso – spento).
√
Sostituite il commando END nel ProvaMessaggiLcd.bs2 con questo blocco di
codice.
DO
PAUSE 600
SEROUT 14, 84, [22]
PAUSE 400
SEROUT 14, 84, [21]
LOOP
√
'
'
'
'
'
'
Inizia un blocco DO...LOOP
ritardo di 6/10 di secondo
Accende il display
ritardo di 4/10 di secondo
Spegne il display
Ripete il blocco DO...LOOP
Eseguite il programma modificato e prendete nota dell’effetto.
Visualizzazione di numeri con caratteri di formato
La maggior parte dei caratteri di formato che hanno lavorato per la visualizzazione di
numeri con il terminale di Debug possono essere utilizzati anche con il LCD seriale
Parallax. Il carattere di formato DEC è probabilmente il più utile, ma potrete anche usare
DIG, REP, ASC, BIN, HEX, SDEC, e gran parte degli altri. Ad esempio, se volete
visualizzare il valore decimale di una variabile chiamata contatore, potete usare un
comando del tipo:
SEROUT 14, 84, [DEC contatore]
Programma esempio – ProvaNumeriLcd.bs2
A parte il dimostrare che potete visualizzare valori variabili sul LCD seriale, questo
programma mostra anche cosa avviene se il programma invia più di 16 caratteri
stampabili sulla Riga 0. Esso va a capo sulla Riga 1. Inoltre, dopo aver stampato altri
sedici caratteri e riempito la Riga 1, il testo continua ad andare a capo, tornando sulla
Riga 0.
√
Digitate, memorizzate, ed eseguite ProvaNumeriLcd.bs2
' Sensori intelligenti e loro applicazioni - ProvaNumeriLcd.bs2
' Visualizza valori numerici con il LCD seriale Parallax.
' {$STAMP BS2}
' {$PBASIC 2.5}
contatore
' Linguaggio
= PBASIC 2.5
VAR
Byte
' Indice del ciclo FOR...NEXT
SEROUT 14, 84, [22, 12]
PAUSE 5
' ritardo di 5 ms per cancellare il
' display
FOR contatore = 0 TO 12
' Conta fino a 12; incrementi di 1/2 s
SEROUT 14, 84, [DEC contatore, " "]
PAUSE 500
NEXT
END
' Fine programma
√
Verificate che il display rassomigli alla Figura 1-11.
Figura 1-11
Visualizzazione
di numeri
Il vostro turno – Altri caratteri di formato
√
√
√
√
Provate a sostituire DEC con DEC2 e osservate cosa succede.
Ripetere col carattere di formato ?.
Se necessario, controllare questi comandi sia nel Manuale BASIC Stamp, sia
nell’aiuto del Editor BASIC Stamp. Provateli anche nel terminale di Debug.
Quali somiglianze e quali differenze ci sono tra l’uso di questi caratteri di
formato nel terminale di Debug e il loro uso nel LCD seriale Parallax?
Codici di controllo per posizionare il cursore
I codici di controllo del LCD sono diversi dai caratteri di controllo del comando DEBUG.
Ad esempio, HOME, e CRSRXY non hanno proprio lo stesso effetto che producono col
terminale di Debug. Però, ci sono comandi del cursore del LCD seriale Parallax che
potrete usare per controllare le coordinate X e Y del cursore. Potete anche mandare il
cursore nella "posizione home" in alto a sinistra. Guardate il capitolo “Insieme dei
Comandi” della documentazione del LCD (Appendice B) che inizia a pagina 341. Esso
elenca tutti i comandi di controllo validi per il LCD; dei quali riportiamo qui sotto alcuni
esempi presi dall’elenco che controllano la posizione del cursore.
•
•
•
•
•
8
9
10
128 a 143
148 a 163
Cursore a sinistra
Cursore a destra
Cursore giù (la riga inferiore scorre alla riga superiore)
Posizione del cursore sulla Riga 0, carattere da 0 a 15
Posizione del cursore sulla Riga 1, carattere da 0 a 15
I valori da 128 a 143 e da 148 a 163 sono particolarmente utili. La Figura 1-12 mostra
cove ciascun valore posiziona il cursore. Potete usare i valori da 128 a 143 per
posizionare il cursore ai caratteri da 0 a 15 sulla riga superiore del LCD (Riga 0).
Analogamente, potete usare i valori da 148 a 163 per posizionare il cursore sui caratteri
da 0 a 15 della riga inferiore (Riga 1).
Figura 1-12
Visualizzazione
di testo
Dopo aver posizionato il cursore, il carattere successivo che inviate al LCD sarà
visualizzato in quella posizione. Ad esempio, ecco un comando SEROUT con il valore
dell’argomento opzionale Pace impostato a 200 ms. Questo comando visualizzerà i
caratteri "R", "I", "G", "A", "-", e "0", ugualmente spaziati sulla riga superiore, un
carattere ogni 200 ms.
SEROUT 14, 84, 200, [128,
131,
134,
137,
140,
143,
"R",
"I",
"G",
"A",
"-",
"0"]
Se si stanno visualizzando molti caratteri dopo aver dato una posizione iniziale, il LCD
farà ancora spostare automaticamente il cursore a destra dopo ciascun carattere. Ad
esempio, potete anche posizionare il cursore sul carattere 7 della riga superiore e quindi
visualizzare "TUTTO", poi muovere il cursore al carattere 6 della riga superiore e
visualizzare "FATTO!" con l’istruzione che segue:
SEROUT 14, 84, [135, "TUTTO", 154, "FATTO!"]
Il seguente blocco di codice farà scorrere il testo "Riga 1" sulla riga inferiore del display,
da destra a sinistra.
FOR indice = 9 TO 0
' IMPORTANTE: Lasciare uno spazio dopo 1 in "Riga 1 "
SEROUT 14, 84, [148 + indice, "Riga 1 "]
PAUSE 100
NEXT
Cancellazione di caratteri
Potete sempre cancellare un carattere posizionando il cursore dove lo volete e poi inviando
un carattere spazio " " per sovrascrivere qualsiasi carattere possa essere là. E’ per tale
motivo che il testo "Riga 1 " ha uno spazio dopo il carattere "1", per cancellare i caratteri alla
sua destra man mano che il testo si nuove a sinistra.
Programma Esempio - PosizioniCursore.bs2
Questo programma mostra alcuni artifici base per il posizionamento del cursore.
√
√
√
Esaminare il programma PosizioniCursore.bs2 e tentare di prevedere quale
comportamento il programma produrrà sul display LCD. Tentare anche di
prevederne la sequenza e la temporizzazione.
Digitare, memorizzare, ed eseguire PosizioniCursore.bs2.
Confrontare il comportamento del display LCD con le vostre previsioni.
' Sensori Intelligenti e loro Applicazioni - PosizioniCursore.bs2
' Visualizza valori numerici sul LCD seriale Parallax.
' {$STAMP BS2}
' {$PBASIC 2.5}
indice
carattere
offset
VAR
VAR
VAR
' Linguaggio
= PBASIC 2.5
Nib
Byte
Byte
SEROUT 14, 84, [22, 12]
PAUSE 500
' Indice del ciclo FOR...NEXT
' Memoria deposito del carattere
' Valore dello spostamento
' Ritardo di 1/2 secondo
' Visualizza caratteri con uguale spaziatura sulla Riga 0 ogni 200 ms.
SEROUT 14, 84, 200, [128, "R",
131, "I",
134, "G",
137, "A",
140, "-",
143, "1"]
PAUSE 1000
' Sposta "Riga 1" sulla Riga 1 da destra a sinistra, quindi da sinistra a
' destra.
FOR indice = 9 TO 0
' IMPORTANTE: Assicurarsi che ci sia uno spazio dopo l’1 in "Riga 1 ".
SEROUT 14, 84, [148 + indice, "Riga 1 "]
PAUSE 100
NEXT
FOR indice = 0 TO 9
' IMPORTANTE: Assicurarsi che ci sia uno spazio tra le " e il carattere R.
SEROUT 14, 84, [148 + indice, " Riga 1"]
PAUSE 250
NEXT
PAUSE 1000
' Ritardo di 1 secondo
' Cancella il LCD, quindi visualizza "TUTTO FATTO!" al centro e lampeggia per
' 5 volte
SEROUT 14, 84, [12]: PAUSE 5
' Cancella il LCD
SEROUT 14, 84, [135, "TUTTO", 13, 154, "FATTO!"]
' "TUTTO" e "FATTO" sono centrati
FOR indice = 1 TO 4
SEROUT 14, 84, 500, [21, 22]
NEXT
END
' Fa lampeggiare il display 5 volte
' Fine programma
Il vostro turno – Ulteriori posizionamenti
Con i cicli e le tabelle di ricerca si possono ottenere visualizzazioni più elaborate. Il
programma che segue è un esempio di visualizzazione della parola "T E S T" in un ciclo
e con l’aiuto di due comandi LOOKUP. Si noti che si può controllare la posizione del
punto in cui ciascun carattere è posto regolando i valori di offset nell’elenco dei valori
del secondo comando LOOKUP.
PAUSE 1000
SEROUT 14, 84, [12]: PAUSE 5
SEROUT 14, 84, ["Questo è un", 13]
FOR indice = 0 TO 3
' Cancella il display
' Testo e CR
' Sequenza di visualizzazione dei
' caratteri
PAUSE 600
LOOKUP indice, ["T", "E", "S", "T"], carattere
LOOKUP indice, [ 1,
5, 9, 13], offset
SEROUT 14, 84, [(148 + offset), carattere]
NEXT
√
Provate il programma!
ATTIVITÀ #3: APPLICAZIONE DI UN TEMPORIZZATORE
Questa attività applica le tecniche presentate nell’Attività #2 ed un temporizzatore ore minuti - secondi.
Visualizzazione del tempo trascorso
Il programma che segue avvia il LCD, cancella lo schermo, e posiziona alcuni caratteri da
visualizzare sul LCD in modo che non saranno cambiati. Il resto del programma può
allora visualizzare i valori numerici delle ore, minuti e secondi che cambiano a fianco dei
caratteri fermi "h", "m", e "s".
SEROUT 14, 84, [22, 12]
PAUSE 5
SEROUT 14, 84, ["Tempo ...", 13]
SEROUT 14, 84, [" h
m
s"]
'
'
'
'
Avvia il LCD & cancella il
display
Pausa di 5 ms per cancellare il
display
' Testo + ritorno carrello
' Testo sulla seconda riga
Per questa applicazione, i codici di controllo per il posizionamento del cursore possono
rivelarsi particolarmente utili. Ad esempio, il cursore può essere posizionato sulla riga 1,
il carattere 0 prima dell’invio del valore decimale a due cifre delle ore. Il cursore può
successivamente essere spostato sulla riga 1, il carattere 5 per visualizzare i minuti e
quindi sulla riga 1, il carattere 10 per visualizzare i secondi.
Segue il singolo commando SEROUT che visualizza i valori di tutte e tre le variabili,
ciascuno nella posizione corretta:
SEROUT 14, 84, [ 148, DEC2 ore,
153, DEC2 minuti,
158, DEC2 secondi ]
L’esempio successivo applica questo concetto assieme alle peculiarità di temporizzazione
del modulo BASIC Stamp. La precisione non promette la qualità di quella di un orologio
da polso; ma comunque è abbastanza buona da mostrare come possa lavorare la
visualizzazione del tempo con il posizionamento dei caratteri. Se si desidera una
precisione maggiore, si può provare ad incorporare il chip di cronometraggio DS1302.
E’ disponibile sul sito www.parallax.com, semplicemente digitando DS1302 nel campo
per le ricerche.
Programma esempio - TimerLcd.bs2
Questo programma esempio visualizza ore, minuti e secondi trascorsi con il LCD seriale
Parallax. Premendo il pulsante RESET sulla Board of Education, si potrà far ripartire il
timer.
√
√
Digitare, memorizzare, ed eseguire TimerLcd.bs2.
Verificate che il display lavori come indicato.
' Sensori Intelligenti e loro Applicazioni - TimerLcd.bs2
' Visualizza il tempo trascorso con il BS2 e il LCD seriale Parallax.
' {$STAMP BS2}
' {$PBASIC 2.5}
ore
minuti
secondi
VAR
VAR
VAR
' direttiva Stamp
' direttiva PBASIC
Byte
Byte
Byte
SEROUT 14, 84, [22, 12]
PAUSE 5
' Memorizza le ore
' Memorizza i minuti
' Memorizza i secondi
' Avvia il LCD & cancella il display
' Pausa di 5 ms per cancellare il
' display
SEROUT 14, 84, ["Tempo trascorso...", 13]
SEROUT 14, 84, [" h
m
s"]
' Testo + ritorno carrello
' Testo sulla seconda riga
DO
' Programma principale
' Calcola ore, minuti, secondi
IF secondi = 60 THEN secondi = 0: minuti = minuti + 1
IF minuti = 60 THEN minuti = 0: ore = ore + 1
IF ore
= 24 THEN ore
= 0
' Visualizza le cifre sulla riga 1 del LCD. I valori 148, 153, 158
' posizionano il cursore al carattere 0, 5, e 10 per i valori di tempo.
SEROUT 14, 84, [148, DEC2 ore,
153, DEC2 minuti,
158, DEC2 secondi ]
PAUSE 991
secondi = secondi + 1
LOOP
' Pausa + ritardo di ~ 1 secondo
' Incremento del contatore dei secondi
' Ripete il programma principale
Il vostro turno – Definire i codici di controllo con le costanti
Fino a questo punto, i codici di controllo del LCD sono stati valori decimali. Comunque,
se si sta scrivendo o leggendo un programma molto lungo, ricordare tutti questi codici di
controllo può essere fastidioso. È meglio dichiarare all’inizio del programma una costante
per ciascuno dei codici di controllo. Poi, utilizzare i nomi delle costanti invece dei
numeri. Si potrà fare la stessa cosa anche con il valore BaudMode, e quindi aggiungere
una direttiva PIN per effettuare lo stesso I/O sul piedino P14. Un esempio è il seguente:
PinLcd
PIN
14
' Piedino I/O del LCD
T9600
CON
84
' Vera, 8-bit, senza parità, 9600
ClsLcd
CrLcd
OffLcd
OnLcd
Riga0
Riga1
CON
CON
CON
CON
CON
CON
12
13
21
22
128
148
'
'
'
'
'
'
Salto pagina -> cancella schermo
Ritorno carrello
Spegne il display
Accende il display
Riga 0, carattere 0
Riga 1, carattere 0
Queste dichiarazioni renderanno il proprio codice più facile da comprendere, cosa
particolarmente importante quando si deve modificare il programma e non lo si è
guardato per parecchi mesi. Ad esempio, il primo comando SEROUT può essere riscritto
nel modo seguente:
SEROUT PinLcd, T9600, [OnLcd, ClsLcd]
Il comando SEROUT nel programma TimerLcd.bs2 che visualizza i numeri sulla riga 1 del
LCD si può riscrivere nel modo seguente:
SEROUT PinLcd, T9600, [(Riga1 + 0), DEC2 ore,
(Riga1 + 5), DEC2 minuti,
(Riga1 + 10), DEC2 secondi]
√
√
√
√
Salvate TimerLcd.bs2 sotto altro nome.
Aggiungete commenti descrittivi al proprio programma.
Sostituite quanti più numeri credete opportuno con nomi di costanti significativi.
Eseguite il programma ed eliminate i malfunzionamenti se necessario.
ATTIVITÀ #4: CARATTERI PERSONALIZZATI E ANIMAZIONE DEL LCD
Anche se non tutte le immagini conservano migliaia di parole, persino quelle che
conservano una o due frasi sono utili quando avete a disposizione uno spazio di soli 32
caratteri per lavorare. Un esempio di immagine utile è il cursore a clessidra che lo
schermo del vostro computer utilizza per farvi sapere che il programma è occupato.
Questa semplice icona animata lavora molto meglio che un messaggio che appaia in
qualche posto dello schermo che dice, "vi preghiamo di attendere, il programma è
occupato...". Questa attività usa una clessidra per presentare tecniche di definizione,
memorizzazione, visualizzazione e animazione di caratteri personalizzati.
Caratteri personalizzati nel LCD Parallax
Il LCD seriale Parallax ha spazi contigui per otto caratteri personalizzati mostrati nella
Figura 1-13. Per visualizzare il carattere personalizzato 0, si invii semplicemente al LCD
il valore 0 con un comando SEROUT. Analogamente, per visualizzare il carattere
personalizzato 1, si invii soltanto un 1, per visualizzare il carattere personalizzato 2, si
invii un 2, e così via. Si noti che i caratteri personalizzati 0 e 1 sono pre - configurati per
essere la barra rovesciata e la tilde. Un esempio di comando SEROUT che visualizza
entrambi questi caratteri: SEROUT 14, 84, [0, 1].
Figura 1-13: Caratteri personalizzati pre – definiti: 0 (Barra rovesciata) e 1 (Tilde)
Caratteri personalizzati
Programma esempio: CaratteriPersonaliPredefiniti.bs2
Questo esempio invia al LCD seriale i due comandi per fargli visualizzare i caratteri
personalizzati 0 and 1, la barra rovesciata "\" e la tilde "~".
√
Digitare ed eseguire il programma, e controllare che visualizza la barra
rovesciata e la tilde.
' Sensori Intelligenti e loro applicazioni - CaratteriPersonaliPredefiniti.bs2
' {$STAMP BS2}
' {$PBASIC 2.5}
SEROUT 14, 84, [22, 12]
PAUSE 5
' ritardo di 5 ms per cancellare il display
' Visualizza i caratteri personalizzati pre – definiti: "\" (carattere
' personalizzato 0) and "~" (carattere personalizzato 1).
SEROUT 14, 84, [0, 1]
Definire (e Ridefinire) caratteri personalizzati
I caratteri personalizzati del LCD seriale Parallax sono memorizzati nella sua RAM. Per
definire uno dei suoi otto caratteri personalizzati, il proprio commando SEROUT deve dire
al LCD quale degli otto caratteri personalizzati si vuole definire e quindi descrivere gli
stati acceso/spento di ciascun pixel nel carattere. Ciascun carattere ha 40 pixel, 8 pixel di
altezza per 5 pixel di larghezza.
La Figura 1-14 mostra i comandi di definizione che si dovranno inviare al LCD per dirgli
quale dei caratteri personalizzati state per definire. Si può anche pensare al riguardo in
questo modo: dire al LCD quale dei caratteri personalizzati si sta per definire, inviare il
valore del carattere personalizzato più 248. Ad esempio, se si vuole definire il carattere
personalizzato 0, si invierà 248, se si vuole definire il carattere personalizzato 1, si
invierà 249, e così via fino a 255 per il carattere personalizzato 7.
Figura 1-14: Comandi per definire un carattere personalizzato
Carattere personalizzato
Comandi di definizione
Dopo aver inviato il codice che dice al LCD quale carattere personalizzato si sta per
definire, dovete poi definire ed inviare gli otto byte che descrivono quel carattere. Il LCD
usa i cinque bit mano significativi di ciascun byte che riceve per descrivere ciascuna delle
righe larghe cinque pixel nel carattere. La Figura 1-15 mostra un esempio di definizione
del carattere personalizzato 0 come una clessidra che è stata appena girata a testa in giù.
SEROUT 14, 84, [248,
%00000,
%11111,
%11111,
%01110,
%00100,
%01010,
%10001,
%11111]
Figura 1-15
Ridefinizione del
carattere personalizzato 0
Si noti come ciascuno dei valori successivi nel commando SEROUT corrisponde ad una
riga di pixel nel carattere personalizzato. Si noti anche che gli 1 corrispondono a pixel
neri, e gli 0 corrispondono ai bianchi.
Le definizioni di caratteri personalizzati col comando SEROUT non sono permanenti.
Ciascuna volta che si dà e si toglie tensione i caratteri personalizzati sono cancellati. Poiché
il BASIC Stamp e il LCD condividono la stessa alimentazione elettrica, il programma nel
BASIC Stamp viene riavviato quando si dà di nuovo tensione. È buona pratica definire
all’inizio di ciascun programma i caratteri personalizzati che ci si propone di utilizzare, in
modo che il BASIC Stamp può definire i caratteri personalizzati ogni volta che gli viene
ridata tensione.
Il programma che segue è una nuova definizione del carattere personalizzato clessidra
con i suoi quattro pixel di sabbia calati nella sua camera inferiore. Questa definizione
utilizza 255 per dire al LCD di renderlo carattere personalizzato 7. Viene anche utilizzata
una tecnica per disegnare i caratteri con asterischi nei commenti a destra del comando
SEROUT. Si inizi con un comando SEROUT con tutti i valori binari impostati a %00000, e
poi si disegni il carattere con asterischi nel commento a destra. Dopo che il disegno è
corretto, si utilizzino gli asterischi per dettare quali zeri debbano essere modificati in uno.
SEROUT 14, 84, [255,
%00000,
%11111,
%10001,
%01010,
%00100,
%01110,
%11111,
%11111]
'
'
'
'
'
'
'
'
'
Definisce il carattere personalizzato 7
* * * *
*
*
*
*
* * *
* * * *
* * * *
*
*
*
*
La Figura 1-16 mostra come i due comandi SEROUT appena discussi ridefiniscano i
caratteri personalizzati del LCD's.
Figura 1-16: Dopo la definizione dei caratteri personalizzati 0 e 7
I caratteri personalizzati sono a volte definiti tramite valori esadecimali. Si potrà
vedere questo in programmi esempio disponibili per lo scarico dalle pagine del sito
www.parallax.com relative al prodotto LCD seriale Parallax. Per informazioni su come
lavorino le definizioni tramite caratteri esadecimali, si provi l’attività nell’Appendice B:
Definizioni di caratteri esadecimali (Appendice C, pagina 347).
Con queste nuove definizioni di caratteri personalizzati, si potrà scrivere un ciclo per fare
in modo che la clessidra passi da vuota a piena, per indicare che l’utente dovrà attendere.
Il ciclo DO...LOOP riportato qui sotto fa questo, dapprima posizionando il cursore nel LCD
sulla riga 0, carattere 5. Quindi visualizza il carattere personalizzato 0, la clessidra appena
girata a testa in giù. Dopo un breve comando PAUSE, il programma invia il commando
backspace (8, cancella a sinistra) per far tornare il cursore indietro al carattere 5. Poi
invia il carattere personalizzato 7, la clessidra con la sabbia precipitata nella base. Se si
ripete questa sequenza, sembrerà come se la clessidra venisse girata a testa in giù,
svuotata, girata ancora, svuotata ancora, e così via.
DO
SEROUT 14, 84,
SEROUT 14, 84,
PAUSE 1250
SEROUT 14, 84,
SEROUT 14, 84,
PAUSE 1500
[133]
[0]
[8]
[7]
'
'
'
'
'
'
Cursore -> Riga 0, char
Visualizza carattere personalizzato 0
Ritardo di 1.25 secondi
Backspace (cancella a sinistra)
LOOP
Programma esempio: Clessidra.bs2
Questo programma definisce e visualizza i caratteri personalizzati clessidra appena
illustrati.
√
√
'
'
'
'
'
Digitate, memorizzate ed eseguite il programma.
Verificate che esso visualizzi alternativamente i due caratteri clessidra al sesto
carattere della riga superiore del LCD.
-----[ Title ]-------------------------------------------------------------Sensori intelligenti e loro applicazioni - Clessidra.bs2
Definisce e visualizza caratteri personalizzati.
{$STAMP BS2}
{$PBASIC 2.5}
' Linguaggio
= PBASIC 2.5
' -----[ Inizializzazione ]--------------------------------------------------PAUSE 250
SEROUT 14, 84, [248,
%00000,
%11111,
%11111,
%01110,
%00100,
%01010,
%10001,
%11111]
'
'
'
'
'
'
'
'
'
'
Toglie l’alimentazione elettrica
SEROUT 14, 84, [255,
%00000,
%11111,
%10001,
%01010,
%00100,
%01110,
%11111,
%11111]
'
'
'
'
'
'
'
'
'
SEROUT 14, 84, [22, 12]
PAUSE 5
' Accende il display e lo cancella
' Ritardo di 5 ms per cancellare il display
* * *
* * *
* *
*
*
*
* * *
* *
* *
*
*
*
* *
* * * *
*
*
*
*
* * *
* * * *
* * * *
*
*
*
*
' -----[ Programma principale ]----------------------------------------------DO
SEROUT 14, 84,
SEROUT 14, 84,
PAUSE 1250
SEROUT 14, 84,
SEROUT 14, 84,
PAUSE 1500
LOOP
[133]
[0]
[8]
[7]
'
'
'
'
'
'
Cursore -> riga 0, char
Backspace (cancella a sinistra)
Il vostro turno
La Figura 1-17 mostra i caratteri personalizzati che rappresentano i granelli di sabbia
nella clessidra mentre si muovono dall’alto verso il basso.
Figura 1-17: Caratteri personalizzati per la clessidra animata
√
√
√
Memorizzare Clessidra.bs2 come VostraClessidra.bs2.
Ampliare il programma di inizializzazione in modo che definisca tutti gli otto
caratteri personalizzati come mostrati dalla Figura 1-17.
Modificare il programma principale in modo che dia un effetto di clessidra
animate come se i granelli di sabbia cadessero dall’alto in basso.
Qui di seguito è riportato un programma principale che si potrà provare per animare gli
otto caratteri personalizzati, una volta che si sarà aggiornata la sezione di
inizializzazione:
DO
' Posizionare il cursore al carattere 5, e visualizzare il carattere
' personalizzato 0.
SEROUT 14, 84, 100, [133, 0]
PAUSE 750
' ritardo di 0.750 secondi
' Backspace, carattere personalizzato 1, backspace, carattere personalizzato
' 2, etc.
' l’argomento opzionale Pace di valore 100 invia ciascun valore ogni 1/10 di
' secondo.
SEROUT 14, 84, 100, [8, 1, 8, 2, 8, 3, 8, 4, 8, 5, 8, 6, 8, 7, 8]
PAUSE 750
LOOP
√
Provate il programma!
Anche se il LCD memorizza soltanto 8 caratteri personalizzati alla volta, il vostro
programma può memorizzarne tanti quanti ve ne occorrono. Ricordate, il vostro
programma può ridefinire qualsiasi carattere personalizzato in una sola volta. Se alla vostra
applicazione occorrono venti caratteri personalizzati, il vostro programma PBASIC puo’
memorizzare 20 caratteri personalizzati e ridefinirli per il LCD quando occorrono.
Potrete visualizzare la clessidra con un solo carattere personalizzato. L’intera
animazione della clessidra si può fare con un solo carattere personalizzato. Il trucco è
ridefinire il carattere personalizzato tra ciascuna coppia di intervalli in cui il display viene
aggiornato.
ATTIVITÀ #5: SCORRIMENTO DI TESTO TRAMITE IL DISPLAY
Se il vostro messaggio è troppo grande per il display a 16 caratteri, far scorrere il testo
lungo il display può farlo visualizzare tutto. La Figura 1-18 mostra un esempio. Con lo
scorrimento, il messaggio inizia all’estremità destra del display. Quindi, il testo scorre
attraverso il display una lettera alla volta.
Figura 1-18
Scorrimento
del testo
Il codice di scorrimento presentato in questa attività è del tutto diverso dal programma
esempio nella Attività #2 che faceva muovere " Riga 1 " attraverso il display. La ragione
principale per cui è diverso è il fatto che il messaggio nell’Attività #2 si fermava al
carattere più a sinistra. Quando il messaggio è più grande della finestra del display,
fermarsi al bordo sinistro del display impedirà al resto del messaggio di diventare
visibile.
Per ottenere testo che scorra lungo lo schermo esattamente di una riga, il programma
deve iniziare con il primo carattere di un messaggio e visualizzarlo nella posizione più a
destra. Dopo un breve ritardo, il programma deve muovere il cursore sul secondo
carattere da destra, e stampare il primo e il secondo carattere. Deve continuare questo
procedimento fino a che il cursore non si trovi a sinistra del display. Allora, il cursore
dev’essere ripetutamente riposizionato a quella stessa posizione in modo che saranno
visualizzate porzioni di messaggio di 16 caratteri, facendo apparire il messaggio come se
scorresse da destra a sinistra, un carattere alla volta.
La tecnica di programmazione per questa elaborazione è detta “a finestra scorrevole” .
Oltre ad essere utile per il LCD Parallax, la finestra scorrevole è ciò che vedete quando il
testo scorre su e giù in programmi come l’Editor BASIC Stamp e il vostro browser web.
È utilizzata anche in programmi che trasmettono e raccolgono i pacchetti TCP/IP. Così
ogni volta che aprite il vostro browser web, c’è più di una istanza di codice “a finestra
scorrevole” che lavora sullo sfondo.
Un sottoprogramma a scorrimento configurabile
Il programma esempio che segue mette in risalto un sottoprogramma comodo per
visualizzare una gran varietà di messaggi scorrevoli col minimo lavoro. Tutto ciò che
comporta è il posizionare i messaggi in direttive DATA precedute da nomi Symbol,
impostando poche variabili, e poi chiamando il sottoprogramma di scorrimento.
Ecco alcuni esempi di direttive DATA.
Messaggio1
Messaggio2
Messaggio3
Messaggio4
DATA @ 2, "Messaggio "
DATA
"ulteriore "
DATA
"Messaggio più lungo, che va più veloce "
DATA
Il primo messaggio di testo inizia ad un indirizzo della EEPROM uguale al valore del
simbolo Messaggio1, che è stato posto a 2 con l’argomento opzionale @Address della
direttiva DATA. L’indirizzo dopo la fine del Messaggio1 è l’indirizzo 11 della EEPROM.
Ciò è evidenziato dall’etichetta Messaggio2, che è anche l’inizio del secondo messaggio.
Dal momento che potete impostare variabili uguali ai valori di Messaggio1 a
Messaggio4, questo è un sistema particolarmente flessibile, adatto a una varietà di
messaggi.
Il programma esempio successivo ha anch’esso variabili che potete impostare per
configurare diverse posizioni, ampiezze e incrementi della finestra. Dopo aver impostato
i valori di queste variabili, potrete poi richiamare il sottoprogramma Scorri_Messaggio,
che fa il resto del lavoro. Ecco un esempio di un blocco di codice che fa visualizzare al
sottoprogramma tutti i caratteri tra le etichette Messaggio1 e Messaggio2 nei quattro
caratteri centrali della riga superiore del LCD.
InizioMessaggio = Messaggio1:
FinestraSinist
= 134:
incremento
= 1
GOSUB Scorri_Messaggio
FineMessaggio = Messaggio2
FinestraDestra = 137
Gli indirizzi iniziale e finale della EEPROM sono memorizzati nelle variabili
InizioMessaggio e FineMessaggio. Gli indirizzi di carattere LCD iniziale e finale che
definiscono la finestra sono memorizzati in FinestraSinist e FinestraDestra. Da
ultimo, la variabile incremento è impostata al numero di caratteri che il testo muove
ogni volta che scorre. Con tutti questi valori impostati, il sottoprogramma
Scorri_Messaggio ha tutto quanto gli occorre per svolgere il suo compito.
Ci sono tre ulteriori esempi nel sottoprogramma principale del programma che segue.
Non tutti gli esempi assegnano valori a tutte le variabili. Alcuni esempi impostano
soltanto pochi valori perché questi sono valori che ritornano, ed erano stati assegnati
prima della precedente chiamata di sottoprogramma. Ad esempio, il valore della
variabile incremento era impostato ad 1 prima della prima chiamata di sottoprogramma.
Poiché il sottoprogramma Scorri_Messaggio non apporta alcun cambiamento a quella
variabile, a tale variabile non dev’essere riassegnato il valore 1 prima che il
sottoprogramma Scorri_Messaggio venga chiamato di nuovo.
' Cambia i valori di alcune variabili di configurazione
' e mostra l’effetto di ciascun cambiamento sul display.
finestraSinist
= 131:
finestraDestra = 140
Ecco l’ultimo esempio nel sottoprogramma principale. Si noti che esso prende la parte
migliore della seconda riga e fa scorrere due caratteri alla volta:
InizioMessaggio = Messaggio3:
finestraSinist
= 150:
incremento
= 2
FineMessaggio = Messaggio4
Programma esempio - RoutineScorriTesto.bs2
√
√
√
'
'
'
'
Rivedere i blocchi di codice nel Sottoprogramma Principale del programma e
predire quanto grande dovrà essere la finestra di scorrimento, quale testo sarà
visualizzato, e quanti caratteri per volta scorreranno.
Digitare, memorizzare, ed eseguire RoutineScorriTesto.bs2.
Confrontare le vostre predizioni con quanto si è verificato in realtà e ricomporre
tutte le differenze.
-----[ Titolo ]------------------------------------------------------------Sensori Intelligenti e loro Applicazioni - RoutineScorriTesto.bs2
Fa scorrere nel LCD un messaggio di testo in una finestra larga quattro
caratteri.
' {$STAMP BS2}
' {$PBASIC 2.5}
' Direttiva BASIC Stamp
' Direttiva PBASIC
' -----[ Direttive DATA]---------------------------------------------------Messaggio1
DATA @ 2, "Messaggio "
Messaggio2
DATA
"ancora "
Messaggio3
DATA
"Messaggio più grande, si accelera..."
Messaggio4
DATA
' -----[ Definizioni I/O]---------------------------------------------------PinLcd
PIN
14
' Piedino I/O del LCD
' -----[ Costanti ]---------------------------------------------------------T9600
LcdCls
LcdCr
LcdOff
LcdOn
Riga0
Riga1
CON
CON
CON
CON
CON
CON
CON
84
12
13
21
22
128
148
'
'
'
'
'
'
'
Vera, 8-bit, senza parità, 9600
Salto pagina -> cancella schermo
Ritorno Carrello
Spegne il display
Accende il display
Riga 0, carattere 0
Riga 1, carattere 0
TimeOn
TimeOff
CON
CON
250
0
' Carattere in tempo
' Carattere perde tempo
' -----[ Variabili ]---------------------------------------------------------' Variabili funzionali per il sottoprogramma Scorri_Messaggio.
AvviaCursore
testa
coda
puntatore
carattere
VAR
VAR
VAR
VAR
VAR
Byte
Byte
Byte
Byte
Byte
'
'
'
'
'
Posizione del primo carattere
Inizio testo visualizzato
Fine testo visualizzato
puntatore indirizzo EEPROM
memorizza un carattere
' Variabili di Configurazione per il sottoprogramma Scorri_Messaggio.
incremento
finestraDestra
finestraSinist
InizMessaggio
FineMessaggio
VAR
VAR
VAR
VAR
VAR
Nib
Byte
Byte
Byte
Byte
'
'
'
'
'
Caratteri
indirizzo
indirizzo
Indirizzo
Indirizzo
da spostare
carattere più a destra
carattere più a sinistra
EEPROM iniziale
EEPROM finale
' -----[ Inizializazione ]---------------------------------------------------SEROUT PinLcd, T9600, [LcdOn, LcdCls]
' Accende & cancella display
PAUSE 5
' Ritarda 5 ms
' -----[ Sottoprogramma principale ]-----------------------------------------' Imposta i valori delle variabili di configurazione, poi
' richiama il sottoprogramma Scorri_Messaggio.
InizMessaggio = Messaggio1:
finestraSinist = 134:
incremento
= 1
FineMessaggio = messaggio2
finestraDestra= 137
' Cambia i valori di alcune variabili di configurazione e ne mostra
' gli effetti sul display ad ogni cambiamento.
finestraSinist
= 131:
FineMessaggio
= messaggio3
finestraSinist = 150:
incremento
= 2
FineMessaggio = messaggio4
END
' -----[ Subroutine - Scorri_Messaggio ]-------------------------------------Scorri_Messaggio:
Avviacursore = finestraDestra - incremento + 1
testa = 0
coda = incremento - 1
' carattere più a destra
' nella finestra
' Inizializza testa e coda
' del messaggio
' Ciclo di scorrimento
DO WHILE coda<(FineMessaggio-InizMessaggio)+(finestraDestra-finestraSinist
+incremento)
SEROUT PinLcd, T9600, [AvvioCursore]
FOR puntatore = testa TO coda
SEROUT PinLcd, T9600, [" "]
NEXT
' carattere più a destra nella
' finestra
' Cancella i vecchi caratteri.
PAUSE timeOff
' Fa svanire i caratteri
SEROUT PinLcd, T9600, [AvvioCursore]
' carattere più a destra nella
' finestra
' Questo ciclo FOR...NEXT rinfresca il messaggio, sposta ogni volta
' i caratteri a sinistra di “incremento”, fino alla fine del messaggio
' nella EEPROM.
' Poi, riempie il display con caratteri spazio, mentre il resto del
' messaggio scorre fuori dalla finestra.
FOR puntatore = testa TO coda
IF (puntatore <= (FineMessaggio - InizMessaggio - 1)) THEN
READ puntatore + InizMessaggio, carattere
ELSE
carattere = " "
ENDIF
SEROUT PinLcd, T9600, [carattere]
NEXT
PAUSE timeOn
' Dà ai caratteri un certo incremento di
' tempo fino alla sinistra della finestra
AvvioCursore = AvvioCursore - incremento MIN finestraSinist
coda = coda + incremento
' Incrementa puntatore di coda
' Incrementa puntatore di testa se puntatore coda > larghezza finestra.
IF coda > (finestraDestra - finestraSinist) THEN
testa = testa + incremento
ELSE
testa = 0
ENDIF
LOOP
' Ripete il ciclo di scorrimento
RETURN
La finestra scorrevole del sottoprogramma Scorri_Messaggio
Diciamo subito che la finestra di visualizzazione di testo scorrevole del vostro LCD sulla
riga superiore è larga quattro caratteri, poiché occorre visualizzare contemporaneamente
altri messaggi sul LCD. Il compito da affrontare è far scorrere il testo in questa finestra
più piccola senza sovrascrivere nessuno dei caratteri visualizzati al di fuori di essa.
√
La Figura 1-19 mostra l’impostazione e il Passo 0 di una finestra larga quattro
caratteri. Nel passo di impostazione, non viene visualizzato nulla nella finestra.
Quindi il passo 0 colloca il cursore nella posizione 137, e visualizza il carattere
0, la "M".
Figura 1-19: Testo scorrevole nella finestra, Impostazione e Passo 0
√
La Figura 1-20 mostra i Passi 1 e 2. Dopo aver atteso un momento perché la
"M" diventi visibile, il cursore va collocato nella posizione 136, e quindi
possono essere visualizzati i caratteri 0 e 1, "Me",. Poi, si muove il cursore a
135, e saranno visualizzati i caratteri da 0 a 2, "Mes".
Figura 1-20: Testo scorrevole nella finestra, Passi 1 e 2
√
La Figura 1-21 mostra i Passi 3 e 4. Si muove il cursore alla posizione 134 e si
visualizzano i caratteri da 0 a 3, c’è ancora la stessa sequenza"Mess", ma quando
la "M" lascia la finestra, la sequenza dovrà cambiare. La posizione iniziale del
cursore, ovvero il puntatore della testa del messaggio, non può più avanzare a
sinistra; deve rimanere nella posizione 134. Inoltre, invece di visualizzare i
caratteri da 0 a 3, si dovranno visualizzare i caratteri da 1 a 4, "essa".
√
La posizione di partenza del cursore deve rimanere a 134 mentre i caratteri di
testa e di coda continuano ad avanzare: da 2 a 5 - "ssag", da 3 a 6 - "sage". La
finestra si mantiene scorrevole, e la Figura 1-22 mostra i caratteri dal secondo –
all’ - ultimo passo, da 6 a 9 - "e" seguito da tre spazi, e finalmente l’ultimo
passo, da 7 a 10 – quattro caratteri spazio.
Il programma RoutineScorriTesto.bs2 usa le variabili mostrate nella Figura 1-23 per la
finestra scorrevole. La variabile AvviaCursore memorizza la posizione dove il cursore
è collocato ogni volta prima che inizi la scrittura dei caratteri del messaggio. Nella
figura, AvviaCursore memorizza il valore 135. La successiva volta che il testo scorre a
sinistra, memorizzerà 134. Due variabili, testa e coda, memorizzano gli indirizzi
iniziale e finale del testo che si adatterà alla finestra di messaggio. Nella figura, testa
memorizza 0, e coda memorizza 2. La variabile puntatore sarà utilizzata dal comando
READ per ottenere il carattere a destra, e la variabile carattere memorizzerà il carattere
che il comando READ reperisce dalla EEPROM.
Figura 1-23: Variabili da RoutineScorriTesto.bs2.
avviacursore
testa
coda
puntatore
Nella Figura 1-23, puntatore sta puntando al carattere 1 nella sequenza, cioè alla "e".
Un ciclo FOR...NEXT utilizza la variabile puntatore per leggere ciascuno dei caratteri
nella EEPROM, da testa a coda e quindi visualizzare ciascun carattere con il comando
SEROUT. Ogni volta che il testo scorre a destra, il nuovo testo deve sovrascrivere il
vecchio testo con lo stesso ciclo da testa a coda.
SOMMARIO
Il display (visualizzatore) a cristalli liquidi (LCD) è utilizzato in una enorme varietà di
prodotti. I semplici visualizzatori di caratteri come il LCD seriale Parallax 2X16 possono
sostituire le caratteristiche di visualizzazione del terminale di debug, cosa particolarmente
utile quando il luogo di prova del vostro progetto non è entro i luoghi raggiungibili da un
cavo seriale collegato al PC.
Il LCD seriale Parallax ha un potenziometro per la regolazione del contrasto nella parte
posteriore, assieme ai due interruttori usabili per scegliere una di tre diverse velocità di
trasmissione (velocità in baud) e una modalità di auto – prova. Nella parte posteriore del
LCD seriale Parallax ci sono tre piedini, visto che sono necessarie soltanto tre
connessioni per farlo funzionare: Vdd, RX, e Vss.
IL LCD seriale Parallax ha un insieme esteso di comandi, e un elenco completo di questi
comandi è incluso nella Documentazione di Prodotto del LCD seriale Parallax
(Appendice B). Questo capitolo presenta i comandi per accendere e spegnere il display,
cancellarne il contenuto, e quelli per il posizionamento del cursore, il controllo della retro
- illuminazione per il modello retro - illuminato, e la visualizzazione di caratteri.
La visualizzazione con il LCD seriale Parallax dipende da messaggi seriali provenienti
dal BASIC Stamp, programmati al suo interno dal comando PBASIC SEROUT. Molte
delle caratteristiche del comando DEBUG possono essere usate anche con il commando
SEROUT, compresi i testi racchiusi entro virgolette e i caratteri di formato come DEC, BIN,
DIG, e così via. Tutti questi comandi producono nel LCD risultati simili a quelli del
terminale di Debug. I codici di controllo del LCD sono diversi e più numerosi di quelli
utilizzati con il terminale di Debug. Anziché tentare di utilizzare CR, CLS, CRSRXY, ecc.,
si possono utilizzare i valori dei codici di controllo elencati nell’insieme dei comandi per
il LCD. E’ anche buona idea definire delle costanti per questi valori, come ad esempio
ClsLcd CON 12, ClrLcd CON 13, LcdOn CON 22, LcdOff CON 21, e così via.
Il LCD seriale Parallax ha otto caratteri personalizzati, da 0 a 7. Potete visualizzare
qualsiasi di questi caratteri inviandone il valore al LCD. Ad esempio, il comando
SEROUT 14, 84, [3] produce sul LCD la scrittura del Carattere Personalizzato 3. I
comandi per definire i caratteri personalizzati vanno da 248 a 255. L’invio di 248 dice al
LCD di definire il Carattere Personalizzato 0, 249 definisce il Carattere Personalizzato 1,
e così via, fino a 255, che definisce il carattere personalizzato 7. Dopo aver inviato un
comando Definisci Carattere Personalizzato, i successivi otto byte sono valori binari, di
cui i cinque bit meno significativi definiscono i pixel in una data riga di pixel. Un 1
rende il pixel nero, e uno 0 lo rende bianco.
Questo capitolo presenta anche un sottoprogramma per far scorrere il testo da destra a
sinistra all’interno di una finestra. Questo sottoprogramma (subroutine) cerca gli
indirizzi di avvio e arresto corrispondenti alle etichette di indirizzo Symbol che precedono
le direttive DATA contenenti il testo da visualizzare. Il modo in cui è visualizzato il testo
della subroutine è definito da cinque variabili: InizioMessaggio, FineMessaggio,
FinestraSinist, FinestraDestra, e incremento. Le variabili InizioMessaggio e
FineMessaggio memorizzano gli indirizzi di inizio e di fine EEPROM del testo che si
vuole visualizzare. Le variabili FinestraSinist e FinestraDestra memorizzano gli
indirizzi di carattere di inizio e fine LCD che definiscono la finestra, e la variabile
incremento memorizza di quanti caratteri per volta il messaggio scorre da destra a
sinistra.
Domande
1. Fate i nomi di tre dispositivi da voi utilizzati ogni giorno, che visualizzano
informazioni tramite LCD.
2. Che cosa indicano il 2 e il 16 nel nome di dispositivo LCD 2x16?
3. Quale comando usate per inviare informazioni al LCD Seriale Parallax?
4. In che cosa differiscono i comandi DEBUG e SEROUT?
5. In quale posizione occorre che siano gli interruttori SW1 e SW2 se volete
scrivere un programma che invii messaggi al LCD Seriale Parallax ad una
velocità di trasmissione di 19.200 bps?
6. Quale componente dovete regolare per cambiare il contrasto di visualizzazione
del LCD?
7. Quale commando SEROUT cancellerà il display?
8. Quali considerazioni speciali entrano in gioco quando si usano i codici di
controllo CR, CLS, e HOME del comando DEBUG con il LCD Seriale Parallax?
9. Quali sono i tre argomenti che occorrono in un comando SEROUT minimo?
10. In che modo potete far lampeggiare il testo visualizzato nel LCD?
11. Quali intervalli di valori potete inviare al LCD per posizionare il cursore?
12. Quale carattere risiede per impostazione nel Carattere Personalizzato 1?
13. In che modo visualizzate un carattere personalizzato dopo che lo avete definito?
14. Quali applicazioni della finestra scorrevole conoscete?
Esercizi
1. Far comparire il messaggio “Ciao” nel Terminale di Debug senza utilizzare il
comando DEBUG.
2. Visualizzare il messaggio "Ciao" centrato sulla riga superiore del LCD.
3. Far lampeggiare il messaggio "Ciao" una volta al secondo.
4. Scrivere un comando che faccia apparire il messaggio "Inizia" al principio della
riga 0 e il messaggio "Termina" sul lato destro della riga 1.
5. Scrivere un comando SEROUT per inviare i messaggi al LCD quando gli
interruttori SW1 e SW2 sono entrambi ON.
6. Scrivere un comando SEROUT per inviare un messaggio al LCD quando SW1 è
ON e SW2 è OFF.
Progetti
1. Scrivere un programma che visualizzi un messaggio di sei righe. Deve iniziare
visualizzando le righe 0 e 1 con una pausa. Quindi deve proseguire con le righe
2 e 3, di nuovo con una pausa. E finalmente, visualizza le righe 4 e 5.
2. Scrivere un programma che stampi tre copie di un carattere personalizzato. Poi,
ridefinite il carattere personalizzato. Che cosa accade a tutte e tre le copie del
carattere personalizzato?
Soluzioni
D1.
D2.
D3.
D4.
Orologio da polso, calcolatore, telefono (le risposte possono variare).
Due righe di testo, ciascuna riga larga 16 caratteri.
Il comando SEROUT.
Quando utilizzate il comando SEROUT dovete specificare il numero di pin
(piedino) e la velocità di trasmissione.
D5. Per avere la velocità di 19.200 bps, entrambi gli interruttori SW1 e SW2 devono
essere in posizione ON.
D6. Un potenziometro.
D7. Il comando SEROUT 14, 84, [12] cancellerà il display.
D8. Le costanti predefinite PBASIC del tipo di CR, CLS, e HOME non debbono essere
definite necessariamente in modo corretto per lavorare con il LCD seriale.
D9. Il comando SEROUT richiede gli argomenti Pin, Baudmode, e DataItem.
D10. Scrivere il testo, quindi far lampeggiare il display con i caratteri di controllo 21 e
22.
D11. Da 128 a 143 per la riga 0, e da 148 a 163 per la riga 1.
D12. La barra rovesciata.
D13. Inviare al LCD il valore del carattere di controllo con il comando SEROUT. Ad
esempio, SEROUT 14, 84, [4] visualizzerà il Carattere Personalizzato 4.
D14. Gli schermi LCD, perfino quelli grandi che si vedono nelle stazioni ferroviarie,
ai cancelli di imbarco degli aeroporti, o negli eventi sportivi, oppure i testi
scorrevoli nelle applicazioni Windows e nei pacchetti TCP/IP.
E1. Dal file di aiuto del BASIC Stamp Editor: “Impostare nel comando SEROUT
l’argomento Tpin per la porta seriale incorporata a 16.”
' Sensori Intelligenti e loro Applicazioni - Eser01_Cap1.bs2
' {$STAMP BS2}
' {$PBASIC 2.5}
DEBUG "Ciao, sono il comando DEBUG", CR
SEROUT 16, 84, ["Ciao – Ecco il SEROUT", CR]
E2. Soluzione esempio:' Sensori Intelligenti e Applicazioni - Eser02_Cap1.bs2
' {$STAMP BS2}
' {$PBASIC 2.5}
SEROUT 14, 84, [22, 12]
'
1234567890123456
SEROUT 14, 84, ["
Ciao
", CR]
' Accende, cancella schermo
' Centra testo su riga
' superiore
E3. Soluzione esempio:
'
'
'
'
Sensori Intelligenti e loro Applicazioni - Eser03_Cap1.bs2
Fa lampeggiare un messaggio una volta al secondo
{$STAMP BS2}
{$PBASIC 2.5}
SEROUT 14, 84, [22, 12]
'
1234567890123456
SEROUT 14, 84, ["
Ciao
", CR]
DO
SEROUT 14, 84, [21]
PAUSE 500
SEROUT 14, 84, [22]
PAUSE 500
LOOP
' Centra testo su riga sup.
' Spenge schermo
' Accende schermo
'
'
'
'
Scrive Avvio a inizio riga1, Fine a fine riga2
{$STAMP BS2}
{$PBASIC 2.5}
SEROUT
SEROUT
SEROUT
SEROUT
14,
14,
14,
14,
84,
84,
84,
84,
[22, 12]
["Avvio"]
[160]
["Fine"]
'
'
'
'
Accende, cancella schermo
Scrive su Riga 0
Riga2, 4° car da bordo dx
Scrive a bordo dx Riga 1
'
'
'
'
Scrive a 19200 baud
{$STAMP BS2}
{$PBASIC 2.5}
SEROUT 14, 32, [22, 12]
SEROUT 14, 32, ["Uso 19200 bps"]
' Scrive su Riga 0
'
'
'
'
Scrive a 2400 baud
{$STAMP BS2}
{$PBASIC 2.5}
SEROUT 14, 396, [22, 12]
SEROUT 14, 396, ["Uso 2400 bps"]
' Scrive su Riga 0
P1. Soluzione esempio:
'
'
'
'
Sensori Intelligenti e loro Applicazioni - Progetto1Cap1.bs2
Visualizza un messaggio di 6 righe
{$STAMP BS2}
{$PBASIC 2.5}
PinLcd
T9600
PIN
CON
14
84
PAUSE 250
SEROUT 14, 84, [22, 12]
PAUSE 5
SEROUT PinLcd,
SEROUT PinLcd,
PAUSE 1500
SEROUT PinLcd,
SEROUT PinLcd,
PAUSE 1500
SEROUT PinLcd,
SEROUT PinLcd,
' Accende e cancella il display
' ritarda 5 ms per cancellare il display
T9600, ["Non ho mai fatto"]
T9600, ["interferire la "]
T9600, ["mia istruzione "]
T9600, ["con l’educazione"]
T9600, ["
T9600, ["
-Mark Twain"]
1835-1910 "]
END
P2. Tutte e tre le copie cambieranno nel carattere appena definito! E’ come una
magia. Qui sotto è mostrato un programma esempio.
'
'
'
'
Sensori Intelligenti e loro Applicazioni – Progetto2Cap1.bs2
Scrive 3 copie del carattere personalizzato, quindi lo ridefinisce.
{$STAMP BS2}
' Dispositivo scelto
= BASIC Stamp 2
{$PBASIC 2.5}
' Linguaggio di progr. = PBASIC 2.5
Riga0
Riga1
copie
CON
CON
VAR
128
148
Nib
PAUSE 250
SEROUT 14, 84, [22, 12]
PAUSE 5
' Accende il display e lo cancella
' ritarda 5 ms per cancellare il display
SEROUT 14, 84, [248,
%00110,
%00101,
%00100,
%11111,
%00100,
%01110,
%10101,
%00100]
' Definisce il Carattere personalizzato 0
'
* *
'
*
*
'
*
' * * * * *
'
*
'
* * *
' *
*
*
'
*
FOR copie = 1 TO 3
SEROUT 14, 84, [0]
NEXT
' Visualizza Carattere personalizzato 0
PAUSE 1000
' Pausa per permettere di vedere il car.
SEROUT 14, 84, [Riga1, "ora ri-definisco"]' Visualizza mess. su Riga 1
PAUSE 1000
SEROUT 14, 84, [Riga1, "
"]' Cancella messaggio
SEROUT 14, 84, [248,
%00100,
%10011,
%01001,
%00101,
%00001,
%00010,
%00100,
%11000]
END
' Ri-definisce Carattere personalizzato 0
'
*
' *
* *
'
*
*
'
*
*
'
*
'
*
'
*
' * *
CapItolo 2: Il sensore ultrasonico Ping))) · Pagina 43
Capitolo 2: Il sensore Ultrasonico Ping))) di
Distanza
Il sensore Ping))), interfacciato con un BASIC Stamp, può misurare quanto gli oggetti
siano lontani (in altre parole, la loro distanza dal sensore stesso). Con un intervallo di
distanze che va da 3 centimetri a 3.3 metri, è una vittoria certa in qualsiasi numero di
progetti di robotica e automazione. E’ anche notevolmente preciso, dato che rileva molto
agevolmente la distanza di un oggetto fino ai centimetri.
Figura 2-1
Il sensore ultrasonico
™
di distanze Ping)))
COME LAVORA IL SENSORE PING)))?
La Figura 2-2 mostra come il sensore Ping))) invii un breve pigolio con il suo
altoparlante ultrasonico e misuri il tempo di ritorno dell’eco al suo microfono ultrasonico.
Il BASIC Stamp inizia il processo, inviando al sensore Ping))) un impulso per avviare la
misura. Poi, il sensore Ping))) aspetta abbastanza a lungo per consentire al programma
del BASIC Stamp di avviare un comando PULSIN. Quindi, contemporaneamente, il
sensore Ping))) emette il suo pigolio a 40 kHz, ed invia un segnale alto al BASIC Stamp.
Quando il sensore ne rileva l’eco col suo microfono ultrasonico, cambia quel segnale alto
riportandolo di nuovo allo stato basso.
Il funzionamento del sensore Ping))) ricorda molto da vicino gli apparati sonar installati a
bordo dei sottomarini, che servono a rilevare la presenza di altri scafi metallici e a
misurarne la distanza.
pigolio
Impulso di avvio
Eco
Impulso del tempo di eco
Figura 2-2: Come lavora il sensore Ping)))
Il commando BASIC Stamp PULSIN utilizza una variabile per memorizzare quanto lunga
sia la durata del segnale a livello alto del sensore Ping))). Questa misura di tempo è la
misura di quanto impieghi il suono a viaggiare fino all’oggetto e a tornare indietro.
Utilizzando la misura e la velocità del suono nell’aria, potrete far sì che il vostro
programma calcoli la distanza dell’oggetto in centimetri, pollici,, piedi, ecc.
I pigolii del sensore Ping))) non sono udibili poiché 40 kHz è frequenza ultrasonica.
Quello che consideriamo suono è la capacità del nostro orecchio interno di rilevare le
variazioni di pressione dell’aria causate da vibrazione. La velocità di queste variazioni
determina quanto il suono sia acuto. Toni di frequenza più alta producono suoni più acuti e
toni di frequenza più bassa producono suoni più gravi.
La maggior parte delle persone possono sentire toni che vanno da 20 Hz, che è un tono
molto basso, a 20 kHz, che è un tono molto alto. Subsonico è un suono con frequenze
sotto 20 Hz, e ultrasonico è un suono con frequenze sopra 20 kHz. Poiché i pigolii del
sensore Ping))) sono a 40 kHz, essi sono definitivamente ultrasonici, e non udibili dalle
persone.
ACTIVITÀ #1: MISURA DEL TEMPO DI ECO
In questa attività, proverete il sensore Ping))) e verificherete che vi dà le misure del
tempo di eco che corrispondono alla distanza di un oggetto.
Parti richieste
(1) Sensore ultrasonico di distanza Ping)))
(3) Fili per il cablaggio
Tutto ciò che vi occorre è un sensore Ping))) e tre fili di cablaggio per farlo lavorare. Il
sensore Ping))) ha una protezione incorporata contro gli errori di programmazione (e gli
errori di cablaggio), in modo che non c’è bisogno di utilizzare una resistenza da 220 Ω tra
P15 e il terminale SIG (segnale) del sensore Ping))).
Circuito del sensore Ping)))
La Figura 2-3 mostra lo schema circuitale e il cablaggio necessari a provare il sensore
Ping))).
√
Costruite il circuito.
Figura 2-3: Schema circuitale e cablaggio del sensore Ping)))
Prova del sensore Ping)))
Come ricordato prima, il sensore Ping))) necessita di un impulso di avvio dal BASIC
Stamp, impulso che avvia la sua misura. Un impulso su P15 che duri 10 µs (PULSOUT
15, 5) è facilmente rilevato dal sensore Ping))), e il BASIC Stamp impiega pochissimo
tempo ad inviarlo. Un comando PULSIN che memorizza la durata dell’impulso di eco del
sensore Ping))) (PULSIN 15, 1, time) deve seguire immediatamente il comando
PULSOUT. In questo esempio, il risultato che il comando PULSIN memorizza nella
variabile tempo è esattamente il tempo che il pigolio del sensore Ping))) impiega per
raggiungere l’oggetto, riflettersi, e ritornare al sensore.
Programma esempio – ProvaPing.bs2
Potete provare il programma che segue misurando la distanza di alcuni oggetti molto
vicini. Per misure ravvicinate (oggetti in primo piano), il sensore Ping))) ha bisogno
soltanto di essere da 3 a 4 pollici (approssimativamente da 8 a 10 cm) al di sopra della
vostra superficie di lavoro. Comunque, se state misurando oggetti distanti più di mezzo
metro, può servire di far salire di altezza il sensore Ping))), per evitare che gli echi del
pavimento siano registrati come oggetti rilevati.
√
√
√
√
√
√
Ponete la vostra Board of Education con il circuito del sensore Ping))) su
qualcosa che la mantenga ad un’altezza di almeno 8 cm sopra la superficie del
tavolo.
Ponete un oggetto (una bottiglia di acqua, una scatola o un bersaglio di carta) a
15 cm dalla parte anteriore del sensore Ping))).
Digitate, memorizzate ed eseguite ProvaPing.bs2.
Il terminale di debug dovrebbe iniziare a riportare un valore nell’intervallo da
400 a 500.
Muovete il bersaglio ad una distanza di 30 cm dal sensore Ping))) e verificate
che il valore della variabile tempo sia all’incirca raddoppiato.
Puntate il vostro sensore Ping))) su molti oggetti vicini e lontani, e osservate le
misure di tempo.
' Sensori intelligenti e loro applicazioni - ProvaPing.bs2
' Prova il sensore ultrasonico di distanza Ping)))
' {$STAMP BS2}
' {$PBASIC 2.5}
tempo VAR Word
DO
PULSOUT 15, 5
PULSIN 15, 1, tempo
DEBUG HOME, "tempo = ", DEC5 tempo
PAUSE 100
LOOP
Il vostro turno – Prova di intervallo, angolo e misura di un oggetto
In termini di precisione ed utilità complessiva, la rilevazione della distanza è realmente
importante, specie se la si confronta con altri sistemi economici di rilevazione di distanze.
Ciò non vuol dire che il sensore Ping))) sia capace di misurare "qualsiasi cosa". La
Figura 2-4 mostra alcune situazioni per la cui misura Ping))) non è progettato: (a)
distanze sopra i 3 metri, (b) angoli molto piccoli, e (c) oggetti di dimensioni minime.
Figura 2-4: Il sensore Ping))) non è progettato per queste situazioni
oggetti
troppo
piccoli
θ<45°
(circa)
:
a.
b.
c.
In aggiunta, come ha scoperto Ken Gracey della Parallax Inc. durante una dimostrazione
in classe nella scuola di suo figlio, alcuni oggetti con superfici morbide, irregolari (come
gli animali di peluche) assorbiranno, anziché riflettere, il suono e per questa ragione può
essere difficile che il sensore Ping))) li rilevi. Gli oggetti con superfici lisce che riflettono
prontamente il suono sono rilevati più facilmente dal sensore.
√
√
Provate a puntare il sensore Ping))) su vari oggetti a diverse distanze. Qual è il
valore più grande che il sensore Ping))) restituisce? Quanto vicino all’oggetto
dovete mettervi prima che il tempo di misura inizi a diminuire?
Provate a stare in piedi a distanza di un metro dalla parete, e puntate il sensore
Ping))) contro la parte, e registrate la misura. Poi, provate a puntare il sensore
Ping))) sulla parte a diversi angoli, come indica la Figura 2-5. I valori
cambiano? A quale angolo il sensore Ping))) smette di rilevare la parete?
Figura 2-5
Determinazione del
minimo angolo di
rilevamento
√
√
Provare ad appendere vari oggetti al soffitto a circa 1,5 metri dal sensore
Ping))). Quanto può essere piccolo l’oggetto? La forma o l’angolo sono
importanti? La richiesta di dimensione cambia a 0,5 metri?
Provare a rilevare oggetti di dimensioni analoghe, ma fatti di materiali diversi,
come una scatola da scarpe di cartone e una pantofola di pelo, per vedere se
avete una distanza effettiva inferiore con oggetti fono-assorbenti. Potete trovare
un qualsiasi oggetto invisibile al sensore Ping)))? Che succede con un tampone
di palline di cotone, o una reticella di tulle?
ATTIVITÀ #2: MISURE IN CENTIMETRI
Questa attività mostra come usare la velocità del suono e l’operatore PBASIC di
Moltiplicazione Alta ( ** ) per calcolare la distanza di un oggetto basandosi sulla misura
del tempo di eco dal sensore Ping))) .
Calcolo della distanza in centimetri con il PBASIC
L’equazione per il calcolo della distanza percorsa dal suono è S = Caria t, dove S è la
distanza, Caria è la velocità del suono nell’aria, e t è il tempo. Poiché la misura di tempo
del sensore Ping))) fornisce il tempo che il suono impiega per raggiungere un oggetto e
tornare indietro di rimbalzo, la distanza effettiva, Soggetto, è la metà della distanza totale
percorsa dal suono.
S = C aria t
S oggetto =
S C aria t
=
2
2
La velocità del suono in aria è espressa comunemente in termini di metri per secondo
(m/s). Però, per il calcolo con il BASIC Stamp, le misure in centimetri (cm) saranno più
convenienti per fare i calcoli. Poiché un metro ha 100 centimetri, usiamo Soggetto-cm che è
semplicemente 100 volte Soggetto. Le unità di misura dell’argomento durata nel
commando PULSIN Durata del BASIC Stamp 2 sono di 2/1.000.000 di secondo (2 µs).
Quindi, al posto di t, che deve essere misurato in secondi, useremo tPULSIN-BS2. Se
moltiplicato per 2/1.000.000, tPULSIN-BS2 dà il numero di secondi. C’è una coppia di 2 a
numeratore e a denominatore che si cancellano, e 100 a numeratore elimina due degli zeri
nel 1.000.000 a denominatore. Il risultato di queste sostituzioni e cancellazioni è
Sogetto-cm = (Caria tPULSIN-BS2)/10.000.
Soggetto-cm =
Soggetto-cm =
Soggetto-cm =
100 Caria t
2
100 C aria t PULSIN-BS2
2
×
2
1.000.000
Caria tPULSIN-BS2
10,000
La velocità del suono in aria a temperatura ambiente di 72 °F (22.2 °C) è di 344,8 m/s.
Dividendo 10.000 per questo valore, ottieniamo Soggettit-cm = 0,03448 tPULSIN-BS2.
Soggetto-cm =
344,8 t PULSIN-BS2
10,000
= 0,03448 t PULSIN-BS2
Il BASIC Stamp può utilizzare l’operatore ** per moltiplicare una variabile che
memorizza il valore misura della Durata nel comando PULSIN, per un valore
frazionario minore di 1. Ad esempio, se il comando PULSIN memorizza la misura di eco
nella variabile tempo, questo comando memorizzerà il risultato di distanza in centimetri
nella variabile DistanzaCm:
DistanzaCm = CostanteCm ** tempo
Con l’operatore **, la variabile CostanteCm dovrà contenere il valore 2260, che è
l’equivalente di 0,03448 ottenuto con **. Invece di un denominatore decimale, come
10.000 (nel caso di 0,03448), l’operatore ** ha bisogno di un valore che sarebbe il
numeratore di una frazione avente per denominatore 65536. Per ottenere quel
numeratore, moltiplicate il vostro valore frazionario per 65536.
CostanteCm = 0,03448 × 65536 = 2260
Ora, abbiamo ottenuto il valore che ci serve per modificare ProvaPing.bs2 in modo che
misurerà la distanza in centimetri. Aggiungeremo anche una variabile per memorizzare
la distanza (DistanzaCm) assieme alla costante che memorizza il valore 2260
(CostanteCm).
CostanteCm
CON
2260
DistanzaCm
VAR
Word
Quindi, il calcolo eseguito con ** può essere aggiunto al DO...LOOP del ProvaPing.bs2 per
calcolare la misura dei centimetri. Il comando DEBUG nel programma può essere
modificato perché visualizzi la misura.
DEBUG HOME, DEC3 DistanzaCm, " cm"
Programma esempio: MisuraCmPing.bs2
√
√
√
√
Digitate, memorizzate ed eseguite MisuraCmPing.bs2.
Muovete l’oggetto bersaglio finché la misura visualizza 20 cm.
Allineate il vostro righello con quella misura. La tacca di 0 cm dovrebbe
allinearsi in qualche posto con il sensore Ping))), di solito in qualche posto tra il
circuito stampato e la parte anteriore dell’altoparlante/microfono.
Ora, sperimentate con la misura di altre distanze.
' Sensori intelligenti e loro applicazioni - MisuraCmPing.bs2
' Misura una distanza col sensore Ping))) e la visualizza in centimetri.
' {$STAMP BS2}
' {$PBASIC 2.5}
' Costante di conversione per misure a temperatura ambiente.
CostanteCm CON
2260
DistanzaCm
tempo
VAR
VAR
Word
Word
DO
PULSOUT 15, 5
PULSIN 15, 1, tempo
PAUSE 100
LOOP
Il vostro turno - Verifica dei calcoli
Verifichiamo che il programma sta calcolando la distanza in modo corretto.
√
√
Modificate MisuraPingCm.bs2 in modo che visualizzi i valori di entrambe le
variabili tempo e distanza.
Usate una calcolatrice per verificare che ottenete lo stesso risultato con
l’equazione della distanza e con il calcolo eseguito dal programma.
Soggetto-cm = 0,03448 × t PULSIN-BS2
ATTIVITÀ #3: MISURE IN POLLICI
La maggior parte dei dispositivi elettronici di misura della distanza offre risultati sia in
unità metriche che inglesi. Ad esempio, il calibro mostrato in Figura 2-6 ha un pulsante
che potrete premere per scegliere tra mm e pollici. Altri dispositivi di misura offrono
iarde o metri, o pollici o centimetri, ecc. Quindi perché il vostro programma possa
visualizzare sia centimetri che pollici, questa attività introduce agli usi dell’operatore
moltiplicazione alta ( ** ) una seconda volta per convertire da centimetri a pollici.
Figura 2-6: Calibro con pulsante di commutazione mm/pollici
Una costante per ** i pollici
The CostanteCm utilizzata nella formula DistanzaCm = tempo ** CostanteCm è
una misura della velocità del suono in centimetri per l’unità di tempo del comando
PULSOUT. In ciascun pollice ci sono 2,54 centimetri. Quindi, la formula di conversione
delle distanza da centimetri a pollici (in.) si può scrivere così:
Sin = Scm ÷ 2,54
Il modo più facile per convertire a pollici è semplicemente dividere il valore di
CostanteCm per 2,54, è utilizzare il risultato prodotto in un’altre costante, come
CostanteIn. Ricordate che le costanti per l’operatore ** dovranno essere intere, quindi
arrotondate il risultato all’intero più vicino.
CostantePol = 2260 ÷ 2,54 = 889,76
≈ 890
Programma esempio: MisuraCmEPolPing.bs2
√
√
Digitate, memorizzate ed eseguite MisuraCmEPolPing.bs2.
Provate a misurare distanze e verificate che esse siano corrette con entrambi i
sistemi di unità.
' Sensori intelligenti e loro applicazioni - MisuraCmEPolPing.bs2
' Misura distanze col sensore Ping))) e le visualizza in pollici (in) & cm
' {$STAMP BS2}
' {$PBASIC 2.5}
' Costanti di conversione per misure a temperature ambiente.
CostanteCm CON
2260
CostanteIn CON
890
DistanzaCm
DistanzaIn
tempo
VAR
VAR
VAR
Word
Word
Word
DO
PULSOUT 15, 5
PULSIN 15, 1, tempo
DistanzaIn = CostanteIn ** tempo
DEBUG CR, DEC3
DistanzaIn, " pollici"
PAUSE 100
LOOP
Il vostro turno
√
√
In 1 piede ci sono 12 pollici. Modificare il programma in modo che visualizzi
piedi e pollici. Suggerimento: Dopo aver calcolato DistanzaIn, usare / 12 per
calcolare il numero di piedi, e // 12 per trovare il resto in pollici.
In un decimetro ci sono 10 centimetri. Ripetere per decimetri e centimetri.
ATTIVITÀ #4: MISURE IN MOVIMENTO
Questa attività illustra la visualizzazione di misure in centimetri e pollici del sensore
Ping))) sul LCD seriale Parallax. Se state utilizzando una batteria come sorgente
elettrica, potrete disconnettervi dal vostro computer e prendere le impostazioni in luoghi
remoti di vostra scelta.
Connessione del sensore Ping))) con un cavo di prolunga
Per far spazio al LCD seriale Parallax sulla scheda Board of Education, connetteremo il
sensore Ping))) alla scheda con un cavo di prolunga .Potrete quindi mantenerlo orientato
e puntarlo su vari luoghi, o utilizzare un supporto per montarlo vicino alla vostra Board
of Education.
Parti richieste
(1) Sensore Ultrasonico Ping)))
(1) LCD Seriale Parallax (2×16)
(1) Cavo di prolunga per il LCD da 14 pollici
(3) Fili per il cablaggio
Se state lavorando da una scheda BASIC Stamp HomeWork Board o da una Board of
Education Rev A or B seriale, vi occorreranno anche:
(1) cavallotto a 3-pin
(3) Fili di cablaggio aggiuntivi
Cablaggi di connessione per Sensore Ping))) e LCD
Gli schemi indicati in Figura 2-7 riportata qui sotto sono identici a quelli che abbiamo
utilizzato per il sensore Ping))) e il LCD Seriale Parallax fino a questo punto.
Cambieremo ora il modo in cui sono fatte queste connessioni elettriche aggiungendo un
cavo, in modo che entrambi i dispositivi siano connessi convenientemente alla vostra
scheda nello stesso tempo. Sebbene gli schemi siano gli stessi, le connessioni reali
tramite cavo varieranno a seconda di quale scheda didattica BASIC Stamp stiate
utilizzando.
Figura 2-7
Schema del Sensore Ping))) e
del LCD Seriale Parallax
LCD Parallax
Cablaggi di connessione per la scheda Board of Education Rev C e per la
Board of Education USB
Queste istruzioni riguardano le schede che hanno le porte dei servo con un cavallotto
Vdd/Vss interposto fra esse, come la scheda Board of Education Rev C e la scheda Board
of Education USB. Per tutte le altre schede, saltare al paragrafo Visualizzazione di
distanze con LCD a pagina 61.
√
√
Scollegate l’alimentazione della vostra scheda (le batterie o l’alimentatore).
Ponete il cavallotto tra i servo X4 e X5 a Vdd (+5 V) come indicato in Figura 28. Il cavallotto deve stare tra i due pin più vicini a Vdd, e il terzo pin vicino a
Vin dovrà essere visibile.
Figura 2-8
Il cavallotto tra le Porte Servo
posizionato su
Vdd (+5 V)
I posizionamenti del cavallotto su Vdd o Vin determinano quale alimentazione sia
connessa alle porte X4 e X5. Quando il cavallotto è posizionato su Vdd, queste porte
ricevono 5 V regolati dal regolatore di tensione della Board of Education. Se il cavallotto è
posizionato su Vin, la porta riceve tensione direttamente dalla batteria o da un alimentatore.
√
√
√
Collegate il LCD seriale Parallax come indicato. E’ lo stesso collegamento del
capitolo precedente.
Inserite una estremità del cavo di prolunga nella Porta 15 del connettore X4,
assicurandovi che le scritte "Red" (“Rosso”) e "Black" (“Nero”) poste sulla
destra della porta X5 siano allineate con i fili rosso e nero del cavo.
Verificate che il vostro cavo sia inserito correttamente accertandovi che il filo
bianco sia vicino alla parte della scritta 15 e il filo nero sia vicino alla scritta X4.
Figura 2-9
Porta del Servo e
connessione del
cavallotto per il
sensore Ping)))
√
√
Collegate l’altra estremità del cavo in modo che il filo nero sia connesso al
piedino (pin) GND del modulo Ping))), il filo rosso sia connesso al pin 5 V, e il
filo bianco sia connesso al pin RX.
Controllate due volte tutte le vostre connessioni, inclusi i posizionamenti del
cavallotto, e accertatevi che siano corrette.
ATTENZIONE! Non collegate la tensione alla vostra scheda fin quando non siete certi
che i collegamenti siano corretti. Se fate un errore con le connessioni del LCD, il
LCD Seriale Parallax potrebbe esser danneggiato permanentemente.
√
√
Collegate di nuovo l’alimentazione alla scheda.
Ponete l’interruttore a 3 posizioni della scheda Board of Education su 2.
√
Se avete una scheda Board of Education Rev C, saltate a Visualizzazione di
distanze con LCD a pagina 61.
Potete anche collegare con un cavo il LCD seriale Parallax alla Porta 14. Le istruzioni
sono quasi le stesse di quelle per connettere il Ping))). Iniziate scollegando l’alimentazione
della vostra scheda. Il cavallotto per Vdd e Vin tra le porte servo deve essere posizionato
su Vdd. Il cavo deve essere inserito nel connettore X4 in modo che il filo nero sia dalla
parte della scritta X4 e il filo bianco sia vicino alla scritta 14. Quando collegate l’altra
estremità del cavo al LCD Seriale Parallax, assicuratevi che il filo nero sia connesso al pin
GND, il filo rosso a 5V, e il filo bianco a RX.
Questo capitolo riguarda la connessione del sensore Ping))) e del LCD Seriale Parallax ad
una delle seguenti schede didattiche BASIC Stamp:
•
•
Scheda HomeWork BASIC Stamp
Board of Education Rev A (versione seriale)
Board of Education Rev B (versione seriale)
√
√
Scollegate l’alimentazione dalla vostra scheda.
Costruite i collegamenti sulla breadboard come mostrato in Figura 2-10.
•
Figura 2-10
Cablaggi della Breadboard per il
collegamento del cavo al
sensore Ping)))
√
√
√
Inserite il LCD Seriale Parallax nella breadboard come mostrato in Figura 2-11 a
pagina 60.
Inserite una estremità del cavo di prolunga nel connettore a tre pin, assicurandovi
che i fili bianco, rosso e nero siano orientati come mostrato. Il filo nero dovrà
essere collegato a Vss, il filo rosso a Vdd, e il filo bianco a P15.
Collegate l’altra estremità del cavo in modo che il filo nero sia connesso al pin
GND del Ping))), il filo rosso sia connesso al pin 5 V, e il filo bianco sia
connesso al pin RX. Controllate due volte tutte le vostre connessioni, compresa
la posizione del cavallotto, e accertatevi che siano corrette.
ATTENZIONE! Non collegate l’alimentazione alla vostra scheda fin quando non siate
certi che i collegamenti siano corretti. Se fate un errore nelle connessioni del LCD, il
LCD Seriale Parallax può essere danneggiato permanentemente .
√
Ricollegate l’alimentazione alla vostra scheda.
Figura 2-11: Connessioni sulla Breadboard per il Sensore Ping))) e il LCD Seriale Parallax
Visualizzazione di distanze con LCD
Non occorrono molte modifiche perché il programma MisuraCmEdInPing.bs2 visualizzi
le sue misure sul LCD. Prima di tutto, si deve aggiungere una parte ad Inizializzazione in
modo che il programma aspetti fin quando la tensione di alimentazione si stabilizza e poi
accenda e cancelli il LCD.
PAUSE 200
SEROUT 14, 84, [22, 12]
PAUSE 5
Quindi si devono convertire i comandi DEBUG in comandi SEROUT. Eccovi i comandi
DEBUG dal programma MisuraCmEdInPing.bs2.
DEBUG CR, DEC3 DistanzaIn, " pollici"
I caratteri di controllo del Terminale di Debug (HOME e CR) devono essere cambiati nei
codici di controllo che posizionano il cursore del LCD.
SEROUT 14, 84, [128, DEC3 DistanzaCm, " cm"]
SEROUT 14, 84, [148, DEC3 DistanzaIn, " poll."]
Programma esempio: CmEPolPingLcd.bs2
Questo programma è una versione modificata del programma MisuraCmEPolPing.bs2
dell’attività precedente. Invece di visualizzare le sue misure nel terminale di Debug, le
visualizza nel LCD Seriale Parallax.
√
√
√
Collegate la batteria alla vostra scheda.
Digitate, memorizzate ed eseguite CmEdInPingLcd.bs2.
Scollegate il cavo seriale, e portate la vostra scheda con voi dovunque vogliate
per verificare le misure del sensore Ping))).
' Sensori intelligenti e loro applicazioni - MisuraCmEPolPing.bs2
' Misura distanze col sensore Ping))) e le visualizza in pollici (in) & cm
' {$STAMP BS2}
' {$PBASIC 2.5}
' Costanti di conversione per misure a temperature ambiente.
CostanteCm CON
2260
CostanteIn CON
890
DistanzaCm
VAR
Word
DistanzaIn
tempo
VAR
VAR
Word
Word
DO
PULSOUT 15, 5
PULSIN 15, 1, tempo
DEBUG CR, DEC3
DistanzaIn, " pollici"
PAUSE 100
LOOP
Il vostro turno – Personalizzazione del Display
√
√
√
Le misure sono di solito allineate a sinistra. Provate a centrarle.
Provate ad allineare a destra le misure e a visualizzare "Distanza: " prima della
misura in cm sulla riga superiore del LCD.
Modificate il programma in modo che visualizzi entrambe le misure della
distanza sulla riga superiore. Quindi, visualizzate il tempo effettivo di eco sulla
riga inferiore. Potrete visualizzarlo in milionesimi di secondo (µs) moltiplicando
la variabile tempo per 2 prima di visualizzarla. Assicuratevi che il vostro
programma aspetti fino a dopo che ha fatto le sue conversioni di distanza prima
di moltiplicare il tempo per 2.
ATTIVITÀ #5: EFFETTO DELLA TEMPERATURA SULLA VELOCITÀ DEL
SUONO
Questa attività indaga sulle variazioni nella velocità del suono prodotti da variazioni della
temperatura dell’aria. Queste variazioni della velocità del suono possono produrre
cambiamenti visibili alle vostre misure di distanza.
Velocità del suono in rapporto alla temperatura e misure dell’errore
percentuale
La velocità del suono cambia con la temperatura dell’aria, con l’umidità, e persino con la
qualità dell’aria. Né l’umidità né la qualità dell’aria provocano differenze consistenti, tali
da incidere nei calcoli di distanza del sensore Ping))). La temperatura dell’aria, d’altra
parte, può produrre errori di distanza misurabili. La velocità del suono aumenta di 0,6
metri al secondo (m/s) per ogni grado Celsius (°C) di aumento della temperatura. Dal
momento che la velocità del suono è di circa 331,5 m/s a 0 °C, possiamo utilizzare
l’equazione seguente per calcolare la velocità del suono a una data temperatura.
Caria = 331,5 + (0,6 × TC ) m/s
Conversione da °F a °C e Viceversa
Per convertire una misura di gradi Fahrenheit in Celsius, sottrarre 32 da TF (la misura in
Fahrenheit), poi dividere per 1,8. Il risultato sarà TC, l’equivalente in Celsius. Per convertire
da Celsius a Fahrenheit, moltiplicare TC per 1,8, quindi aggiungere 32. Il risultato sarà TF.
TC = (TF - 32) ÷ 1,8
TF =1,8×TC + 32
Qui sotto sono riportati esempi della velocità del suono per due temperature di interni
molto accettabili, ma leggermente diverse.
Esempio 1: Calcolare la velocità del suono a 22,2 °C, che equivale a circa 72 gradi
Fahrenheit (°F).
C aria (22,2°C ) = 331,5 + (0,6 × 22,2) m/s ) = 344,8 m/s
Esempio 2: Calcolare la velocità del suono a 25 °C, che equivale a 77 gradi Fahrenheit
(°F).
Caria (25°C ) = 331,5 + (0,6 × 25 ) m/s = 346,5 m/s
Che differenza produce questa variazione sulle vostre misure di distanza? Possiamo
calcolare l’errore percentuale che questa variazione propagherà con l’equazione
dell’errore percentuale.
% errore =
effettiva - prevista
× 100%
prevista
Se la temperatura prevista nella stanza è di 72 °F (22,2 °C), e la temperatura effettiva è
di 77 °F (25 °C), l’errore è lo 0,49 per cento. Un errore percentuale di mezzo per cento
può costringervi a muovere l’oggetto di mezzo centimetro oltre i 100 cm prima che la sua
distanza passi da 99 a 100 cm.
% errore =
346,5 - 344,8
× 100%
344,8
= 0,49%
Il vostro turno – Temperatura ambiente in rapporto al gelo
√
√
√
√
√
√
√
Calcolate l’errore percentuale della misura che risulterebbe supponendo che la
temperatura ambiente stia gelando (32 °F, 0 °C), ma è in realtà la temperatura
della stanza (72 °F, 22,2 °C).
Quanto scarterebbe la misura se l’oggetto fosse distante 1 m?
Usate la procedura introdotta nell’Attività #2 per calcolare la velocità del suono
e CostanteCm per la misura a 0 °C.
Memorizzate MisuraCmPing.bs2 col nome MisuraCmPingTuoTurno.bs2
Eseguite il programma prima di modificarlo e provate la misura della distanza di
un oggetto ad 1 m.
Modificate la direttiva CostanteCm CON con il valore per 0 °C.
Provate di nuovo il programma con un oggetto ad 1 m. Quanto è vicino il vostro
errore previsto all’errore effettivo?
SOMMARIO
Il BASIC Stamp richiede una misura al sensore Ping))) inviandogli un breve impulso, che
produce dal sensore l’emissione di un pigolio a 40 kHz. Poi, il Ping))) ascolta se c’è un
eco di quel pigolio. Il sensore dà conto dell’eco restituendo al BASIC Stamp un impulso
uguale al tempo che prende il sensore Ping))) per ricevere l’eco.
Per calcolare la distanza basandosi sulla misura del tempo di eco, la velocità del suono
deve essere convertita in unità convenienti per il BASIC Stamp. Questo procedimento
comporta la conversione dei metri al secondo in centimetri per unità di misura PULSIN.
Anche il valore risultante deve essere convertito in un valore utilizzabile con l’operatore
moltiplicazione alta ( ** ), moltiplicandolo per 65536.
La velocità del suono nell’aria è caria = 331,5 + (0,6 × TC) m/s. Poiché la velocità del
suono cambia con la temperatura, gli errori di misura che ne risultano sono piccoli, specie
a temperatura ambiente.
Domande
1. Qual’è l’intervallo (di sensibilità) del sensore Ping)))?
2. Cosa significa ultrasonico?
3. Quale segnale manda il sensore Ping))) al BASIC Stamp e come questo segnale
corrisponde ad una misura di distanza?
4. Quali tre scenari di orientamento sensore-oggetto possono fare in modo che il
sensore Ping))) restituisca una misura errata della distanza?
5. Quando si usa un BS2, quali incrementi di tempo vengono restituiti dal
commando PULSIN?
6. Qual’è la velocità del suono in aria a temperatura ambiente?
7. Come si rapporta la costante CostanteCm alla velocità del suono in aria?
8. Che cosa dovete fare al cavallotto posto tra i connettori dei servo X4 e X5 sulla
Board of Education per fornire la tensione di alimentazione corretta a dispositivi
come il sensore Ping))) e il LCD seriale Parallax? Cosa potrebbe accadere se
questo cavallotto non è posizionato in modo corretto?
9. Quali comandi devono essere modificati se si vuole che il LCD Parallax
visualizzi quanto sta visualizzando il Terminale di Debug?
10. Che ruolo gioca la temperature dell’aria sulla velocità del suono in aria?
Esercizi
1. Calcolare quanti metri è lontano un oggetto se il tempo di eco è di 15 ms, e la
temperatura è 22,5 °C.
2. Calcolare l’equivalente in °C di 100 °F.
3. Calcolare l’equivalente in piedi di 30,48 cm.
4. Calcolare l’errore percentuale se CostanteCm è per 37,8 °C ma la temperatura
effettiva è 0 °C. Predire quale sarebbe la distanza misurata se l’oggetto fosse
posto a 0,5 m.
Progetti
1. Aggiungere un circuito LED alla vostra scheda e programmare il BASIC Stamp
perché il LED lampeggi quando non c’è alcun oggetto nell’intervallo (di
sensibilità del sensore).
2. Utilizzare un piezo - altoparlante per costruire un allarme che segnali quando una
persona attraversa il vano di una porta. Il sensore Ping))) dovrà essere montato
vicino al vano della porta, puntando il centro del cammino lungo il quale una
persona camminerà quando entra o esce dalla porta.
Capitolo 2: Inclinazione con l’accelerometro Memsic · Pagina 67
Soluzioni
Q1. Da 3 centimetri a 3,3 metri.
Q2. Un suono con frequenza superiori a 20 kHz.
Q3. Un impulso alto, la cui durata corrisponde al tempo che impiega il pigolio sonoro
a viaggiare fino all’oggetto e tornare al sensore.
Q4. a) Distanza sopra i 3 metri, b) Angoli stretti, c) Oggetti troppo piccoli.
Q5. Incrementi di 2µs.
Q6. 344,8 m/s.
Q7. CostanteCm è l’equivalente, operato da **, della velocità del suono nell’aria
diviso per 10000, ovvero 0,03448.
Q8. Il cavallotto deve essere posto nella posizione Vdd, altrimenti il LCD potrebbe
essere danneggiato.
Q9. Tutti i comandi DEBUG devono essere modificati, e i caratteri di controllo devono
essere modificati nei corrispondenti codici di controllo del LCD.
Q10. Un ruolo molto importante, con la velocità del suono che aumenta di 0,6 m/s per
ciascun aumento di un grado °C nella temperatura dell’aria.
E1. L’oggetto è distante 2,59 m.
E2. 100 °F = 37,7 °C
E3. 30,48 cm = 1,0 ft.
E4. % errore = +/- 6,84%; distanza misurata = 0,466 m.
P1. La soluzione esempio che segue pone un LED su P13 in stato attivo - alto.
'
'
'
'
'
Sensori intelligenti e loro applicazioni - Cap2_Progetto1.bs2
Indica misure fuori-intervallo con un LED che lampeggia. Regola
DistanzaMax per adattarla.
{$STAMP BS2}
{$PBASIC 2.5}
LED
LCD
Ping
PIN
PIN
PIN
13
14
15
' LED rosso attivo alto
' LCD Seriale Parallax
' sensore Ping))) Parallax
CostanteCm
CostanteIn
DistanzaMax
CON
CON
CON
2260
890
361
' Calcola tempo viaggio del suono
DistanzaCm
tempo
VAR
VAR
Word
Word
PAUSE 200
SEROUT LCD, 84, [22, 12]
PAUSE 5
DO
'
'
'
'
Il massimo che si può misurare
(empirico)
Distanza in centimetri
Tempo di eco del viaggio
' Inizializza LCD
LOW LED
' LED spento prima di ciascun misura
PULSOUT 15, 5
' Avvia sensore Ping)))
PULSIN 15, 1, tempo
' Legge il tempo di eco
' Calcola distanza da tempo
SEROUT LCD, 84, [128, DEC3 DistanzaCm, " cm"] ' Stampa distanza su
' schermo LCD
IF DistanzaCm >= DistanzaMax THEN HIGH LED
' Commuta LED se fuori
' dell’’intervallo
PAUSE 100
LOOP
' Sensori intelligenti e loro applicazioni - Progetto2Cap2.bs2
' Produce un suono quando qualcuno attraversa il vano della porta.
' {$STAMP BS2}
' {$PBASIC 2.5}
' -----[ Definizioni
Ping
PIN
Altoparlante
PIN
I/O]--------------------------------------------15
' Sensore Ping))) Parallax
9
' Altoparlante opzionale
' -----[ Costanti ]--------------------------------------------------CostanteIn
CON
890
MontantePorta CON
35
' Larghezza vano porta è 35 pollici
' -----[ Variabili ]--------------------------------------------------DistanzaIn
VAR
Word
tempo
VAR
Word
' Tempo di eco del viaggio
contatore
VAR
Nib
' -----[ Routine principale ]-----------------------------------------DO
GOSUB Legge_Ping
GOSUB Calcola_Distanza
IF (DistanzaIn < MontantePorta) THEN
GOSUB Suona_Allarme
ENDIF
LOOP
' -----[ Subroutines ] -----------------------------------------------Legge_Ping:
PULSOUT 15, 5
' Avvia sensore Ping)))
PULSIN 15, 1, tempo
' Legge tempo di eco
RETURN
Suona_Allarme:
FREQOUT Altoparlante, 300, 3300
PAUSE 50
FREQOUT Altoparlante, 450, 2200
RETURN
Calcola_Distanza:
RETURN
' Bing
' Bong
' Ecco tutte le misure
Capitolo 3: L’Accelerometro Memsic a due assi
L’accelerazione è una misura di quanto rapidamente varia la velocità. Così come un
tachimetro è uno strumento che misura la velocità, un accelerometro è uno strumento che
misura l’accelerazione. Potrete utilizzare la capacità di un accelerometro di sentire
l’accelerazione per fare una gran varietà di misure molto utili in progetti di elettronica e
robotica. Ecco alcuni esempi:
•
•
•
•
•
•
•
Accelerazione
Inclinazione ed angolo di inclinazione
Pendenza
Rotazione
Vibrazione
Collisione
Gravità
Gli accelerometri sono già utilizzati in moltissimi dispositivi differenti, comprese
apparecchiature elettroniche personali, e apparecchiature e macchine specializzate. Ecco
qui pochi altri esempi:
•
•
•
•
•
•
•
Robot a bilanciamento automatico
Controllori di giochi per il modo inclinato
Autopiloti di aeromodelli
Sistemi di allarme per automobile
Sistemi che fanno uso di rilevatori di urto/ airbag
Sistemi di rilevamento del moto umano
Strumenti di livellamento
Molto tempo fa, gli accelerometri erano strumenti molto grandi, poco efficienti e costosi
che non si prestavano a progetti di elettronica e robotica. Tutto questo è cambiato grazie
all’avvento della tecnologia MEMS, sistemi-microelettronici-meccanici (SMEM). La
tecnologia MEMS è responsabile di un numero sempre crescente di dispositivi in
precedenza meccanici, ora correttamente progettati all’interno di chip di silicio.
L’accelerometro con cui lavorerete in questa prova è il modulo accelerometro Memsic
2125 a due assi Parallax mostrato in Figura 3-1. Le misure di questo modulo sono
inferiori a 1/2” × 1/2” × 1/2”, e lo stesso chip dell’accelerometro è più piccolo di 1/4” × 1/4”
× 1/8”.
Figura 3-1: Modulo accelerometro e chip MX2125
Modulo Accelerometro
Chip MX2125
Le persone sentono naturalmente l’accelerazione su tre assi: avanti/indietro,
sinistra/destra e alto/basso (su/giù). Pensate esattamente all’ultima volta che stavate sul
sedile del passeggero di un’automobile su una strada collinosa e piena di curve.
L’accelerazione avanti/indietro è la sensazione di andar più forte e rallentare.
L’accelerazione sinistra/destra vi fa pendere quando si fanno le curve, e l’accelerazione
su giù è quella che avvertite andando sulle colline.
A differenza del senso che le persone hanno sui tre assi, l’accelerometro MX2125 sente
una accelerazione su due assi. L’accelerazione che sente dipende da come è posizionato.
Mantenendolo in una direzione, può sentire aventi/indietro e sinistra/destra. Se lo tenete
in modo diverso, può sentire su/giù e avanti/indietro. Due assi di accelerazione sono
sufficienti per molte delle applicazioni elencate prima. Anche se potrete sempre montare
e controllare un secondo accelerometro per catturare quel terzo asse, gli accelerometri a
tre assi sono anch’essi molto comuni.
Per un accelerometro a 3 assi, provate il nostro modulo accelerometro a tre assi
Hitachi H48C, numero di parte Parallax #28026.
L’ACCELEROMETRO MX2125 – COME LAVORA
Il progetto del MX2125 è meravigliosamente semplice. Ha una camera piena di gas con
un elemento riscaldatore al centro e quattro sensori di temperatura intorno al suo bordo.
Come l’aria calda sale e raffredda i dissipatori di calore, lo stesso vale per i gas bollenti e
freddi. Se tenete l’accelerometro fermo, tutto ciò che sente è la gravità, e inclinandolo
abbiamo un esempio di come senta l’accelerazione statica. Quando mantenete livellato un
accelerometro, la tasca di gas bollente sale nella parte centrale alta della camera
dell’accelerometro, e tutti i sensori misureranno la stessa temperatura. A seconda di come
inclinerete l’accelerometro, il gas bollente si raccoglierà più vicino ad uno o forse due dei
sensori di temperatura.
Figura 3-2: La tasca di gas riscaldato di un accelerometro
Confrontando la temperatura dei sensori, si possono rilevare sia l’accelerazione statica
(gravità e inclinazione) che l’accelerazione dinamica (come nel fare una corsa in
automobile). Se prendeste con voi l’accelerometro nella corsa in automobile, i gas
bollenti e quelli freddi si spargerebbero nella camera in modo simile a quello che accade
in un contenitore mezzo pieno di acqua, e i sensori rileverebbero questo comportamento.
Nella maggior parte dei casi, portare queste sensazioni in quelle misure è compito
semplice grazie all’elettronica interna al MX2125. Il MX2125 converte le misure di
temperature in segnali (durate di impulso) facili da misurare e decifrare per il
microcontrollore BASIC Stamp.
ATTIVITÀ #1: CONNETTERE E PROVARE AD INCLINARE IL MX2125
In questa attività, collegherete il modulo accelerometro al BASIC Stamp, eseguirete un
programma di prova, e verificherete che si può utilizzare per sentire l’inclinazione.
Parti richieste
(2) Fili di collegamento da 3 pollici
(2) Resistenze – 220 Ω
(1) Accelerometro Memsic MX2125 a due assi
Connessioni elettriche e di segnale dell’accelerometro
La Figura 3-3 mostra come collegare il modulo accelerometro all’alimentazione della
Board of Education, assieme alle connessioni con i pin I/O del BASIC Stamp che
occorre fare per eseguire il programma di prova.
√
Connettete il modulo accelerometro utilizzando la Figura 3-3 come guida.
Figura 3-3: Schema e Diagramma di cablaggio dell’accelerometro
Ascoltare i segnali dell’accelerometro con il BASIC Stamp
I due assi che il MX2125 utilizza per sentire la gravità e l’accelerazione sono etichettati
con x e y nella Figura 3-4. Vi sarà di aiuto mantenere in piano la vostra scheda sul tavolo
di fronte a voi come mostrato in figura. In questo modo, gli assi x e y puntano nelle
stesse direzioni in cui sono orientati molti diagrammi xy.
Figura 3-4: Misure di impulso sull’asse dell’accelerometro
inclinazione asse Y
Asse Y
Asse
X
Inclinazione asse X
Per la prova a temperatura ambiente, potrete ottenere una indicazione molto esatta
dell’inclinazione misurando semplicemente con il comando PULSIN le alte durate di
impulso inviate ai pin Xout e Yout del MX2125 . A seconda di quanto ampiamente e in
quale direzione inclinate la scheda BoE, le misure di tempo del PULSIN dovrebbero stare
nell’intervallo da 1875 a 3125. Quando la scheda è a livello (in piano), il comando
PULSIN dovrebbe immagazzinare valori prossimi a 2500.
√
√
Accertatevi che la vostra scheda sia posizionata in piano sul tavolo, orientata con
i suoi assi x e y come mostra la Figura 3-4.
Digitate ed eseguite il programma InclinaSemplice.bs2.
' Sensori intelligenti e loro applicazioni - InclinaSemplice.bs2
' Misura l’inclinazione a temperatura ambiente.
'{$STAMP BS2}
'{$PBASIC 2.5}
x
y
VAR
VAR
Word
Word
DEBUG CLS
DO
PULSIN 6, 1, x
PULSIN 7, 1, y
DEBUG HOME, DEC4 ? X, DEC4 ? Y
PAUSE 100
LOOP
√
Controllate per assicurarvi che il terminale di Debug riporti il fatto che le
variabili x e y memorizzano entrambe valori intorno a 2500 come mostrato in
Figura 3-5.
Figura 3-5
Uscita del
Terminale
di Debug
√
√
√
√
√
√
Afferrate il bordo della scheda dove è l’etichetta dell’asse Y e sollevatela
gradualmente verso di voi. Il valore di y dovrebbe aumentare man mano che
aumentate l’inclinazione.
Mantenete la scheda inclinata verso di voi fin quando è esattamente orientata nel
verso su/giù. Il terminale di Debug dovrebbe riportare che la variabile y
memorizza un valore prossimo a 3125.
Rimettete la scheda di nuovo in piano.
Ripetete questa prova con l’asse x. Man mano che inclinate la scheda in alto
verso di voi con la vostra mano destra, il valore x dovrebbe aumentare e
raggiungere un valore prossimo a 3125 quando la scheda è verticale. Se
inclinate la scheda verso l’alto con la vostra mano sinistra, il valore x dovrebbe
avvicinarsi a 1875.
Finalmente, mantenete la vostra scheda davanti a voi, dritta in direzione su/giù
come il volante di un’automobile.
Appena ruotate lentamente la vostra scheda, i valori x e y dovrebbero cambiare.
Questi valori saranno utilizzati in una attività successiva per determinare
l’angolo di rotazione in gradi.
Questa attività visualizzerà le misure dell’accelerometro Memsic sul LCD seriale
Parallax. Nel caso che usiate una batteria, dopo aver scritto e provato il programma
potrete scollegarvi dal vostro computer ed effettuare la messa a punto in un luogo lontano
di vostra scelta.
Connessione di entrambi i moduli al BASIC Stamp
Sia l’accelerometro Memsic che il LCD seriale possono essere ospitati
contemporaneamente sulla vostra scheda e quindi non vi occorrerà il cavo di estensione, a
meno che non scegliate di montare il LCD seriale Parallax vicino alla Board of Education
o in una scatola da progetti.
Parti richieste
(1) Accelerometro Memsic 2125
(1) LCD seriale Parallax (2×16)
(5) Fili di cablaggio
(2) Resistenze 220 Ω
Costruzione dei circuiti dell’accelerometro e del LCD
Gli schemi mostrati nella Figura 3-6 sono identici a quelli utilizzati per l’accelerometro
Memsic e il LCD seriale Parallax nelle attività precedenti.
Figura 3-6
Schemi dell’accelerometro
Memsic e del LCD
seriale Parallax
LCD Parallax
I diagrammi di cablaggio per l’accelerometro Memsic e il LCD seriale Parallax mostrati
in Figura 3-7 e Figure 3-8 sono una combinazione dei due diagrammi di cablaggio
precedenti per i singoli moduli.
√
Costruite prima il diagramma di cablaggio mostrato in Figura 3-7.
Figura 3-7
Diagramma di
cablaggio per
l’accelerometro
Memsic MX2125
√
Inserite quindi il LCD seriale Parallax come mostra la Figure 3-8.
Figure 3-8: Diagramma di cablaggio del display seriale LCD, aggiunto al MX2125
Display LCD inclinato
La modifica di tutti i programmi esempio per l’accelerometro riportati in questo capitolo
per fare in modo che visualizzino le misure sul LCD è un tipico procedimento a due stadi.
Il primo consiste nell’aggiungere la routine di Inizializzazione del LCD, e poi sostituire i
comandi DEBUG con comandi SEROUT che visualizzeranno le informazioni sul LCD.
Ricordare sempre di aggiungere questa Inizializzazione o prima della Routine principale,
o, come nei piccoli programmi, prima della prima direttiva DO. Questo eviterà che
l’inizializzazione venga ripetuta tutte le volte nel ciclo DO...LOOP assieme al resto del
programma. Assicuratevi di mantenere la routine fuori dal ciclo principale DO...LOOP
poiché essa potrebbe produrre un lampeggiamento del display.
' Inizializza LCD
PAUSE 200
SEROUT 14, 84, [22, 12]
PAUSE 5
Quindi, dovrete modificare i comandi DEBUG cambiandoli in comandi SEROUT. Eccovi il
comando DEBUG dal programma InclinaSemplicet.bs2.
Il carattere di controllo HOME dovrà essere sostituito da 128, che è il carattere di
riposizionamento a sinistra (home) del LCD. La direttiva ? visualizza il nome della
variabile, seguito da un carattere ritorno carrello (CR). Ricordate dal Capitolo 1 che CR è
l’unico carattere di controllo che rimane lo stesso tanto per il terminale di Debug che per
il LCD seriale Parallax? Per questa ragione, possiamo lasciare la direttiva ? nel comando
SEROUT anche per il LCD. Ecco un commando SEROUT che effettua la visualizzazione
equivalente nel LCD seriale Parallax.
SEROUT 14, 84, [128, DEC4 ? X, DEC4 ? Y]
Programma esempio: InclinaSempliceLcd.bs2
Questo programma è una versione modificata del InclinaSemplice.bs2 dall’attività
precedente. Invece di visualizzare le sue misure sul terminale di Debug, le visualizzerà
sul LCD seriale Parallax.
√
√
√
Connettete una batteria alla vostra scheda.
Digitate, memorizzate ed eseguite InclinaSempliceLcd.bs2.
Scollegate il cavo seriale, e portate con voi la vostra scheda in qualsiasi posto
vogliate provare le misure dell’accelerometro Memsic.
' Sensori intelligenti e loro applicazioni - InclinaSempliceLcd.bs2
' Misura l’’inclinazione a temperatura ambiente e visualizza la misura sul
' LCD seriale Parallax.
'{$STAMP BS2}
'{$PBASIC 2.5}
x
y
VAR
VAR
Word
Word
' DEBUG CLS
PAUSE 200
SEROUT 14, 84, [22, 12]
PAUSE 5
DO
PULSIN 6, 1, x
PULSIN 7, 1, y
'
SEROUT 14, 84, [128, DEC4 ? X, DEC4 ? Y]
PAUSE 100
LOOP
Il vostro turno – Personalizzazione del Display
Il ritorno carrello (CR) incorporato nell’operatore ? rende più difficile visualizzare
informazioni dopo i valori della variabile x o y. Potrete riscrivere i comandi DEBUG e
SEROUT per eseguire le stesse operazioni come nel comando:
DEBUG HOME, "x = ", DEC4 x, CR, "y = ", DEC4 y
Questo comando SEROUT visualizza la stessa informazione sul LCD seriale Parallax.
Notate che il codice di controllo 128 posiziona il cursore sulla Riga 0, al carattere 0.
Invece di un carattere di controllo CR, 148 posiziona il cursore del LCD sulla Riga 1, al
carattere 0.
SEROUT 14, 84, [128, "x = ", DEC4 x, 148, "y = ", DEC4 y]
Con questo commando SEROUT modificato, è più facile visualizzare caratteri dopo
ciascun valore. Per esempio, ecco un commando SEROUT che moltiplica ciascuna misura
per 2 e visualizza, dopo la misura, la scritta "us".
SEROUT 14, 84, [128, "x = ", DEC4 (2 * x), " us",
148, "y = ", DEC4 (2 I y), " us"]
Dove "us" non è proprio la stessa cosa di "µs" (microsecondi) poiché stiamo utilizzando
una u invece della lettera greca mu, ma la maggior parte delle persone conoscono il suo
significato. Potrete anche fabbricare un carattere personalizzato per il carattere mu.
Questo comporta il dover aggiungere un comando SEROUT all’inizio del programma che
definisca un carattere personalizzato. Poi dovrete visualizzare questo carattere
personalizzato dove è visualizzata attualmente la "u".
ATTIVITÀ #3: RIDUZIONE IN SCALA (SCALATURA) E SPOSTAMENTO
(RISPETTO ALL’ORIGINE) DEI VALORI DI INGRESSO - OFFSET)
Quando si lavora con il MX2125 e il BASIC Stamp 2, le misure di inclinazione variano
nell’intervallo tra 1875 e 3125. Questo intervallo può essere ridotto in scala e spostato
quante volte si vuole. Ad esempio, l’attività #4 scala questo intervallo ai valori da −100
a 100. L’attività #5 lo scala tra −127 e 127.
Introdurre un offset (spostamento) in un intervallo di valori è facile, e comporta
tipicamente una operazione di somma o sottrazione. La riduzione in scala può essere un
pò più complessa, specialmente con un processore come il BASIC Stamp, che effettua
tutti i suoi calcoli con matematica a numeri interi. Questa attività introduce il modo più
semplice e preciso per ridurre in scala con un programma PBASIC un gran numero di
intervalli di valori ad un intervallo più piccolo. La tecnica introdotta qui aiuta ad evitare
che si introducano di nascosto errori nelle misure del vostro sensore in ciascuno dei
successivi cicli di calcolo PBASIC, e sarà utilizzata e riutilizzata in molte delle attività di
questo manuale.
Esempio di riduzione in scala (scalatura) e spostamento di valori (offset)
In questo primo esempio, acquisiremo un valore qualsiasi tra 1875 e 3125 in ingresso, lo
scaleremo e lo sposteremo fino ad un valore corrispondente in uscita che cada
nell’intervallo tra −127 e 127. La Figura 3-9 mostra come opererà questo procedimento.
La posizione del valore nella scala di uscita dovrà essere proporzionale alla posizione del
valore nella scala di ingresso. Per esempio, se il valore di ingresso è 2500, che si trova a
metà intervallo tra 1875 e 3125, dovremo aspettarci che il valore di uscita sia 0, che è a
metà intervallo tra −127 e 127.
Figura 3-9: Esempio di scale di Ingresso e di Uscita
Scala di
ingresso
Scala
di
uscita
Per applicare la riduzione in scala e lo spostamento (offset) in PBASIC, ricordare questi
tre passi:
1) Applicare lo spostamento per allineare a zero la scala di ingresso.
2) Applicare la riduzione in scala (o scalatura).
3) Applicare ogni spostamento aggiuntivo necessario alla vostra scala di uscita.
La Figura 3-10 mostra come applicare questi tre passi con un unico commando PBASIC
che esegua sia la riduzione in scala che lo spostamento. Tenete a mente che i calcoli con
il PBASIC sono eseguiti da sinistra a destra, tranne nel caso che questo procedimento sia
scavalcato con l’uso delle parentesi. Pertanto la prima operazione che questa riduzione in
scala effettua è sottrarre 1875 dal valore di ingresso. Il nuovo intervallo è adesso da 0 a
1200 invece che da 1875 a 3215. Poi, ** 13369 riduce in scala il valore tra 0 e 254.
Dopo aver effettuato la riduzione in scala dell’intervallo, è sottratto il valore 127 dal
valore ottenuto, e ne risulta un valore tra −127 e 127.
(1875 a 3125) → (0
|
|
(0 a 1200) →
|
|
|
|
(0 a 254)
|
|
valore = valore - 1875 ** 13369
a 1200)
(0 a 254)
→ (-127 a 127)
|
- 127
Figura 3-10: Riduzione in scala della variabile valore
Scegliere l’operazione Destra ** Costante per la riduzione in scala (scalatura)
Il valore 13369 utilizzato con la ** per una constante per ridurre in scala l’intervallo (0 a
1250) a quello (0 a 254) è stato ottenuto sostituendo entro questa equazione il numero di
elementi nelle scale di ingresso e di uscita. Il numero di elementi della scala di uscita è
255, incluso lo 0, e il numero di elementi della scala di ingresso è 1251, incluso anche qui
lo 0. Usate questa equazione ogni volta che vi occorra adattare una scala più grande ad
una più piccola con l’operatore ** .


elementi scala uscita 

Cos tan teScala = Int 65536 

 elementi scala ingresso − 1 


 255 
Cos tan teScala = Int 65536 

 1251 − 1 

Cos tan teScala = Int [13.369,344 ]
Cos tan teScala = 13369
Arrotondate sempre il risultato ottenuto per la vostra CostanteScala, anche se il
risultato è già un valore intero! Altrimenti, il valore più grande nella vostra scala di
ingresso potrebbe essere un valore fuori dall’intervallo della scala di uscita.
Fissare l’Intervallo di valori di Ingresso
Il modo migliore per assicurarsi che i valori di uscita non superino l’intervallo di uscita è
accertarsi che i valori di ingresso non vadano fuori dall’intervallo di ingresso. Ad
esempio, se non volete che l’uscita di questo commando vada fuori dall’intervallo da
−127 a 127, l’approccio più conveniente è quello di accertarsi che i valori di ingresso non
vadano sotto 1875 o sopra 3125. Ecco una versione modificata di valore = valore 1875 ** 13369 - 127 che evita il problema.
valore = (valore MIN 1875 MAX 3125) - 1875 ** 13369 - 127
Prima di sottrarre 1875 dalla variabile valore, questo commando utilizza due operatori,
MIN 1875 e MAX 3125, per accertarsi che valore memorizzi un numero che cada in
questo intervallo. Se la variabile valore sta memorizzando un numero in questo
intervallo, gli operatori MIN e MAX lo lasciano da solo. Se, però, sta memorizzando
qualcosa al di sotto di 1875, MIN 1875 cambierà tale valore in 1875. Analogamente, se
sta memorizzando qualcosa al di sopra di 3125, MAX 3125 lo cambia in 3125.
Programma esempio: ProvaOffsetScala.bs2
La Figure 3-11 mostra come appare il terminale di Debug quando si prova ad eseguire il
programma esempio che segue. Quando digitate i valori di ingresso (separati da virgole)
nella finestrella di Trasmissione del Terminale di Debug, il programma visualizza nella
finestrella di Ricezione del terminale di Debug il valore equivalente scalato e spostato.
√ Digitate, memorizzate ed eseguite ProvaOffsetScala.bs2.
' Sensori intelligenti e loro applicazioni - ProvaOffsetScala.bs2
' Prova la riduzione in scala da un intervallo di ingresso da 1875 a 3125 ad
' un intervallo di uscita da -127 a + 127.
'{$STAMP BS2}
'{$PBASIC 2.5}
valore
VAR
Word
DEBUG CLS, "Digita valori (da 1875 a 3125)...", CR
DO
DEBUG ">"
DEBUGIN DEC valore
valore = (valore MIN 1875 MAX 3125) - 1875 ** 13369 - 127
DEBUG ", scalato a ", SDEC valore, CR
LOOP
Figure 3-11: Prova riduzione in scala
Finestrella
di Trasmissione
Digita valori (da 1875 a 3125)…
>1875, scalato a -127
>1876, scalato a -127
>1879, scalato a -127
>1880, scalato a -126
>1881, scalato a -126
>2496, scalato a -1
>2497, scalato a -1
>2498, scalato a 0
>2499, scalato a 0
>2500, scalato a 0
>2501, scalato a 0
>2502, scalato a 0
>2503, scalato a 1
>2504, scalato a 1
>3119, scalato a 126
>
Finestrella
di Ricezione
√
Cliccate nella Finestrella di Trasmissione del Terminale di Debug e digitate
questa sequenza, incluse le virgole: 1875, 1876, 1879, 1880, 1881, 2496, 2497,
2498, 2499, 2500, 2501, 2502, 2503, 2504, 3119, 3120, 3121, 3124, 3125.
√ Provate vari altri valori nell’intervallo da 1875 a 3125, e verificate con una
calcolatrice che la posizione del valore di uscita nell’intervallo di uscita è
proporzionale alla posizione del valore di ingresso nell’intervallo di ingresso.
Il vostro Turno - PBASIC e i Numeri Negativi
L’ultimo programma esempio esaminato utilizzava il modificatore SDEC del comando
DEBUG per visualizzare la variabile valore come un numero con segno (numero
relativo). Ricordate che in PBASIC una variabile dimensionata a “parola” può contenere
un valore senza segno nell’intervallo da 0 a 65535 oppure un valore con segno tra
−32768 e +32767. Ciò è dovuto al fatto che il PBASIC utilizza il metodo del
complemento a due per i numeri con segno. In questo metodo, tutti i numeri positivi, in
binario, iniziano con uno 0 e tutti i numeri negativi, in binario, iniziano con un 1.
Utilizzando il complemento a due, i valori tra 0 e 32767 sono rappresentati dai loro
normali equivalenti binari a 16-bit, ma quelli tra −1 e −32768 non lo sono. Invece, quei
numeri negativi sono rappresentati dagli equivalenti binari dei numeri tra 32768 e 65535.
Tabella 3-1: Complemento a due di un numero Decimale
Decimale
senza segno
1
32767
32768
65535
con segno e
Numeri Binari
Binario a 16-Bit
Bit 15
Bit 0
0000000000000001
0111111111111111
1000000000000000
1111111111111111
Decimale con
segno
1
32767
-32768
-1
Scrivi una riga di numeri, come in Figura 3-12 . Da 0 in avanti, i valori tra 0 e 32767
sono rappresentati dai loro normali equivalenti binari a 16-bit: il valore 1 è rappresentato
dal numero binario 1, e così via, fino a 32767. Ma il numero −1 è rappresentato
dall’equivalente binario di 65535, il più grande valore contenuto in una variabile di tipo
word, che è il numero binario composto da tutti 1. Andando avanti nei valori negativi, i
numeri binari che li rappresentano diventano più piccoli fino al numero −32768 che è
rappresentato dal valore binario 32768.
Figura 3-12: Riga di numeri decimali con segno rappresentati in
complemento a due
(DEC 32767)0111111111111111
|
(DEC 1)0000000000000001
|
|
|
-32768...............-1...0...1...............32767
|
|
|
1111111111111111(DEC 65535)
|
1000000000000000 (DEC 32768)
Lo schema diviene evidente quando vedete un numero decimale non segnato a confronto
con il suo valore decimale con segno e i loro equivalenti binari.
√ Provate ad eseguire NumeriConSegno.bs2 con valori differenti per x fin quando
lo schema vi diventa chiaro. Provate questi valori per x: 0, 1, 2, -1, -2.
√ Quindi provate 65535, 65534, 32767, 32768, e 32769. Vi è chiaro come lavora?
' Sensori intelligenti e loro applicazioni - NumeriConSegno.bs2
' {$STAMP BS2}
' {$PBASIC 2.5}
x VAR Word
x = 32768
'<< Inserire qui i nuovi valori di x, e rieseguire il programma
DEBUG "avete inserito il decimale: ", DEC x, CR
DEBUG "decimale con segno: ", SDEC x, CR
DEBUG "binario a 16-bit: ", BIN16 x, CR
In PBASIC, soltanto le variabili di tipo word possono ospitare numeri con segno, quindi
tutti i numeri con segno hanno 16 bit. Se guardiamo il bit più a sinistra, Bit 15, possiamo
sapere se un numero con segno è negativo o positivo. Potete utilizzare valore.BIT15
come una variabile che vi dice se valore è un numero positivo o negativo. Se
valore.BIT15 è uguale a 0, il numero è positivo. Se è uguale a 1, il numero è negativo.
Questo è un suggerimento importante, perché alcuni operatori importanti del PBASIC,
come l’operatore di divisione "/" e l’operatore modulo "//", lavorano soltanto con interi
positivi. Quando utilizzate questi operatori, è conveniente memorizzare il segno di un
numero, ed effettuare l’operazione con il suo valore assoluto, quindi riapplicare
successivamente il segno. In realtà, faremo proprio così più avanti, nel capitolo 4.
Il vostro turno – Uno sguardo più da vicino alla CostanteScala e all’operatore **
Se consideriamo intervalli di ingresso ed uscita piccoli, potremo esaminarli con una
calcolatrice, una matita e un foglio di carta. Consideriamo come nostra scala di ingresso i
valori da 0 a 10, e come nostra scala di uscita i valori da 0 a 2. Il primo passo è calcolare
quale valore dovrebbe avere la costante nell’operazione **, utilizzando l’equazione
della costante di scala.

 elementi scala uscita 

Cos tanteScala = Int 65536 

 elementi scala ingresso − 1 

Nella scala di uscita ci sono tre elementi, 0, 1, and 2. Nella scala di ingresso ci sono 11
elementi, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, e 10. Ricordando di arrotondare verso il basso
all’intero più vicino, il risultato è 19660, e questa è la costante da usare con l’operatore
**.

 3 
Cos tan teScala = Int 65536 

 11 − 1 

Cos tan teScala = Int [19.660,8
]
Cos tan teScala = 19660
Il termine valore = valore ** 19660 moltiplica la variabile valore per:
19660 ÷ 65536 ≈ 0,29999 → valore = valore × 0,29999
La Tabella 3-2 mostra alcuni esempi di calcoli del BASIC Stamp per ciascuno dei valori
nell’intervallo di ingresso per valore = valore ** 19660. Ricordate che è circa la
stessa cosa che moltiplicare valore per 0,29999 con una calcolatrice. Poiché il BASIC
Stamp è un processore a matematica intera, esso tronca ogni risultato a un valore intero,
arrotondandolo effettivamente verso il basso. Notate come i primi quattro valori di
ingresso abbiano risultato in uscita pari a zero. Quindi, quando il valore di ingresso è 4, il
risultato è 1,19996, che arrotondato diventa 1. Appena effettuate gli altri calcoli nella
tabella, noterete come la scala di uscita di 2 riceve quattro elementi di ingresso. Se il
valore -1 non era adoperato al denominatore, si sarebbe ricevuto soltanto un elemento di
ingresso.
Finite i calcoli nella Tabella 3-2 per i valori di ingresso da 5 a 10.
Tabella 3-2: Misure delle tensioni durante il ciclo di carica
√
√
√
Valore calcolato
Risultato Intero
del BASIC Stamp
x 0.2999 =
0
0
x 0.2999 =
0.2999
0
2
x 0.2999 =
0.5998
0
3
x 0.2999 =
0.8997
0
4
x 0.2999 =
1.1996
1
5
x 0.2999 =
6
x 0.2999 =
7
x 0.2999 =
8
x 0.2999 =
9
x 0.2999 =
10
x 0.2999 =
Valore
** Costante Scala
0
1
Memorizzate ProvaOffsetScala.bs2 con il nome ProvaOffsetScalaTuoTurno.bs2.
Modificate il programma in modo da poter provare la Tabella 3-2 con il BASIC
Stamp e il terminale di Debug.
Confrontate i risultati sul terminale di Debug con la vostra tabella.
ATTIVITÀ #4: RIDUZIONE IN SCALA A 1/100 G
La misura standard della gravità sulla superficie terrestre si abbrevia con il simbolo "g."
Questa attività dimostra come utilizzare le tecniche presentate nell’attività precedente per
visualizzare il numero di centesimi di un g che agisce sugli assi x e y dell’accelerometro.
Dal comando PULSIN a 1/100 g
Vogliamo modificare il programma esempio dell’Attività #1 in modo che visualizzi le
misure sugli assi x- e y- in termini di 1/100 g invece che in unità di 2 µs. E’ un altro caso
di riduzione in scala ed offset, ma questa volta, vogliamo riportare la scala di ingresso tra
1875 e 3125 alla scala di uscita tra −100 e 100 come mostrato nel la Figura 3-13.
Figura 3-13: Riduzione in scala e Offset per 1/100 g.
Scala di
ingresso
Scala
di
uscita
Il vostro turno – Sviluppo del programma
La meta, in questo caso, è utilizzare la tecnica di riduzione di scala dalla Attività #3 per
modificare il programma presente nell’Attività #1 in modo che visualizzi le misure degli
assi x e y in termini di 1/100 g. La Figura 3-14 mostra le letture approssimate che
dovreste aspettarvi dopo le vostre modifiche
Figura 3-14: Lettura campione per vari orientamenti (inizia in alto a sinistra, ruota in senso
orario)
a. x = 100 100
d. x = 0 100
√
√
√
√
√
y = 0 100
y = −100 100
b. x = 0 100
y = 10 0 100
c. x = −100 100
y = 0 100
Aprite InclinaSemplice.bs2 dalla Attività #1 e memorizzatelo come
InclinaCentiGravità.bs2
Seguite i passi per la riduzione in scala dalla Attività #3 e determinate le costanti
di scala per l’operazione **.
Aggiungete al programma le righe di codice che riducono i valori sugli assi x e y
a g/100.
Modificate la visualizzazione in modo che appaia nel Terminale di Debug.
Provatelo in accordo con la Figura 3-14 e togliete gli errori se occorre.
ATTIVITÀ #5: MISURA DELLA ROTAZIONE VERTICALE DI 360°
Il MX2125 ha una caratteristica incorporata che permette di utilizzare le misure di
inclinazione su entrambi gli assi x e y per calcolare l’angolo di rotazione
dell’accelerometro nel piano verticale, come mostra la Figura 3-15. L’inclinazione
verticale è utile in un gran numero di applicazioni, compresa la sterzata virtuale delle
ruote per i video giochi e il conteggio dei giri delle ruote di una bicicletta. Questa attività
dimostra come calcolare l’inclinazione sul piano verticale con l’operatore PBASIC ATN.
Figura 3-15
Inclinazione sul piano
verticale
Calcolo dell’arcotangente con il PBASIC
La tangente di un angolo teta (θ) in un triangolo rettangolo è il rapporto tra il lato (y) del
triangolo rettangolo opposto a teta diviso per il lato adiacente (x). Se conoscete i valori
di x e y, potete usare la tangente inversa o arcotangente per calcolare l’angolo θ. Le
notazioni più comuni per l’arcotangente sono tan−1 e arctan.
y
tan θ =
x
Figura 3-16
Tangente e Arcotangente
y
θ = tan −1  
x
La funzione arcotangente può essere utilizzata per determinare l’angolo di rotazione
dell’accelerometro tramite le sue misure x e y. Il PBASIC ha un operatore chiamato ATN
che potete usare per calcolare la tan−1(y/x). Per calcolare l’arcotangente di y/x e
memorizzarla in una variabile chiamata angolo, usate l’istruzione angolo = x ATN y.
y
θ = tan −1   → angolo = x atn y
x
La Figura 3-17 è ricavata dal file di aiuto dell’Editor BASIC Stamp, e mostra come
lavora l’operatore ATN. Entrambe le variabili x e y devono essere ridotte in scala a valori
compresi tra −127 e 127. Il risultato dell’operatore ATN è il valore dell’angolo in radianti
binarie, abbreviato in “brad”. Con brad, un cerchio è suddiviso in 256 segmenti nello
stesso modo in cui i gradi dividono il cerchio in 360 segmenti.
Figura 3-17
Cerchio Unitario in Gradi e
Radianti Binarie
Conversione da Brad a Gradi con */
Nell’attività precedente, abbiamo usato l’operatore ** per ridurre in scala valori da un
intervallo più grande ad uno più piccolo. La conversione da brad a gradi comporta
l’aumento di una scala più piccola da 0 a 255 a una scala più grande da 0 a 359. Per fare
questo lavoro esiste in PBASIC l’operatore */.
Quando utilizzate una istruzione come valore = CostanteScala */ valore, il
termine CostanteScala è il numero di 256-esimi per il quale volete moltiplicare la
variabile valore. Ad esempio, diciamo che volete moltiplicare valore per 2,5.
Moltiplicate 2,5 per 256 ed otterrete come risultato 640. Adesso, se valore ha il valore
iniziale di 10, il risultato della istruzione valore = 640 */ valore sarà 25. Se
vogliamo che valore sia uguale a 2,5 volte valore:
Cos tan teScala = 2,5 × 256 = 640
valore = 640 */valore
'moltiplicazione per 2,5
Ricorda
L’operatore ** moltiplica per un numero di 65536-esimi.
L’operatore */ moltiplica per un numero di 256-esimi.
Le regole della matematica intera per fare una scalatura da una scala all’altra sono ancora
valide, anche se stiamo convertendo da una scala più piccola ad una più grande. L’unica
cosa che cambierà è la costante di scala, che è il numeratore di 256 per */, e invece di
65536 per **.

 elementi della scala in uscita 

* / CostanteScala= Int256
 elementi della scala in ingresso−1

La scala di ingresso va da 0 a 255, ed ha 256 elementi, e quella di uscita va da 0 a 359, ed
ha 360 elementi. Il risultato dopo la sostituzione di questi valori nella equazione */
costante di scala è 361.

 360 
* / Cos tan teScala = Int 256 

 256 − 1 

* / Cos tan teScala = Int [361,412
]
* / Cos tan teScala = 361
Questo calcolo dimostra che se la variabile angolo memorizza una misura in brad, e
volete memorizzare invece una misura in gradi, usate questa istruzione:
angolo = 361 */ angolo
La maggior parte dei documenti raccomanda angolo = 360 */ angolo. Però, utilizzare
una */ costante di scala di 361 è leggermente più preciso per gli intervalli di input/output.
Provate a confrontare i risultati di questa operazione fatta con un BASIC Stamp con quelli
ottenuti con un foglio elettronico (es. EXCEL).
angologradi= (360/256) × angolobrad
Arrotondate il risultato di angologradi all’intero più vicino. Se il risultato ha una parte decimale
di 0,5 o superiore, arrotondatelo verso l’alto. Altrimenti, arrotondatelo verso il basso. Quindi
confrontatelo con le 256 possibili uscite del Terminale di Debug prima con 360 */ angolo, poi
ripetete il confronto con 361 */ angolo. E’ utile impiegare un foglio elettronico per questo
confronto. Se provate a farlo, vedrete che la velocità con cui si approssima il valore intero è
molto maggiore con 361 */ angolo.
Programma Esempio: ProvaAtn.bs2
Questo programma esempio calcola gli angoli basandosi sui valori di y ed x che digitate
nella finestra di Trasmissione del Terminale di Debug.
Inserisci y: 90
Inserisci x: 90
angolo in brad = 32
angolo in gradi = 45
Inserisci y: 0
Inserisci x: -127
angolo in brad = 128
angolo in gradi = 180
Inserisci y: -71
Figura 3-18
Tangente e Arcotangente
Per calcolare i valori x ed y da inserire nel Terminale di Debug, utilizzate queste
equazioni:
y = h sin θ
Figura 3-19
Tangente ed Arcotangente
x = h cosθ
Per esempio, diciamo che h = 127 e θ = 45°, e allora i valori di x ed y da inserire nel
terminale di Debug sono entrambi 90. Se h = 100 e θ = 315°, il valore di y da inserire nel
terminale di Debug sarà −71, e il valore di x sarà 71. Se h = 100 e θ = 180°, y sarà 0 ed
x sarà −127.
Per h = 127 e θ = 45°
Per h = 100 e θ = 315°
Per h = 127 e θ = 180°
y = 127 sin45°
y = 100 sin 315°
y = 127 sin 180°
= 89.9
= − 71
=0
≈ 90
x = 127 cos 45°
= 89.9
x = 100 cos 315°
= 71
x = 127 cos 180°
= − 127
≈ 90
√
√
√
√
√
Digitate, memorizzate ed eseguite ProvaAtn.bs2
Cliccate sulla finestrella di trasmissione del terminale di Debug. Quando vi si
chiederà il valore di x, digitate 90 e premete il tasto Invio. Quando vi si chiederà
y, digitate 90 e di nuovo il tasto Invio.
Verificate che il risultato sia 32 brad = 45°.
Ripetete per gli altri valori di x ed y appena discussi.
Usate la vostra calcolatrice per determinare i valori di x ed y che corrispondono a
vari valori di h e θ. Confrontate i risultati che avete calcolato con i risultati
riportati dal terminale di Debug.
Alcuni valori saranno inferiori a quelli che avrete previsto. Ad esempio, quando h =
100 e θ = 30°, y = 50 e x = 87. Il terminale di Debug visualizzerà 21 come valore dell’angolo
in brad, che è corretto, ma 29 come valore in gradi dell’angolo non è corretto. Dovrebbe
essere 30. Questo succede occasionalmente quando si passa in scala da un intervallo più
piccolo ad uno più grande. La misura di 21 brad corrisponde a 29° e 22 brad corrisponde a
31°.
' Sensori intelligenti e loro applicazioni - ProvaAtn.bs2
' Prova i calcoli di arcotangente del BASIC Stamp.
'{$STAMP BS2}
'{$PBASIC 2.5}
angolo
x
y
VAR
VAR
VAR
Word
Word
Word
DO
DEBUG "Inserisci y: "
DEBUGIN SDEC y
DEBUG "Inserisci x: "
DEBUGIN SDEC x
angolo = x ATN y
DEBUG "brad ", SDEC ? angolo
angolo = angolo */ 361
DEBUG "gradi ", SDEC ? angolo, CR
LOOP
Il vostro turno – Prova della conversione da Brad a Gradi
Com’è stato ricordato prima, il risultato intero ideale viene dal calcolo di angologradi =
(360/256) x angolobrad e poi dall’arrotondamento all’intero superiore se il valore a destra
della virgola è tra 5 e 9 o a quello inferiore se è tra 1 e 4. Con questo programma potrete
generare un elenco di tutte le 256 conversioni da brad a gradi.
' Sensori intelligenti e loro applicazioni - BradAGradi.bs2
' Visualizza le conversioni da brad a gradi per */ 360 e */ 361.
'{$STAMP BS2}
'{$PBASIC 2.5}
angolo
brad
VAR
VAR
DEBUG CLS, "brad
Word
Word
*/ 360
*/ 361", CR
FOR brad = 0 TO 255
DEBUG DEC3 brad
angolo = brad */ 360
DEBUG "
", DEC3 angolo
angolo = brad */ 361
DEBUG "
", DEC3 angolo, CR
NEXT
END
√
√
Digitate, memorizzate ed eseguite BradAGradi.bs2.
Usate un foglio elettronico (EXCEL) o una calcolatrice per generare un elenco
con questa formula.
angolo gradi = (360 256)× angolo brad
√
Ricordate di arrotondare per eccesso se il valore a destra della virgola è tra 5 e 9
o per difetto se è tra 1 e 4.
Confrontate i vostri risultati con quanto visualizzato dal Terminale di Debug.
Quanti risultati coincidono con la formula */ 360? Quanti invece con */ 361?
Misura dell’angolo di inclinazione sul piano verticale
L’angolo di rotazione in senso orario della vostra scheda nel piano verticale (θ) è
l’arcotangente dell’effetto della gravità sull’asse y del MX2125 (Ay) diviso per l’effetto
sul suo asse x (Ax), come mostrato nella Figura 3-20.
Figura 3-20
Rotazione verticale in
senso orario
θ = tan
−1
 AY

A
 X




Ecco alcuni esempi di ciò che l’accelerometro rileva e di come questo sia correlato
all’arcotangente del rapporto di Ay con Ax. La Figura 3-21 mostra quello che
l’accelerometro avverte (“sente”) quando l’angolo è 0°. Se θ è 0°, allora Ay sente gravità
0 (g), e Ax sente 1 g, l’arcotangente di 0/1 è 0°.
Figura 3-21: Accelerometro ruotato di 0°
0
tan −1   = 0°
 1
Quando l’accelerometro è ruotato di 30° in senso orario, come mostrato in Figura 3-22, la
componente della gravità che agisce sull’asse x dell’accelerometro è circa √3/2 g. La
componente della gravità che agisce sull’asse y è 1/2 g, e l’arcotangente di √3/2 ÷ 1/2 è
30°.
Figura 3-22: Accelerometro ruotato di 30° in senso orario


−1 
tan



1
2
3
2


 = 30°



Quando l’accelerometro è ruotato di 135° in senso orario, come mostrato in Figura 3-22,
la componente della gravità che agisce sull’asse x dell’accelerometro è Ax = -1/√2 g, e la
componente della gravità che agisce sull’asse y è 1/√2 g. L’arcotangente di 1/√2 ÷
(−1/√2) è 135°.
Figura 3-23: Accelerometro ruotato di 135° in senso orario


tan −1 



1 

2
= 135°
−1 

2
Il caso generale
L’angolo di rotazione (θ) è la funzione inversa della tangente o arcotangente della
componente della gravità che agisce sull’asse sensibile Y del Memsic 2125 (AY) divisa per
la componente della gravità che agisce sull’asse sensibile X (AX). La figura qui sotto
mostra il MX2125 inclinato ad un angolo θ, che ruota entrambi gli assi sensibili di θ.
Applicando due identità geometriche, θ è anche entro due triangoli che mostrano le
componenti della gravità agire su ciascuno degli assi sensibili dell’accelerometro (xm e ym).
La componente della gravità che agisce su xm è AX = g cosθ, e la componente che agisce su
ym è AY = g sinθ. Dopo aver applicato le identità trigonometriche mostrate a destra, ciò
dimostra che l’angolo di rotazione θ è in realtà l’arcotangente di AY/AX.
AY g sin θ
= tan θ
=
AX g cos θ
tan θ =
AY
AX
 A 
tan −1 (tan θ ) = tan − 1  Y 
 AX 
 A 
θ = tan −1  Y 
 AX 
Programma esempio: RotazioneVertRuota.bs2
Questo programma visualizza l’angolo di rotazione della vostra scheda come mostrato
nella Figura 3-20 all’inizio di questa attività, a pagina 98.
√
√
√
√
Digitate, memorizzate, ed eseguite RotazioneVertRuota.bs2.
Mantenete la scheda in verticale davanti a voi come fosse un volante di auto.
Ruotate la scheda in senso orario, e osservate come l’angolo di misura cresca.
Verificate che l’angolo di visualizzazione vari tra 0 e 359.
' Sensori intelligenti e loro applicazioni - RotazioneVertRuota.bs2
' Montare l’accelerometro come una ruota verticale e misurare
' l’angolo di rotazione.
'{$STAMP BS2}
'{$PBASIC 2.5}
angolo
x
y
VAR
VAR
VAR
Word
Word
Word
DO
PULSIN 6, 1, x
PULSIN 7, 1, y
x = (x MIN 1875 MAX 3125) - 1875 ** 13369 - 127
y = (y MIN 1875 MAX 3125) - 1875 ** 13369 - 127
angolo = x ATN y
DEBUG HOME, CLREOL, SDEC ? x,
CLREOL, SDEC ? y,
"angolo = ", CLREOL,
DEC angolo,
176
' ASCII 176 è il simbolo del grado
PAUSE 100
LOOP
Il vostro turno – Comportamento del Terminale di Debug
Il comando DEBUG qui di seguito visualizza valori con segno delle variabili x e y seguiti
dall’angolo e dal simbolo di grado (che è il codice ASCII 176). Il motivo per cui c’è
CLREOL davanti a ciascun numero è prevenire il fatto che i caratteri non scompaiano a
destra di alcune misure. Ad esempio, se una misura è −105, e la misura successiva è
076, sarà visualizzata come 0765 se l’istruzione CLREOL non cancellasse il valore
precedente prima di visualizzare il nuovo valore. Sebbene questo problema possa essere
risolto anche da CLS, lo sfarfallio del Terminale di Debug che ne risulterebbe non
sarebbe piacevole da osservare per qualsiasi durata. Il comando CLREOL cancella a destra
del cursore su una determinata riga. Mentre anch’esso causa un piccolo sfarfallamento in
ciascuno dei valori, sarete probabilmente d’accordo che è molto più facile osservarli così
piuttosto che nella versione con il CLS.
DEBUG HOME, CLREOL, SDEC ? x,
CLREOL, SDEC ? y,
"angolo = ", DEC3 angolo,
176
' ASCII 176 è il simbolo di grado
√
√
√
√
√
Memorizzate RotazioneVertRuota.bs2 come ProvaDisplayVertRuota.bs2.
Sostituite HOME con CLS nel comando DEBUG ed eseguite il programma.
Modificate di nuovo CLS riportandolo a HOME ed eseguite ancora il programma.
Avete trovato un miglioramento nella visualizzazione?
Togliete i caratteri di controllo CLREOL e notate l’effetto sul display quando
ruotate la scheda. Alla fine dei valori non negativi appariranno ulteriori cifre.
Rimettete ancora i caratteri di controllo CLREOL ed eseguite di nuovo il
programma. Queste sgradevoli ulteriori cifre che prima non sparivano ora non
dovrebbero esserci più.
Il vostro turno - Display LCD
Il comando DEBUG ha tre righe di visualizzazione, e il simbolo di grado ha bisogno di un
carattere personalizzato. Ecco un comando di inizializzazione del LCD che fa tre cose:
(1) avvia il LCD, (2) visualizza testo che non cambia, e (3) definisce il carattere
personalizzato 7 come il simbolo di grado " ° ".
PAUSE 200
SEROUT 14, 84, [22, 12]
PAUSE 5
SEROUT 14, 84, [ 130, "angolo = ", DEC angolo, 7,
150, "x=", SDEC x,
157, "y=", SDEC y ]
SEROUT 14, 84, [255,
%01000,
' Definisce il Carattere Personalizzato 7
'
*
%10100,
%01000,
%00000,
%00000,
%00000,
%00000,
%00000]
' *
*
'
*
'
'
'
'
'
Definizioni di caratteri personalizzati Ricordate, 248 definisce il Carattere Personalizzato
0. 249 definisce il Carattere Personalizzato 1. 250 definisce il Carattere Personalizzato 2, e
così via, fino a 255, che definisce il Carattere Personalizzato 7.
Il comando DEBUG, che il comando SEROUT deve sostituire, utilizza tre righe nel
terminale di Debug. Il comando SEROUT riportato qui sotto ne usa soltanto due. Per
minimizzare lo sfarfallio del display LCD, le cifre vengono cancellate soltanto prima di
visualizzare le nuove. Il SEROUT posiziona il cursore a 138 (Linea 0, carattere 10), quindi
sovrascrive la misura precedente con cinque spazi. Poi, posiziona il cursore di nuovo a
138 e visualizza la nuova misura dei gradi con DEC angolo. Finalmente, stampa il
simbolo di grado con il Carattere Personalizzato 7. Questo procedimento viene ripetuto
per le misure di x e y, ma occorrono soltanto quattro spazi tra virgolette che seguono le
posizioni del cursore 152 e 159.
' Routine di visualizzazione LCD
SEROUT 14, 84, [ 138, "
", 138, DEC angolo, 7,
152, "
", 152, SDEC x,
159, "
", 159, SDEC y ]
√
√
√
√
√
Memorizzate RotazioneVertRuota.bs2 come RotazioneVertRuotaLcd.bs2.
Inserite la routine di inizializzazione del LCD tra la dichiarazione delle variabili
e la parola chiave DO.
Sostituite il comando DEBUG nel ciclo DO...LOOP con la Routine di
visualizzazione LCD.
Cambiate PAUSE 100 in PAUSE 350.
Eseguite il programma e provate la rotazione del vostro display LCD.
Il vostro turno - Rotazione nella direzione opposta
Diagrammi che mostrino l’angolo di rotazione che aumenta quando l’oggetto ruota in
senso anti-orario, come la Figura 3-24, sono un po’ più comuni del diagramma in senso
orario che abbiamo utilizzato precedentemente.
Figura 3-24
Misura dell’angolo con rotazione in senso anti-orario
Per rovesciare l’angolo di rotazione che il programma visualizza, tutto quello che dovete
fare è usare −Ay invece di Ay. Date un’occhiata alla Figura 3-25. Se ruotate
l’accelerometro in senso antiorario, Ay è −1/2, e l’arcotangente diventa 330°. Prendendo
l’arcotangente di −Ay/Ax, il risultato è 30°.
Figura 3-25: Rovesciare la direzione di rotazione con -Ay
 − AY
tan −1 
 AX
 1 



 = tan −1  2  = 330 °




 3 
 2


−
Ay


−1
−1 
 = tan 
tan 
 Ax 


1
2
3
2



 = 30 °


Questa modifica è facile da fare nel programma.
negativo prima della y in angolo = x ATN y.
√
√
√
Inserite semplicemente un segno
Memorizzate RotazioneVertRuota.bs2 come RotazioneVertRuotaAntior.bs2
Cambiate angolo = x ATN y in angolo = x ATN −y.
Eseguite il programma e verificate che l’angolo di rotazione ora aumenta quando
ruotate la scheda in senso antiorario.
ATTIVITÀ #6: MISURA DELL’INCLINAZIONE DAL PIANO
ORIZZONTALE
Questa attività misura quanto la Board of Education sia inclinata rispetto al piano
orizzontale. La Figura 3-26 mostra la Board of Education con l’accelerometro Memsic
sulla breadboard. Gli assi dell’accelerometro che sentono l’accelerazione (xm e ym)
puntano verso l’alto e verso sinistra della Board of Education. Questa attività sviluppa un
programma che visualizza l’angolo di inclinazione per ciascun asse. Quando la scheda si
mantiene a livello, l’angolo di inclinazione è 0° per entrambi gli assi xm e ym. Se
inclinate la scheda in modo che ym punti verso l’alto, il programma riporterà un angolo di
inclinazione positivo per l’asse y. Se la inclinate in modo che ym punti verso il basso,
riporterà un angolo di inclinazione negativo. La stessa cosa si applica all’asse xm;
puntatelo verso l’alto per avere un angolo di inclinazione positivo o verso il basso per un
angolo di inclinazione negativo. Se inclinate la scheda verso uno dei suoi angoli, il
programma vi riporterà inclinazione per entrambi gli assi xm e ym.
Figura 3-26: Inclinazione degli assi della Board of Education
Seno e Coseno
La Figura 3-27 mostra la relazione tra i lati di un triangolo rettangolo e le funzioni seno e
coseno. Il seno di un angolo è il lato del triangolo (y) opposto a quell’angolo diviso per
l’ipotenusa (h). Se conoscete h ed y, e volete sapere l’angolo (θ), usate l’arcoseno (sin−1).
Il coseno di un angolo è il lato adiacente (x) diviso per h. Se volete sapere l’angolo dati x
ed h, usate l’arcocoseno (cos−1).
y
h
x
cos θ =
h
sin θ =
Figura 3-27
Seno e Coseno
Notate dalle equazioni nella Figura 3-27 che il valore x può essere al massimo uguale ad
h quando θ = 0°. Analogamente, il valore y può essere al massimo h quando θ = 90°. Per
angoli tra 0 e 90°, i rapporti x/h ed y/h sono entrambi minori di 1. Non importa quanto
sia grande il triangolo, il rapporto sarà sempre compreso tra 1 e 0.
Il cerchio unitario è un artificio comune per descrivere le funzioni seno e coseno.
L’ipotenusa diventa il raggio del cerchio. Il cerchio unitario è detto così perché la
lunghezza dell’ipotenusa è fatta uguale ad 1 (una unità). Quando l’ipotenusa è ruotata in
senso antiorario, l’angolo θ diventa più grande, o più piccolo se è ruotato in senso orario.
Il coseno è determinato disegnando una linea verticale dal punto dove l’ipotenusa
incontra in basso il cerchio (o in alto se l’ipotenusa è sotto) all’asse x. Qualunque sia il
valore di x, quel valore è il coseno. Il seno dell’angolo è determinato disegnando una
linea dalla fine del raggio orizzontalmente verso l’asse y.
Figura 3-28: Esempi di Seno e Coseno nel cerchio unitario
a.
b.
c.
L’intervallo tra 0 e 90° è il Quadrante 1 del cerchio unitario. Quando θ è nel Quadrante
1, sia il coseno che il seno dell’angolo saranno numeri positivi. Quando θ è tra 90 e 180°
(Quadrante 2), il coseno diventa negativo ma il seno è ancora positivo. Nel Quadrante 3,
sia il seno che il coseno sono negativi, e nel Quadrante 4, il seno è ancora negativo ma il
coseno è di nuovo positivo. Notate in Figura 3-28 (c) che un valore negativo di θ (tra 0 e
−90) può essere nel Quadrante 4 proprio come un valore tra 270 e 360°. Un’altra cosa da
tenere a mente qui è che il valore minimo sia per il seno che per il coseno è −1, e il valore
massimo è 1. Per esempio, quando θ = 0°, cos θ = 1, e sin θ = 0. Se θ = 90°, sin θ = 1 e
cos θ = 0. Per θ = 180°, cos θ = −1 e sin θ = 0.
La Figura 3-29 mostra la versione BASIC Stamp di un cerchio unitario per i suoi
operatori SIN e COS. Invece dei risultati che sono nell’intervallo da −1 ad 1, I risultati di
SIN e COS variano da −127 a 127. Gli angoli per gli operatori SIN e COS sono misurati in
brad. Così, invece di 45°, usate 32 brad. Invece di 90°, usate 64 brad, e così via. Per
convertire da brad a gradi con una calcolatrice, moltiplicate il numero di brad per
360/256. Per convertire da gradi a brad, usate 256/360.
Figura 3-29
Operatori Seno e
Coseno
del Cerchio unitario
nel BASIC Stamp
Programma esempio: SenoCoseno.bs2
Questo programma esempio visualizza i calcoli interi di seno e coseno nel BASIC Stamp.
Potete dividere questi valori per 127 per ottenere una approssimazione dei veri valori di
seno o coseno. BASIC Stamp converte i gradi in brad con ** 46733, che è stata ricavata
tramite la equazione CostanteScala dalla Attività #3.
√
√
Digitate, memorizzate ed eseguite SenoCoseno.bs2
Confrontate i risultati (divisi per 127) con i valori calcolati di seno e coseno.
' Sensori intelligenti e loro applicazioni - SenoCoseno.bs2
' Visualizza i valori seno e coseno del BASIC Stamp.
' {$STAMP BS2}
' {$PBASIC 2.5}
gradi
brad
seno
coseno
VAR
VAR
VAR
VAR
Word
Word
Word
Word
DEBUG "Gradi
Brad
Coseno
FOR gradi = 0 TO 359 STEP 15
brad = gradi ** 46733
seno = SIN brad
coseno = COS brad
Seno", CR
DEBUG " ",
SDEC3
SDEC3
SDEC3
SDEC3
gradi, "
brad, "
coseno, "
seno, CR
",
",
",
NEXT
END
Il vostro turno – Modifiche al programma
√
√
Provate a modificare l’argomento STEP del ciclo FOR...NEXT per ottenere diversi
valori.
Provate a modificare il programma in modo che vi chieda un valore in gradi con
il comando DEBUGIN e poi visualizzi il risultato.
Subroutine Arcoseno e Arcocoseno
Mentre il seno è il rapporto di y/h per un dato angolo, l’arcoseno (sin−1) è il suo inverso,
come è mostrato nella Figura 3-30. Dato il rapporto y/h, l’arcoseno vi fornisce l’angolo.
Analogamente, il coseno è il rapporto x/h per un dato angolo, e l’arcocoseno (cos−1) è
l’angolo corrispondente ad un dato rapporto x/h.
sin θ =
y
h
θ = sin −1
y
h
cos θ =
x
h
θ = cos −1
Figura 3-30
Seno, Arcoseno, Coseno, e
Arcocoseno
x
h
Visto che il BASIC Stamp non ha gli operatori ASIN e ACOS, Tracy Allen, autrice del
testo Stamps in Class Applied Sensors, ha pubblicato sul suo sito web
www.emesystems.com alcune subroutine molto graziose che eseguono queste funzioni.
Il programma esempio che segue utilizza versioni modificate di queste subroutine.
Ricordate che gli operatori SIN and COS restituiscono valori tra −127 e 127. Se dividete
il risultato per 127, otterrete un valore tra −1 e 1 che approssima il valore reale dei
rapporti seno (y/h) o coseno (x/h). Con le subroutine Arcoseno e Arcocoseno, potete
impostare una variabile chiamata lato ad un valore tra −127 e 127, e la subroutine
memorizzerà i risultati della misura in gradi nella variabile angolo.
Se volete che le subroutines Arcoseno e Arcocoseno restituiscano brad invece di
gradi, basta che facciate tre modifiche:
Nella subroutine Arcocoseno, commentate la riga di codice che converte da brad a gradi:
'
' Converte brad in gradi
Poi, nell’istruzione IF...THEN cambiate 180 in 128 poiché stiamo ora usando un cerchio a
256 divisioni:
IF segno = Negativo THEN angolo = 128 - angolo
Analogamente, nella subroutine Arcocoseno cambiate 90 in 64:
angolo = 64 - angolo
Programma esempio: ProvaArcoseno.bs2
Il programma che segue fa variare i valori del seno tra −127 e 127, e la sua subroutine
Arcoseno converte questi valori del seno di nuovo in angoli in gradi. Tenete a mente che
questi calcoli sono l’inverso di quelli fatti nel programma esempio precedente. Il
programma esempio precedente visualizzava valori del seno per valori dati dell’angolo.
Questo programma visualizza angoli per valori dati del seno.
√
√
Digitate, memorizzate ed eseguite ProvaArcoseno.bs2
Confrontate i risultati con i valori del seno calcolati nel programma esempio
precedente.
' -----[ Titolo ]------------------------------------------------------------' Sensori intelligenti e loro applicazioni - ProvaArcoseno.bs2
' Prova l’arcoseno per valori del seno da -127 a 127.
' {$STAMP BS2}
' {$PBASIC 2.5}
' Direttiva PBASIC
' -----[ Costanti ]----------------------------------------------------------Negativo
Positivo
CON
CON
1
0
' Segno - .bit15 delle variabili Word
' -----[ Variables ]---------------------------------------------------------seno
VAR
Word
' seno nel cerchio di raggio r = 127
lato
angolo
segno
VAR
VAR
VAR
Word
Word
Bit
' variabile della subroutine trig
' angolo risultante - gradi
' bit del segno
' -----[ Initialization ]----------------------------------------------------DEBUG CLS
seno = -128
' Cancella il Terminale di Debug
' Inizializza y a -128
' -----[ Programma principale]-----------------------------------------------DO UNTIL seno = 127
seno = seno + 1
lato = seno
DEBUG "seno = ", SDEC seno, "
GOSUB Arcoseno
DEBUG SDEC ? angolo
LOOP
END
"
'
'
'
'
'
'
'
Fa variare da y = -127 a y = 127
Incrementa di 1
Pone lato uguale a y
Visualizza il valore di seno
Calcola l’arcoseno
Visualizza l’angolo risultante
Ripete DO...LOOP
' Fine programma
' -----[ Subroutine - Arcoseno ]---------------------------------------------' Questa subroutine calcola l’arcoseno basato sulla coordinata y di un cerchio
' di raggio 127. Pone la variabile lato uguale alla vostra coordinate y prima
' di richiamare questa subroutine.
Arcoseno:
GOSUB Arcocoseno
RETURN
' Subroutine inversa del seno
' Ottiene l’inversa del coseno
' sin(angolo) = cos(90 - angolo)
' -----[ Subroutine - Arcocoseno ]-------------------------------------------' Questa subroutine calcola l’arcocoseno basato sulla coordinata x di un
' cerchio di raggio 127. Pone la variabile lato uguale alla vostra coordinate
' x prima di richiamare questa subroutine.
Arcocoseno:
segno = lato.BIT15
lato = ABS(lato)
angolo = 63 - (lato / 2)
DO
IF (COS angolo <= lato) THEN EXIT
angolo = angolo + 1
LOOP
IF segno = Negativo THEN angolo = 180 –
RETURN
'
'
'
'
'
'
'
Subroutine inversa del coseno
Memorizza il segno di lato
Calcola il positivo di lato
Approssimazione iniziale di angolo
loop di approssimazione successiva
Fine quando COS angolo <= lato
Prosegue aumentando angolo
angolo ' Corregge se segno è
' negativo.
Il vostro turno – Prova della Subroutine Arcocoseno
Ecco alcune modifiche che potete fare al programma ProvaArcoseno.bs2 per fare in
modo che provi invece la subroutine Arcocoseno.
√
√
√
√
√
Memorizzate ProvaArcoseno.bs2 col nome ProvaArcocoseno.bs2.
Aggiornate i commenti nella sezione titolo. I valori del coseno saranno spostati
nell’intervallo da 127 a −127.
Cambiate l’istruzione seno VAR Word in coseno VAR Word nella sezione
Variabili.
Cambiate seno = −128 in coseno = 128 nella sezione Inizializzazione
Modificate il Programma principale in modo che sia come la seguente
DO UNTIL coseno = -127
coseno = coseno - 1
lato = coseno
DEBUG "coseno = ", SDEC coseno, "
GOSUB Arcocoseno
DEBUG SDEC ? angolo
LOOP
"
END
√
Eseguite il programma di prova modificato. Mentre il coseno varia tra 127 e 127, l’angolo varierà tra 0 e 180°.
Visualizzazione dell’angolo di inclinazione dell’Accelerometro
La Figura 3-31 mostra la Board of Education con un accelerometro Memsic. La figura
mostra anche una vista ravvicinata del modulo accelerometro e i suoi assi sensibili xm e
ym. Questi assi sensibili rilevano le componenti dell’accelerazione terrestre dovute alla
gravità. Appena inclinate un determinato asse verso la verticale, sull’asse agirà una
componente di gravità terrestre maggiore di 1 g.
Figura 3-31: Inclinare la Board of Education, inclinare l’accelerometro Memsic
Inclinazione
Inclinazione
Inclinazione
Inclinazione
La Figura 3-32 mostra come si possa utilizzare la funzione arcoseno per determinare
l’angolo di inclinazione. Se osservate il modulo accelerometro Memsic da questo lato, la
componente della gravità che agisce sul suo asse xm è l’accelerazione sull’asse x (Ax),
che è uguale a g × sin θ. Poiché sin θ è uguale a Ax / g, θx può essere determinata
prendendo l’arcoseno di Ax / g. In termini di equazione, si ha :
A
θ X = sin −1  X
 g




Lo stesso principio si applica all’asse dell’accelerometro ym, e il risultato è il seguente:
A
θ X = sin −1  Y
 g




Figura 3-32: Determinare l’angolo di inclinazione con la funzione Arcoseno
AX = g sin θ
AX
= sin θ
g
sin θ =
AX
g
A
sin −1 (sin θ ) = sin −1  X
 g
A
θ = sin −1  X
 g








Con il MX2125, una misura di 1875 corrisponde a −1 g, e una misura di 3125 è 1 g.
Nell’Attività #3, abbiamo scalato questi valori all’intervallo da −127 a 127. Ricordate
che −127 è l’equivalente di −1 per la subroutine Arcoseno, e 127 è l’equivalente di 1.
Qualunque valore compreso tra −127 e 127 è l’equivalente di una frazione, e a provenire
dal MX2125 è, in realtà, sin θ. Quindi, una volta che la misura del MX2125 è stata
riportata in scala all’intervallo da −127 a 127, tutto ciò che dovrete fare è utilizzare la
subroutine Arcoseno per determinare l’angolo di inclinazione (il valore di θ).
Il modo più semplice di scrivere un programma di inclinazione è iniziare col precedente
programma esempio, ProvaArcoseno.bs2. Poi, incorporatevi la misura dell’accelerometro
e le istruzioni di riduzione in scala e offset da ProvaScalaOffset.bs2 e le misure con
l’accelerometro da RotazioneVertRuota.bs2. La Routine principale di questo programma
si riduce a due istruzioni per la misura sugli assi x ed y, due istruzioni per la scalatura, e
due piccole routine che chiamano la subroutine Arcoseno e visualizzano il risultato.
DO
PULSIN 6, 1, x
PULSIN 7, 1, y
x = (x MIN 1875 MAX 3125) - 1875
y = (y MIN 1875 MAX 3125) - 1875
lato = x
GOSUB Arcoseno
DEBUG HOME, "angolo inclinazione
lato = y
GOSUB Arcoseno
DEBUG "angolo di inclinazione su
PAUSE 100
** 13369 - 127
** 13369 - 127
su x = ", CLREOL, SDEC3 angolo, CR
y = ", CLREOL, SDEC3 angolo
LOOP
Programma esempio: InclinaOrizzontale.bs2
Questo programma esempio visualizza l’inclinazione della vostra scheda in gradi.
√
√
Digitate, memorizzate ed eseguite InclinaOrizzontale.bs2.
Confrontate i vari angoli di inclinazione con la visualizzazione degli assi del
Terminale di Debug.
' -----[ Titolo ]------------------------------------------------------------' Sensori intelligenti e loro applicazioni - InclinaOrizzontale.bs2
' Prova l’arcoseno per i valori del seno da -127 a 127.
' {$STAMP BS2}
' {$PBASIC 2.5}
' Direttiva PBASIC
' -----[ Costanti ]---------------------------------------------------------Negativo
Positivo
CON
CON
1
0
' Segno - .bit15 delle variabili
Word
' -----[ Variabili ]---------------------------------------------------------x
y
lato
angolo
segno
VAR
VAR
VAR
VAR
VAR
Word
Word
Word
Word
Bit
'
'
'
'
'
Misura sull’asse x di Memsic
Misura sull’asse y di Memsic
variabile della subroutine trig
angolo risultante - gradi
bit del segno
' -----[ Inizializzazione ]--------------------------------------------------DEBUG CLS
' Cancella Terminale di Debug
' -----[ Routine principale --------------------------------------------------
DO
PULSIN 6, 1, x
PULSIN 7, 1, y
' misura asse x
' misura asse y
' Scalatura e offset dei valori su asse x ed asse y da -127 a 127.
x = (x MIN 1875 MAX 3125) - 1875 ** 13369 - 127
y = (y MIN 1875 MAX 3125) - 1875 ** 13369 - 127
' Calcola e visualizza l’Arcoseno della misura sull’asse x .
lato = x
GOSUB Arcoseno
DEBUG HOME, "angolo inclinazione su x = ", CLREOL, SDEC3 angolo, CR
' Calcola e visualizza l’Arcoseno della misura sull’asse y.
lato = y
GOSUB Arcoseno
DEBUG "angolo inclinazione su y = ", CLREOL, SDEC3 angolo
PAUSE 100
' Pausa di 1/10 di secondo
LOOP
' Ripete il ciclo DO...LOOP
' -----[ Subroutine - Arcoseno ]--------------------------------------------' Questa subroutine calcola l’arcoseno basandosi sulla coordinata y in un
' cerchio di raggio 127. Ponete la variabile lato uguale alla vostra
' coordinata y prima di richiamare questa subroutine.
Arcoseno:
GOSUB Arcocoseno
RETURN
' Subroutine inversa del seno
' Chiama l’inversa del coseno
' -----[ Subroutine - Arcocoseno ]------------------------------------------' Questa subroutine calcola l’arcocoseno basandosi sulla coordinata x in un
' cerchio di raggio 127. Ponete la variabile lato uguale alla vostra
' coordinata x prima di richiamare questa subroutine..
Arcocoseno:
' Subroutine inversa del coseno
segno = lato.BIT15
' Conserva il segno di lato
lato = ABS(lato)
' Calcola il positivo di lato
' Approssimazione iniziale di angolo
DO
' Ciclo approssimazioni successive
' Fatto quando COS angolo <= lato
angolo = angolo + 1
' Aumenta angolo
LOOP
IF segno = Negativo THEN angolo = 180 – angolo
' Modifica se segno è
' negativo.
RETURN
Il vostro turno – Visualizzazione su LCD
Modificare il programma esempio per visualizzare le misure di inclinazione su LCD
seriale Parallax LCD è solo questione di aggiungere una routine di inizializzazione e
trasformare comandi DEBUG in comandi SEROUT. Come il programma dell’Attività #5,
questo programma visualizza caratteri che non cambiano nella routine di inizializzazione
per prevenire lo sfarfallio del display.
√
√
Memorizzate InclinaOrizzontale.bs2 col nome InclinaOrizzontaleLcd.bs2
Sostituite il comando DEBUG nella routine di inizializzazione con questo blocco.
PAUSE 200
SEROUT 14, 84, [22, 12]
PAUSE 5
SEROUT 14, 84, [128, "inclinazione x =",
148, "inclinazione y ="]
SEROUT 14, 84, [255,
%01000,
%10100,
%01000,
%00000,
%00000,
%00000,
%00000,
%00000]
√
Sostituite il primo comando DEBUG nel ciclo DO...LOOP del Programma principale
con il comando SEROUT qui sotto. Assicuratevi che ci siano quattro spazi tra le
virgolette. I quattro spazi servono per cancellare il massimo di quattro caratteri
che il comando potrebbe inviare al LCD: un segno negativo, due cifre, e il
Carattere personalizzato 7 simbolo del grado (°).
SEROUT 14, 84, [135, "
√
", 135, SDEC angolo, 7]
Sostituite il secondo comando DEBUG nel ciclo DO...LOOP del Programma
principale con quello che segue. Ancora, accertatevi di mettere quattro spazi tra
le virgolette per cancellare il valore precedente.
SEROUT 14, 84, [155, "
√
√
' Definisce Carattere personal. 7
'
*
' *
*
'
*
'
'
'
'
'
", 155, SDEC angolo, 7]
Cambiate PAUSE 100 in PAUSE 350.
Eseguite il programma e provate il display.
Il vostro turno – Correzioni
Se il vostro display non va completamente a 90° quando mantenete la vostra scheda
verticale con uno particolare dei suoi assi, potrete personalizzare la vostra riduzione in
scala e l’offset per fare in modo che si adatti allo scopo. Ciò comporterà la
determinazione della scala di uscita effettiva del vostro accelerometro. Se i valori reali
vanno davvero da 1865 a 3100, ripetete i passi nell’Attività #3 per fare le correzioni
della riduzione di scala e dell’offset.
SOMMARIO
Questo capitolo è focalizzato sul sentire – con l’accelerometro a due assi Memsic 2125 –
l’accelerazione dovuta alla gravità. Sentire la gravità rende possibile misurare sia
l’inclinazione che la rotazione. L’accelerometro Memsic trasmette impulsi che indicano
l’accelerazione agente sui suoi assi x ed y. A temperatura ambiente, gli impulsi variano
tra 3750 e 6250 µs, e possono essere utilizzati per misurare un intervallo tra −1 ed 1 g
con qualsiasi dei due assi sensibili dell’accelerometro. Per misurare questi impulsi è
utilizzato il comando PULSIN, e poiché questo comando misura il tempo in unità di 2 µs,
l’intervallo che i programmi debbono considerare va da 1875 a 3125.
Le misure dell’accelerometro possono essere visualizzate con il LCD seriale Parallax. Se
il programma è stato già provato con il Terminale di Debug, visualizzare le misure con il
LCD seriale è soltanto questione di aggiungere una routine di inizializzazione all’inizio
del programma, ed utilizzare comandi SEROUT al posto di comandi DEBUG. I caratteri
personalizzati sono molto comodi per visualizzare il simbolo dei gradi (°), e la lettera
Greca mu (µ).
L’accelerometro può essere utilizzato per misurare la rotazione nel piano verticale. Per
far questo, il BASIC Stamp deve calcolare l’arcotangente della misura sull’asse y
dell’accelerometro, divisa per la misura sul suo asse x. Le misure sugli assi x ed y
debbono essere ridotte in scala e spostate in offset in modo da cadere nell’intervallo tra
−127 e 127, che è quanto occorre all’operatore PBASIC ATN per restituire un angolo
misurato in radianti binarie. Mentre i gradi dividono un cerchio in 360 segmenti, i
radianti binari lo frazionano in 256 segmenti. Per convertire una data misura in radianti
binari, in gradi, si può utilizzare l’operatore PBASIC */.
L’accelerometro può essere utilizzato anche per misurare gli angoli di inclinazione.
Poiché le componenti della gravità che agiscono su ciascuno degli assi sensibili
dell’accelerometro e il seno dell’angolo di inclinazione, per determinare l’angolo di
inclinazione nella misura su un asse si possono utilizzare le funzioni inverse del seno o
dell’arcoseno. Si può utilizzare una subroutine Arcoseno per calcolare l’angolo (in gradi)
dato un valore che varia tra −127 e 127. Questo intervallo di variazione corrisponde a
valori del seno tra −1 e + 1.
Poiché sia l’operatore ATN che la subroutine Arcoseno si aspettano un valore tra −127
e 127, sono state introdotte tecniche per la riduzione in scala e l’offset delle misure dell’
accelerometro. L’intervallo di misure che il BASIC Stamp raccoglie dall’accelerometro è
compreso in una scala tra 1875 e 3125. Il modo più efficiente di scalare questi valori ad
un intervallo di −127 a 127 comporta il sottrarre 1875 per allineare l’intervallo a zero, poi
usare l’operatore ** per ridurre la scala, quindi sottrarre 127. Questa è la riga di codice
che ne risulta: valore = (valore MIN 1875 MAX 3125) - 1875 ** 13369 - 127.
Il valore 13369 è determinato dall’equazione per la costante di scala ** nell’Attività #2.
Domande
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
Quali sono le sette quantità che si possono misurare con un accelerometro?
Cosa significa la sigla MEMS?
Cosa si muove all’interno del MX2125 quando lo inclinate?
Può la gravità essere considerata una forma di accelerazione?
Cosa dovete fare ad un programma che visualizza misure nel terminale di Debug
per far sì che visualizzi invece misure in un LCD seriale?
Come potete limitare una variabile in un intervallo di valori?
Come potrete orientare la vostra scheda per applicare 1 g all’asse x
dell’accelerometro?
Come potete orientare la vostra scheda per applicare 0 g ad entrambi gli assi?
Quale è la differenza tra un radiante binario e un grado?
Quali sono gli intervalli di valori accettati dagli operatori SIN e COS? Cosa
rappresentano questi valori?
Come potete convertire i brad in gradi?
Quale intervallo di valori accetta l’operatore ATN? Cosa rappresentano questi
valori?
Come potete utilizzare ATN per calcolare l’angolo di rotazione della vostra
scheda?
Quale intervallo di valori viene accettato per progetto dalla subroutine
Arcocoseno? Cosa rappresentano questi valori?
Quale intervallo di valori viene accettato per progetto dalla subroutine
Arcoseno? Cosa rappresentano questi valori?
Perché è necessario usare la subroutine Arcoseno per determinare l’angolo di
inclinazione?
Esercizi
1. Scrivere una istruzione che riceve la misura dell’accelerazione dal pin di uscita
dell’asse y dell’accelerometro connesso a P10.
2. Scrivere una istruzione che riceve la misura dell’accelerazione dal pin di uscita
dell’asse x dell’accelerometro connesso a P9.
3. Scrivere un comando che converta la misura sull’asse x in microsecondi.
4. Scrivere un comando che converta la misura sull’asse x in millisecondi.
5. Scrivere una riga di codice in PBASIC che scali un intervallo da 0 a 100 in un
intervallo da 20 a 32.
Progetti
1. Progettare un dispositivo che conti il numero di volte che voi ruotate la vostra
scheda nel piano verticale. Supponete di iniziare con 0˚.
2. Progettate un dispositivo che visualizzi un messaggio di allarme ogni volta che
l’angolo di inclinazione sull’orizzontale superi 10˚.
Soluzioni
Q1. Accelerazione, inclinazione ed angolo di inclinazione, inclinazione assoluta,
rotazione, vibrazione, urto, gravità.
Q2. Micro-sistemi elettro-meccanici.
Q3. Una bolla di gas riscaldato.
Q4. Si, tanto statica che dinamica.
Q5. Aggiungere una routine di inizializzazione per il LCD, e convertire i comandi
DEBUG in comandi SEROUT.
Q6. Usare gli operatori MAX e MIN .
Q7. Inclinarla verso l’alto con il suo lato più lungo, con le porte servo in alto. (Come
in Figura 3-14a).
Q8. Porla di piatto su un tavolo.
Q9. I gradi dividono un cerchio in 360 unità, mentre un radiante binario divide un
cerchio in 256 unità.
Q10. Da 0 a 255. Essi rappresentano l’angolo, in brad (radianti binarie).
Q11. Gradi = brad * 360 / 256.
Q12. -127 a +127, che rappresenta lati opposti ed adiacenti di un triangolo.
Q13. Poiché l’accelerometro misurerà l’accelerazione che agisce lungo l’asse ym del
Memsic, e analogamente quella che agisce lungo il suo asse xm, per trovare
l’angolo di rotazione dal piano verticale su cui agisce g, si può usare l’ATN di
Ay/Ax.
Q14. Da -127 a 127, che rappresenta la lunghezza del lato x del triangolo.
Q15. Da -127 a 127, che rappresenta la lunghezza del lato y del triangolo.
Q16. Sappiamo dalla geometria che la componente della gravità che agisce sull’accelerometro è g sin θ, quindi per ottenere l’angolo dobbiamo prendere
l’arcoseno.
E1. y VAR Word
E2.
E3.
E4.
E5.
PULSIN 10, 1, y
x VAR Word
PULSIN 9, 1, x
x = x * 2
x = x * 2 / 1000
-OPPUREx = x /500
valore = (valore MIN 0 MAX 100) ** 8519 + 20
' Sensori intelligenti e loro applicazioni - Cap3Prog1.bs2
' Basandosi su RotazioneVertRuota.bs2, questo dispositivo conta il
' numero di volte che la scheda è stata ruotata sul piano verticale.
'{$STAMP BS2}
'{$PBASIC 2.5}
angolo
angoloVecchio
x
y
ContaVolte
VAR
VAR
VAR
VAR
VAR
Word
Word
Word
Word
Word
PAUSE 250
SEROUT 14, 84, [22, 12]
PAUSE 5
' Inizializza LCD
SEROUT 14, 84, [128, DEC5 ContaVolte]
DO
PULSIN 6, 1, x
PULSIN 7, 1, y
x = (x MIN 1875 MAX 3125) - 1875 ** 13369 - 127
y = (y MIN 1875 MAX 3125) - 1875 ** 13369 - 127
angolo = x ATN y
IF (angolo >= 90 AND angolo < 180) AND (angoloVecchio < 90 OR angoloVecchio
>= 270) THEN
ContaVolte = ContaVolte + 1
angoloVecchio = angolo
ENDIF
IF angolo >= 270 AND (angoloVecchio >= 90 AND angoloVecchio < 180) THEN
ContaVolte = ContaVolte + 1
angoloVecchio = angolo
ENDIF
SEROUT 14, 84, [128, DEC5 (ContaVolte / 2)]
LOOP
P2. Soluzione esempio: Qui sotto è una versione modificata del programma
principale preso dal programma InclinaOrizzontale.bs2
PULSIN 6, 1, x
PULSIN 7, 1, y
' misura asse x
' misura asse y
' Scalatura e offset degli assi x ed y all’intervallo da -127 a 127.
x = (x MIN 1875 MAX 3125) - 1875 ** 13369 - 127
y = (y MIN 1875 MAX 3125) - 1875 ** 13369 - 127
' Calcola e visualizza l’Arcoseno della misura sull’asse x.
lato = x
GOSUB Arcoseno
DEBUG HOME, "angolo inclinazione x = ", CLREOL, SDEC3 angolo, CR
IF ABS(angolo) > 10 THEN
DEBUG CRSRXY, 0, 2, "Attenzione! Controlla asse x!"
ELSE
DEBUG CRSRXY, 0, 2, CLREOL
ENDIF
' Calcola e visualizza l’Arcoseno della misura sull’asse y.
lato = y
GOSUB Arcoseno
DEBUG CRSRXY, 0, 1, "angolo inclinazione y = ", CLREOL, SDEC3 angolo
IF ABS(angolo) > 10 THEN
DEBUG CRSRXY, 0, 3, " Attenzione! Controlla asse y!"
ELSE
DEBUG CRSRXY, 0, 3, CLREOL
ENDIF
PAUSE 100
LOOP
' Pausa 1/10 secondo
' Ripete DO...LOOP
Capitolo 4: Modulo Bussola Hitachi HM55B · Pagina 127
Capitolo 4: Il modulo Bussola Hitachi HM55B
Il modulo bussola Hitachi HM55B misura la direzione. Potete usarlo assieme ai vostri
BASIC Stamp, Board of Education, e LCD seriale Parallax per farne una bussola digitale
che opera come mostrato in Figura 4-1. Il chip del modulo Hitachi HM55B è un modulo
utilizzato come caratteristica sempre più comune nell’elettronica delle automobili, poiché
fornisce al pilota una prua di bussola. Il modulo bussola è anche uno strumento molto
importante per i robot mobili, poiché da loro un senso direzionale che produce una grossa
differenza sia nelle squadre sportive di robot che nei labirinti.
Siete qui di fronte
Figura 4-1
Modulo bussola Hitachi sulla Board of Education dotata
di Display LCD
Questo capitolo utilizza versioni modificate dei programmi contenuti nella
documentazione di prodotto del modulo bussola Hitachi HM55B per le prove e la
taratura. Esso presenta anche il metodo della media come modo per filtrare il rumore
delle misure e illustra come modificare i programmi esempio esistenti per visualizzare
l’indicazione di bussola sul LCD seriale Parallax.
INTERPRETAZIONE DELLE MISURE DELLA BUSSOLA
La documentazione di prodotto del modulo bussola Hitachi HM55B ha programmi
esempio che usano tutti una subroutine chiamata Ottieni_assi_bussola, che
restituisce le misure x ed y dell’intensità del campo magnetico. Il valore di x è la
componente del campo magnetico terrestre che agisce lungo l’asse xm del sensore
mostrato nella Figura 4-2. Il valore di y è il negativo del campo magnetico terrestre che
agisce sull’asse ym. Se N è il valore riportato da x o y quando è allineato con il campo
magnetico terrestre, allora la misura x ad un certo angolo θ sarà N cos θ, e la misura y
sarà −N sin θ. Utilizzando questi fatti e due identità di trigonometria, segue che l’angolo
θ è l’arcotangente di −y/x. Quindi, in aggiunta alla rotazione dell’accelerometro,
l’angolo del modulo bussola dalla direzione nord è un altro dei valori che si possono
determinare tramite l’operatore PBASIC ATN.
Figura 4-2
Assi di sensibilità del
modulo bussola
tan θ =
−N sin θ − y
=
N cos θ
x
−y
tan −1 (tan θ ) = tan −1 

 x 
−y
θ = tan −1 

 x 
ATTIVITÀ #1: CONNESSIONE E PROVA DEL MODULO BUSSOLA
In questa attività, collegherete il modulo bussola al BASIC Stamp ed eseguirete un
programma di prova. Questo verificherà che le connessioni elettriche sono corrette e che
il modulo è pronto per lavorare.
Connessione del modulo bussola
Il modulo bussola Hitachi HM55B deve essere connesso a Vdd e Vss (tensione e massa)
e al BASIC Stamp con tre connessioni per linea di comunicazione.
Parti Occorrenti
(1) Modulo bussola Hitachi HM55B
(6) Cavallotti (fili di collegamento)
Non sono richiesti resistenze o condensatori esterni; sono tutti incorporati nel modulo.
Schema elettrico e diagramma di cablaggio
Il modulo HM55B può essere collegato con i suoi pin Dout e Din uniti assieme, in modo
che possano trasmettere e ricevere segnali al e dallo stesso pin I/O del BASIC Stamp. Un
altro pin I/O del BASIC Stamp è connesso al pin del temporizzatore del dispositivo
(CLK). Il BASIC Stamp invierà impulsi a questo pin in modo che il chip possa inviare il
suo stato o le misure o ricevere comandi. Il BASIC Stamp invia anche segnali a zero
(bassi) al pin Enable del modulo bussola prima che esso scambi qualsiasi dato, ed anche
per inizializzare qualsiasi misura di campo magnetico.
√
Costruite il circuito mostrato in Figura 4-3.
Figura 4-3: Schema elettrico e diagramma di cablaggio del Modulo Bussola
Prova del modulo bussola
Questo programma esempio si accerta che il modulo bussola sia connesso in modo
corretto e sia pronto a lavorare. Ci possono essere differenze significative tra il nord
magnetico riportato da una bussola meccanica e quello riportato dal modulo bussola.
Dopo aver eseguito i programmi di calibrazione nelle attività che seguono, tutti gli errori
di misura che si verificassero dovrebbero scomparire.
La Figura 4-4 mostra ciò che la bussola dovrebbe visualizzare quando rileva che è a 35°
in senso orario dalla direzione del nord. Di nuovo, in questa fase non preoccupatevi della
direzione esatta poiché il programma sta solo provando per assicurarsi che il modulo stia
funzionando. Appena potrete usarlo per avere un’idea generale di nord, sud, est ed ovest,
vorrà dire che il modulo è in condizioni di funzionamento.
Figura 4-4: Uscita del terminale di Debug con la bussola a 35° in senso orario dal Nord
asse x N(-S) = 27
asse y w(-E) = - 19
angolo = 35 gradi
Programma esempio: ProvaBussola.bs2
Scarico gratuito! Questo programma è disponibile come scarico gratuito di file .bs2 dalla
Pagina di Prodotto “Smart Sensors and Applications” al sito www.parallax.com.
√
√
√
Scaricate e decomprimete il codice sorgente selezionato dalla pagina di prodotto
“Smart Sensors and Applications”del sito www.parallax.com.
Aprite il file ProvaBussola.bs2 (TestCompass.bs2) con l’Editor BASIC Stamp ed
eseguite il programma.
Il terminale di Debug dovrebbe visualizzare le misure di bussola sugli assi x ed y
e l’angolo di cui è spostato, in senso orario, dal nord.
√
Se la vostra bussola riporta misure con errore di angolo inferiore a 40°, questo
significa che sta lavorando ed è pronta per la taratura con il programma di
calibrazione descritto nell’Attività #2.
' -----[ Titolo ]------------------------------------------------------------' Sensori intelligenti e loro applicazioni - ProvaBussola.bs2
' Prova che il modulo bussola Hitachi HM55B funzioni.
' {$STAMP BS2}
' {$PBASIC 2.5}
' -----[ Dichiarazioni I/O]--------------------------------------------------DinDout
Clk
En
PIN
PIN
PIN
2
0
1
' P2 trasmette/riceve a/da Din/Dout
' P0 invia impulsi al clock del HM55B
' P2 controlla il HM55B/EN(ABLE)
' -----[ Costanti ]----------------------------------------------------------Reset
Misura
Riporta
Pronto
MaskNeg
CON
CON
CON
CON
CON
%0000
' Reimposta i comandi per il HM55B
%1000
' Avvia il commando di misura
%1100
' Ottiene il commando stato/valore assi
%1100
' 11 -> Fatto, 00 -> nessun errore
%1111100000000000 ' Per negativo di 11-bit a 16-bit
' -----[ Variabili ]---------------------------------------------------------x
y
stato
angolo
VAR
VAR
VAR
VAR
Word
Word
Nib
Word
'
'
'
'
dato asse x
dato asse y
Flag di stato
Memorizza misura angolo
' -----[ Routine Principale ]------------------------------------------------DO
' Ciclo principale
GOSUB Ottieni_assi_bussola
' Ottiene i valori x, ed y
angolo = x ATN -y
' Converte x ed y a brad
' Converte brad a gradi
DEBUG HOME, "asse x N(-S) = ",SDEC x,
' Visualizza assi e gradi
CLREOL, CR, "asse y W(-E) = ",
SDEC y, CLREOL, CR, CR, "angolo = ",
DEC angolo, " gradi", CLREOL
PAUSE 150
LOOP
' Ritarda per i PC più lenti
' Ripete ciclo principale
' -----[ Subroutine - Ottieni_assi_bussola ]---------------------------------Ottieni_assi_bussola:
HIGH En: LOW En
SHIFTOUT DinDout,clk,MSBFIRST,[Reset\4]
' Subroutine modulo bussola
' Invia comando reset a HM55B
HIGH En: LOW En
' commando inizia misura HM55B
SHIFTOUT DinDout,clk,MSBFIRST,[Measure\4]
stato = 0
' Cancella flag stato precedente
DO
HIGH En:
SHIFTOUT
SHIFTIN
LOOP UNTIL
SHIFTIN
HIGH En
'
LOW En
'
DinDout,clk,MSBFIRST,[Riporta\4]
DinDout,clk,MSBPOST,[Stato\4]
'
stato = Pronto
' Esce
DinDout,clk,MSBPOST,[x\11,y\11]
IF (y.BIT10 = 1) THEN y = y | MaskNeg
IF (x.BIT10 = 1) THEN x = x | MaskNeg
Status flag checking loop
Measurement status command
Ottiene Stato
dal ciclo quando stato è Pronto
' Ottiene valori assi x & y
' Disabilita modulo
' Memorizza 11-bit come parola
' con segno
' Ripete per l’altro asse
RETURN
Il vostro turno – Esperimenti con il campo magnetico
Non ci sono molti luoghi dove il campo magnetico terrestre è parallelo al terreno. Il
campo o punta nel terreno, oppure esce dal terreno. L’angolo al quale il campo
magnetico della Terra punta nel terreno o esce dal terreno è detto inclinazione.
√
√
√
Mantenete orizzontale la vostra scheda, e allineate l’asse x del vostro modulo
bussola al nord magnetico. Quando l’asse x è allineato con il nord, il Terminale
di Debug dovrebbe visualizzare il valore x più grande, e l’angolo visualizzato
dovrebbe essere 0 gradi.
Mantenete la vostra bussola orientata a nord, ma provate ad inclinarla in su e giù.
Ci sono casi in cui troverete a certe inclinazioni una misura perfino più grande di
quella che ottenete mantenendo la bussola orizzontale. Ciò avviene perché il
campo magnetico o punta verso il terreno, o esce dal terreno, nel vostro locale.
Prendete nota della misura più grande sull’asse x che siete riusciti ad ottenere.
La declinazione è la misura in gradi dell’angolo tra nord magnetico e nord vero. Negli
Stati Uniti, potete trovare informazioni sulle differenze al sito http://nationalatlas.gov. Al
momento in cui scriviamo, sia un articolo con informazioni sulla inclinazione, sia la
mappa delle declinazioni è nella pagina web:
http://nationalatlas.gov/articles/geology/a_geomag.html
Una delle mappe contenute in questa pagina web mostra anche misure dell’intensità
totale del campo magnetico in nanotesla. Il tesla (T) è una unità di misura dell’intensità
del campo magnetico, e i nanotesla (nT) sono miliardesimi di tesla. Le letture che gli assi
x e y del modulo bussola restituiscono sono approssimativamente in milionesimi di tesla
(µT). Secondo quanto riportato sul foglio dati del chip del HM55B, le unità del vostro
modulo bussola potrebbero avere qualsiasi valore tra 1 e 1,6 µT.
√
Trovate una mappa dell’intensità del campo magnetico totale che mostri la
vostra situazione locale, e quindi utilizzatela per calcolare le unità di intensità del
campo magnetico lungo l’asse x per il vostro modulo bussola. Se l’intensità del
campo magnetico totale è riportata in nanotesla, allora il vostro risultato sarà in
nanotesla per l’unità lungo l’asse x. Per convertirle in microtesla, dividete per
1000 il vostro risultato.
unità sull'asse x =
intensità del campo magnetico totale
lettura lungo l'asse x
Il modulo bussola può anche rilevare campi magnetici da calamite, ma le calamite
possono anche danneggiare il sensore! STATE ATTENTI!
Non mettete calamite potenti vicino al modulo bussola!
Tenete barrette magnetiche, ferri di cavallo, ed elettromagneti ben lontani dal vostro modulo
bussola finché non avrete determinata una distanza di sicurezza utilizzando la procedura
che segue. Assicuratevi di non avvicinare mai questi dispositivi abbastanza vicino da
provocare letture sull’asse x o y superiori a ±300, poiché il modulo si potrebbe danneggiare.
√
√
Iniziate a porre la vostra scheda su un tavolo ed allineate il suo asse x con il nord
magnetico.
Tenete una calamita a barretta sopra il modulo bussola con il suo polo S che
punti a nord e il suo polo N che punti a sud come mostrato in Figura 4-5.
Iniziate con un metro sopra, ed abbassate la barretta fin quando il terminale di
Debug riporti una lettura lungo l’asse x di 120.
Figura 4-5: Campo di una barretta magnetica sopra il modulo bussola
√
Tenete la barretta magnetica orizzontale alla stessa altezza, e ruotatela in modo
che i suoi poli N ed S non siano più allineati con il nord e il sud magnetico
terrestre. Mentre la ruotate, la rotazione della barretta dovrebbe essere facilmente
evidenziata dal Terminale di Debug.
Notate come il campo magnetico che agisce sul modulo bussola sia opposto a quanto
hanno mostrato i poli della barretta magnetica. Questo fatto avviene per il modo in cui il
campo magnetico si avvolge dal polo nord al polo sud della barretta. La Figura 4-5
illustra questo fatto con le linee di campo magnetico che mostrano l’andamento del
campo intorno a una barretta magnetica.
Potete anche mantenere la barretta magnetica allo stesso livello del modulo bussola,
direttamente davanti ad esso, come mostrato in Figura 4-6a. Questa volta i poli della
barretta magnetica sono allineati con il nord e il sud invece di essere opposti.
√
√
Con la barretta magnetica orientata in Posizione 1 come mostra la Figura 4-6b e
la vostra scheda orientata verso il nord, trovate una distanza che produca una
misura lungo l’asse x di 120. Iniziate da 1 m.
Successivamente, tentate di porre la barretta magnetica nelle posizioni da 2 a 6.
Potete utilizzare il terminale di Debug per determinare dov’è la barretta
magnetica?
Figura 4-6: Trovare i limiti di distanza di sicurezza
a.
b.
Misure tra 127 e 300
Ricordate che i dati di ingresso dal comando ATN possono variare tra −127 e 127. Se
tenete la barretta magnetica abbastanza vicina al modulo bussola in modo che produca
misure sopra il valore 127, avrete bisogno di ridurre in scala le misure prima di utilizzare il
comando ATN. La procedura di riduzione in scala introdotta nel Capitolo 3, Attività #3
lavorerà bene per questo scopo.
La barretta magnetica avrà un effetto simile sopra una bussola meccanica. Non è un
magnete molto forte, quindi probabilmente non sarà un problema metterla molto vicina al
modulo bussola. Con una bussola meccanica, il suo ago magnetico si allinea
automaticamente al nord, quindi dovrete in questo caso muovere il modulo bussola
intorno alla bussola meccanica.
√
Provate, e notate quanta distorsione una bussola meccanica vicina produce sulle
misure del modulo bussola.
Avendo presente questa lezione, accertatevi di mantenere la bussola meccanica ben
distante dal modulo bussola mentre eseguite e provate le tarature delle due attività
successive.
ATTIVITÀ #2: TARATURA DEL MODULO BUSSOLA
Il processo di taratura comporta il puntare il modulo bussola per conoscere la direzione
corretta mentre è in esecuzione il programma di taratura . Il programma di taratura
registrerà i valori riportati dal modulo bussola in una porzione non utilizzata della
memoria di programma EEPROM del BASIC Stamp. Quando eseguite il programma
nell’attività successiva, esso leggerà questi valori dalla EEPROM e li userà per
determinare la lettura reale del modulo bussola. Questo procedimento è detto “taratura
con il software” poiché la procedura non effettua nessuna regolazione fisica del modulo
bussola reale.
Impostazione della taratura e procedura di taratura
L’impostazione della taratura comporta l’allineare uno stampato della bussola e il fissarlo
su una superficie piana con nastro adesivo. La procedura di taratura comporta
l’esecuzione del programma esempio di questa attività e il seguire le domande mentre
allineate la Board of Education ai vari raggi della ruota della bussola.
Impostazione della taratura
√
Stampate o fate una fotocopia della Figura 4-7. Se state lavorando su una copia
stampata del libro e non avete una fotocopiatrice a vostra disposizione, scaricate
la versione .pdf di questo testo dalla pagina di prodotto “Smart Sensors and
Applications” del sito www.parallax.com. Quindi fate una stampa della pagina
dal file .pdf.
Figura 4-7: Bussola di taratura
√
Ponete la vostra copia della Figura 4-7 su una superficie piana, livellata
(orizzontale), non metallica. Assicuratevi che sia abbastanza lontana dal vostro
monitor, tanto quanto è consentito dalla lunghezza del cavo di programmazione.
Il luogo dovrebbe anche essere quanto più lontano possibile da contenitori
metallici, lampadari, e da qualsiasi altra sorgente potenziale di interferenza da
campo magnetico. Controllate anche se il vostro tavolo ha strutture metalliche di
montaggio sottostanti.
√
√
√
√
Prima di finalizzare il vostro luogo, ponete la vostra bussola meccanica ben
lontana da qualsiasi sorgente di interferenza magnetica e notate la direzione che
indica. Quindi, ponete la bussola meccanica sulla vostra superficie di lavoro. La
direzione del nord che indica non dovrebbe cambiare. Se cambia, trovate un
luogo diverso privo di interferenze magnetiche.
Usate la bussola meccanica per allineare la linea di 0° con il nord magnetico
come mostrato dalla Figura 4-8.
Fissate lo stampato al tavolo con nastro adesivo, assicurandovi di non sciupare il
foglio mentre lo fate.
Ponete la vostra bussola meccanica ben lontana dal vostro stampato.
Figura 4-8
Allineamento al Nord Magnetico
Procedura di taratura
Quando eseguite il programma TaraBussola.bs2, questo vi chiederà di allineare la vostra
scheda a vari angoli sullo stampato della bussola, e di premere il tasto Invio dopo ciascun
allineamento. I primi due angoli (0 e 90°) sono mostrati in Figura 4-9.
Figura 4-9: Bussola a 0° e a 90°
a.
b.
Quando eseguite TaraBussloa.bs2, vi si chiederà dapprima di cliccare sulla finestrella di
Trasmissione del terminale di Debug (mostrata nella Figura 4-10), e quindi di premere
Invio. Dopo di ciò vi sarà richiesto di digitare T per tarare o R per rivedere le
impostazioni di taratura. Digitando la lettera T si avvia la procedura di taratura, durante la
quale vi sarà richiesto di orientare la bussola a 0°, e a 90° come mostrato in Figura 4-9, e
poi a: 180°, 270°, 0°, 22.5°, 45°, 67.5°, 90°, 112.5°, 135°, 157.5°, 180°, 202.5°, 225°,
247.5°, 250°, 292.5°, 315°, e finalmente, 337.5°. Dovrete premere il tasto Invio prima di
far avanzare la vostra scheda a ciascuno degli angoli.
√
√
√
Aprite ed eseguite TaraBussola.bs2.
Seguite le richieste finché arrivate al messaggio "TARATURA
COMPLETATA".
Se fate un errore, riavviate il programma ed iniziate daccapo. Il processo di
taratura prende soltanto un minuto o due, ed è giusto che abbiate le impostazioni
corrette nella memoria EEPROM del vostro BASIC Stamp 2.
Figura 4-10: Finestrella di Trasmissione
Finestrella di
Trasmissione
Clicca sulla finestrella di
trasmissione, poi premi Invio…
Digita un carattere:
T - taratura
R - rivede impostazioni taratura
>T
Punta la bussola su 0 gradi
poi premi Invio…
poi premi Invio…
poii premi Invio
Programma Esempio - TaraBussola.bs2
Scaricate gratuitamente! Questo programma è disponibile come file .bs2 scaricabile
gratuitamente dalla Pagina di Prodotto “Smart Sensors and Applications” nel sito
www.parallax.com. Se vi piace conoscere come lavora questo programma, leggetelo qui.
'
'
'
'
'
'
'
'
'
'
'
'
'
'
-----[ Titolo ]-----------------------------------------------------------Sensori intelligenti e loro applicazioni – TaraBussola.bs2
Questo programma raccoglie e memorizza le misure del
modulo bussola Hitachi HM55B nella EEPROM per l’offset degli assi
e le correzioni di interpolazione lineare che saranno eseguite
dal programma ProvaBussolaTarata.bs2.
{$STAMP BS2}
{$PBASIC 2.5}
IMPORTANTE: Segui le istruzioni fornite nel Capitolo #4, Attività #2
del testo Sensori intelligenti e loro applicazioni. È
disponibile per lo scarico da Internet alla pagina
Smart Sensors and Applications del sito www.parallax.com.
' -----[ Dati nella EEPROM ]-------------------------------------------------OffsetBussola
ValBassoBussola
TarBussola
DATA @ 0, (4)
DATA
(1)
DATA
(16)
' Memorizza gli offset degli assi x ed y
' Memorizza indice angolo più piccolo
' angoli di bussola di riferimento a 16 bit
' -----[ Definizioni dei Pin ]-----------------------------------------------DinDout
PIN
2
Clk
PIN
0
' P0 invia impulsi al Clk del HM55B
En
PIN
1
' P1 controlla l’EN(ABLE) del HM55B
' -----[ Costanti ]----------------------------------------------------------Reset
CON
%0000
' Riavvia comando per HM55B
Misura
CON
%1000
' Avvia comando misura
Riporta
CON
%1100
' Ottiene stato/valori assi
Pronto
CON
%1100
' 11 -> Fatto, 00 -> senza errori
MaskNeg
CON
%1111100000000000
' Per negativo 11-bit a 16-bits
Corrente
Precedente
CON
CON
0
1
' Indice per tabella array
' Indice per tabella array
' -----[ Variabili ]---------------------------------------------------------x
VAR
Word
' dato asse x
y
VAR
Word
' dato asse y
stato
VAR
Nib
' Flag di Stato
angolo
VAR
Word
' Misura dell’angolo
contatore
VAR
Byte
' Contatore del ciclo
indice
VAR
Nib
' Indice della EEPROM
carattere
VAR
Byte
' Memorizza un carattere per DEBUGIN
intero
VAR
Word
' Valori interi per il display
frazione
VAR
Nib
' Valori Frazionari per il display
brad
VAR
Byte
' Misura in radianti binari
tabella
VAR
Byte(2)
' Memorizza valori tabella
temp
VAR
Word(2)
' Memorizza misura lungo asse
OffsetAsse
VAR
Word
' Memorizza valore offset su asse
' -----[ Programma principale ]----------------------------------------------DEBUG "Clicca sulla finestrella di trasmissione, ", CR, ' Attesa per utente.
"poi premi Invio... ", CR, CR
DEBUGIN carattere
DO
' Ciclo principale
DEBUG "Digita un carattere: ", CR,
' Menu
"T - taratura ", CR,
"R - revisione impostazioni taratura", CR,
"> "
DEBUGIN carattere
' Ottiene scelta utente
DEBUG CR
IF carattere = "t" OR carattere = "T" THEN
' "t" -> taratura
GOSUB Taratura_Bussola
' "r" -> rivede impostazioni
ELSEIF carattere = "r" OR carattere = "R" THEN
GOSUB Rivede_Taratura
ENDIF
DEBUG CR, "Premi un tasto per",
CR, "continuare"
DEBUGIN carattere
DEBUG CR, CR
LOOP
' attende scelta utente
' -----[ Subroutine - Taratura_Bussola ]------------------------------------Taratura_Bussola:
GOSUB
GOSUB
GOSUB
DEBUG
Ottieni_E_Memor_Offset_Assi
Ottieni_E_Memor_Interpolaz
Ottieni_E_Memor_Indiriz_Val_Min
CR, "TARATURA COMPLETATA...", CR,
"Sei ora pronto ad eseguire", CR,
"ProvaBussolaTarata.bs2.", CR
RETURN
' -----[ Subroutine - Ottieni_E_Memor_Offset_Assi ]----------------------'
'
'
'
Questa subroutine chiede all’utente di puntare la bussola a nord, poi a est,
poi a sud, poi a ovest. Esegue poi la media tra valori massimo e minimo per
ciascun asse e memorizza quella media nell’area di EEPROM riservata dalla
direttiva DATA OffsetBussola.
Ottieni_E_Memor_Offset_Assi:
' Ciclo FOR...NEXT ripete per quattro misure di assi.
' Dice all’utente di puntare la bussola in una particolare direzione, poi
' aspetta il carattere INVIO.
DEBUG CR, "Punta la bussola su "
LOOKUP contatore, [ 0, 90, 180, 270 ], intero
DEBUG DEC intero
DEBUG " gradi", CR, "quindi premi Invio..."
DEBUGIN carattere
GOSUB Ottiene_Assi_Bussola
' Ottiene misure degli assi
' Calcola gli offset basandosi sui valori max e min per ciascun asse, poi
' li memorizza nella EEPROM.
SELECT contatore
CASE 0
' Nord
temp(0) = x
CASE 1
' Est
temp(1) = y
CASE 2
' Sud
x = x + temp(0)
IF x.BIT15 = 1 THEN
x = ABS(x)/2
x = -x
ELSE
x = x / 2
ENDIF
WRITE OffsetBussola, Word x
CASE 3
y = y + temp(1)
IF Y.BIT15 = 1 THEN
y = ABS(y)/2
y = - y
ELSE
y = x / 2
ENDIF
WRITE OffsetBussola + 2, Word y
ENDSELECT
NEXT
RETURN
' Ovest
' -----[ Subroutine - Ottieni_E_Memor_Interpolaz ]------------------' Questa subroutine chiede all’utente di puntare la bussola in varie direzioni
' separate da 22.5 gradi e memorizza l’’angolo per ciascuna misura nell’’area
' della EEPROM riservata dalla direttiva DATA TarBussola.
Ottieni_E_Memori_Interpolaz:
DEBUG CR, "Punta la bussola a "
LOOKUP contatore, [0,
22, 45, 67, 90, 112, 135, 157,
180, 202, 225, 247, 270, 292, 315, 337], intero
LOOKUP contatore, [ 0,
5,
0,
5,
0,
5,
0,
5,
0,
5,
0,
5,
0,
5,
0,
5 ], frazione
DEBUG DEC intero
IF frazione = 5 THEN DEBUG ".", DEC frazione
DEBUG " gradi", CR, "poi premi Invio..."
DEBUGIN carattere
' Attende per risposta utente
GOSUB Corregge_Offset_Bussola
' Corregge offset degli assi
angolo = x ATN - y
WRITE TarBussola + contatore, angolo
' Memorizza valore in brad
NEXT
RETURN
' -----[ Subroutine - Ottiene_E_Memor_Indir_Val_Min ]----------'
'
'
'
Questa subroutine trova e memorizza l’indirizzo del valore più piccolo
nell’area della EEPROM riservata dalla direttiva DATA TarBussola e lo
memorizza in un byte riservato dalla direttiva DATA ValBassoBussola.
Ciò riduce il sovraccarico di codice in ProvaBussolaTarata.bs2.
Ottiene_E_Memor_Indir_Val_Min:
indice = 8
tabella(corrente) = 0: tabella(precedente) = 0
DO
indice = indice + 1
READ TarBussola + indice, tabella(corrente)
READ TarBussola + (indice - 1 & $F), tabella(precedente)
LOOP UNTIL tabella(corrente) < tabella(precedente)
WRITE ValBassoBussola, indice
RETURN
' -----[ Subroutine - Rivede_Taratura ]-----------------------------------' Visualizza valori EEPROM.
Rivede_Taratura:
DEBUG CR, "Offset degli Assi:", CR
READ OffsetBussola, Word x
DEBUG CR, "Offset x = ", SDEC x
READ OffsetBussola + 2, Word y
DEBUG CR, "Offset y = ", SDEC y, CR
DEBUG CR, "Indice del valore basso in TarBussola:", CR
READ ValBassoBussola, indice
DEBUG CR, "Valore basso ", ? indice
DEBUG CR, "ProvaBussolaTarata.bs2", CR,
"usa questi valori per ", CR,
"correggere errori:", CR
DEBUG CR, "Angolo in Brad
CR, "Teorico Reale
CR, "------- -----
Angolo in Gradi",
Teorico Reale",
------- -----", CR
brad = contatore * 16
DEBUG CRSRX, 1, DEC3 brad
READ TarBussola + contatore, angolo
DEBUG CRSRX, 10, DEC3 angolo
LOOKUP contatore, [0,
22, 45, 67, 90, 112, 135, 157,
180, 202, 225, 247, 270, 292, 315, 337], intero
LOOKUP contatore, [ 0,
5,
0,
5,
0,
5,
0,
5,
0,
5,
0,
5,
0,
5,
0,
5 ], frazione
DEBUG CRSRX, 19, DEC3 intero, ".", DEC frazione
DEBUG CRSRX, 28, DEC3 angolo, CR
PAUSE 50
' Ritardo Debug per PC lenti
NEXT
DEBUG CR
RETURN
' -----[ Subroutine - Ottiene_Assi_Bussola ]---------------------------------Ottiene_Assi_Bussola:
HIGH En: LOW En
' Invia un comando reset al HM55B
HIGH En: LOW En
SHIFTOUT DinDout,clk,MSBFIRST,[Misura\4]
stato = 0
' comando inizia misura HM55B
DO
HIGH En:
SHIFTOUT
SHIFTIN
LOOP UNTIL
SHIFTIN
HIGH En
'
LOW En
'
'
stato = Pronto
'
'
Ciclo controllo flag stato
Comando stato misura
Ottiene stato
Esce dal ciclo appena stato è
Pronto
' Disabilita modulo
' con segno
RETURN
' -----[ Subroutine - Corregge_Offset_Bussola ]------------------------------'
'
'
'
'
'
Questa subroutine corregge l’interferenza cumulative del campo magnetico
che può derivare da sorgenti come la PCB, i cavallotti di filo, una vicina
batteria, o una vicina sorgente di corrente. Questa subroutine si basa sui
valori memorizzati nello spazio EEPROM riservato dalla direttiva DATA
OffsetBussola. Questi valori in EEPROM sono scritti da questo programma
durante la taratura.
Corregge_Offset_Bussola:
READ OffsetBussola, Word OffsetAsse
x = x - OffsetAsse
READ OffsetBussola + 2, Word OffsetAsse
y = y - OffsetAsse
RETURN
'
'
'
'
Ottiene offset asse x
Corregge asse x
Ottiene offset asse y
Corregge asse y
Il vostro turno – Rivedere le impostazioni di taratura
Nell’attività principale, avete digitato la lettera T per memorizzare i valori di taratura
nella EEPROM del BASIC Stamp. Potete anche rivedere questi valori di taratura
eseguendo il programma e digitando R invece di T. Questo vi mostrerà un confronto fra i
valori attuali contro i valori teorici delle misure di angolo in radianti binari. Gli errori
che ne sono evidenziati sono causati in parte dalla scheda di circuito stampato sulla quale
è montato il sensore. Alcuni dei materiali che compongono il circuito stampato sono
magnetici, e non sono necessariamente allineati con il campo magnetico della Terra.
Altre sorgenti di campo magnetico che possono causare errori di misura provengono da
correnti elettriche vicine, come gli elettroni che scorrono attraverso le linee Vdd e Vss
per alimentare il vostro LED spia di alimentazione.
√
√
√
√
Eseguite di nuovo TaraBussola.bs2.
Cliccate sulla finestrella di Trasmissione del terminale di Debug e premete Invio.
Digitate R per rivedere le impostazioni di taratura.
Esaminate gli errori riportati, che il programma esempio della successiva attività
utilizzerà per fare le correzioni.
ATTIVITÀ #3: PROVA DELLA TARATURA
Dopo l’attività #2, il programma di questa attività dovrà far funzionare la vostra bussola
in modo perfettamente corretto, abbastanza bene da poter riconoscere correttamente la
maggior parte delle 64 direzioni presenti in Figura 4-11. In questa attività, la Figura 4-11
sarà utilizzata per collaudare le prestazioni del modulo bussola.
Figura 4-11: Scala delle 64 Direzioni
Orientamento (rotta di bussola)
ProvaBussolaTarata.bs2 giunge in memoria e trova i valori che TaraBussola.bs2 ha
registrato nella memoria EEPROM del BASIC Stamp. Poi, esso utilizza questi valori
per correggere l’errore di scala, e raffina le misure utilizzando una tecnica detta
interpolazione lineare.
√
√
√
√
Stampate o fotocopiate la scala mostrata dalla Figura 4-11 e seguite
l’Impostazione dell’attività #2 per allineare la scala al nord e fissarla al tavolino.
Calcolate gli angoli non segnati sulla scala.
Aprite ed eseguite il programma ProvaBussolaTarata.bs2.
Allineate la vostra scheda a vari angoli, e confrontate le misure degli angoli
riportate dal modulo bussola con gli angoli effettivi.
Se in questo modo non c’è ancora abbastanza precisione per voi, la prossima attività vi
mostrerà come migliorarla anche di più.
Programma esempio: ProvaBussolaTarata.bs2
Scarico gratuito Questo programma è disponibile come file .bs2 scaricabile gratuitamente
dalla Pagina di Prodotto “Smart Sensors and Applications” al sito web www.parallax.com.
Leggete i commenti incorporate nel codice per avere la spiegazione delle sue funzioni.
'
'
'
'
'
'
'
-----[ Titolo ]------------------------------------------------------------Sensori intelligenti e loro applicazioni - ProvaBussolaTarata.bs2
Mostra la precisione del modulo bussola Hitachi HM55B dopo la taratura con
TaraBussola.bs2.
{$STAMP BS2}
{$PBASIC 2.5}
' -----[ Descrizione Programma ]---------------------------------------------'
' Questo programma visualizza la seguenti misure del Sensore Bussola Hitachi
' HM55B:
'
' - Misure di offset del campo magnetico sugli assi x ed y corrette
' - Angolo in radianti binarie in senso orario dal nord corretto con la
'
tabella di interpolazione lineare
' - Angolo in gradi in senso orario dal nord corretto con la
'
tabella di interpolazione lineare
' IMPORTANTE: Questo programma si basa sui valori EEPROM che sono stati
'
memorizzati dal TaraBussola.bs2 durante la procedura di
'
taratura.
'
Quella procedura di taratura deve essere eseguita prima di
'
eseguire questo programma di prova.
'
'
Per le istruzioni su come va eseguita la procedura di taratura,
'
consultare il Capitolo #4, Attività #2 del testo “Sensori
'
intelligenti e loro applicazioni”. E’ disponibile per lo
'
scarico dalla Pagina di prodotto “Smart Sensors and Applications”
'
al sito www.parallax.com.
' -----[ Dati nella EEPROM ]-------------------------------------------------OffsetBussola
ValBassoBussola
TarBussola
DATA @ 0, (4)
DATA
(1)
DATA
(16)
' Memorizza gli offset degli assi x ed y
' Memorizza indice angolo più piccolo
' angoli di bussola di riferimento a 16 bit
' -----[ Definizioni dei Pin ]-----------------------------------------------DinDout
PIN
6
Clk
PIN
5
En
PIN
4
' -----[ Costanti ]---------------------------------------------------------Reset
Misura
Rapporto
Pronto
MaskNeg
Corrente
Precedente
CON
CON
CON
CON
CON
CON
CON
%0000
%1000
%1100
%1100
%1111100000000000
0
1
'
'
'
'
'
'
'
Riavvia comando per HM55B
Avvia comando misura
Ottiene stato/valori assi
11 -> Fatto, 00 -> senza errori
Per negativo 11-bit a 16-bits
Indice per tabella array
Indice per tabella array
' -----[ Variabili ]--------------------------------------------------------x
VAR
Word
' dato asse x
y
VAR
Word
' dato asse y
stato
VAR
Nib
' Flag di Stato
angolo
VAR
Word
' Misura dell’angolo
OffsetAsse
VAR
Word
' offset su asse
indice
tabella
passo
OffsetAngolo
VAR
VAR
VAR
VAR
stato
Byte(2)
x
y
'
'
'
'
‘
Indice della EEPROM
Memorizza valori tabella EEPROM
Passo tra le entrate in tabella
Offset tra val. misurati e
entrate in tabella
' -----[ Inizializzazione ]--------------------------------------------------DEBUG CLS
GOSUB Corregge_Offset_Bussola
angolo = x ATN -y
SDEC y, CLREOL
GOSUB Interpola_Bussola
' Ciclo principale
'
'
'
'
Ottiene valori di x, ed y
Corregge offset degli assi
Converte x ed y in brad
Visualizza assi corretti
' Interpolazione lineare
DEBUG CR, CR, "angolo = ",
DEC angolo, " brad", CLREOL
DEBUG CR,"angolo = ",
PAUSE 150
LOOP
'
'
'
'
'
'
Visual. angolo interpolato
... in brad
Converte brad in gradi
Visual. angolo interpolato
... in gradi
Ritardo Debug per PC più lenti
' Ripeti ciclo principale
' -----[ Subroutine - Ottiene_Assi_Bussola ]---------------------------------' Questa subroutine gestisce la comunicazione BASIC Stamp - HM55B e memorizza
' le misure di intensità del campo magnetico restituite dal dispositivo nelle
' variabili asse x ed asse y.
Ottiene_Assi_Bussola:
' subroutine modulo bussola
HIGH En: LOW En
' Invia a HM55B un comando reset
HIGH En: LOW En
stato = 0
' HM55B avvia un comando misura
DO
HIGH En:
SHIFTOUT
SHIFTIN
LOOP UNTIL
SHIFTIN
HIGH En
' Ciclo controllo flag di stato
LOW En
' Comando stato misura
DinDout,clk,MSBFIRST,[Rapporto\4]
' Ottiene stato
stato = Pronto
' Fine ciclo quando stato è pronto
' Disabilita modulo
' Memorizza 11-bits come parola
‘ con segno
' Ripete per altro asse
RETURN
' -----[ Subroutine - Corregge_Offset_Bussola]------------------------------'
'
'
'
'
'
Questa subroutine corregge l’interferenza cumulativa del campo magnetico
che può provenire da sorgenti come le PCB, i cavallotti di filo, una vicina
batteria, o una vicina sorgente di corrente. Questa subroutine si basa sui
valori memorizzati nello spazio della EEPROM riservato dalla direttiva DATA
di OffsetBussola.
Questi valori di EEPROM sono stati scritti da TaraBussola.bs2.
Corregge_Offset_Bussola:
READ OffsetBussola, Word OffsetAsse
' Ottiene offset asse x
x = x - OffsetAsse
READ OffsetBussola + 2, Word OffsetAsse
y = y - OffsetAsse
' Corregge asse x
' Ottiene offset asse y
' Corregge asse y
RETURN
' -----[ Subroutine – Interpola_Bussola ]----------------------------------'
'
'
'
'
'
'
'
'
'
'
'
'
Questa subroutine applica l’interpolazione lineare alla rifinitura della
misura con la bussola. Questo secondo livello di rifinitura si può eseguire
dopo la subroutine Corregge_Offset_Bussola, e può correggere lo spostamento
degli assi e altri fattori relativi al chip HM55B.
La subroutine si basa su 16 misure reali di bussola memorizzate nelle sedici
locazioni di EEPROM riservate dalla direttiva DATA di TarBussola.
Queste misure sono state memorizzate da TaraBussola.bs2, e rappresentano
le misure effettive della bussola per 0, 22.5, 45, 90,..., 337.5
gradi. La subroutine trova le due misure della EEPROM tra le quali cade
la misura corrente dell’angolo. Quindi aggiorna la misura di angolo
basata su dove la misura di angolo cade tra i due valori noti della
tabella.
Interpola_Bussola:
' Inizia con il valore più piccolo della tabella TaraBussola.
READ ValBassoBussola, indice
' Carica i valori di tabella corrente e precedente.
READ (TarBussola + (indice - 1 & $F)), tabella(precedente)
'
'
'
'
'
'
'
Il blocco di codice IF...ELSEIF...ELSE...ENDIF trova i due valori EEPROM
della tabella TarBussola tra i quali cade l’angolo corrente e calcola
la differenza tra la misura di angolo corrente e il più basso tra i due
valori di tabella. I blocchi IF ed ELSEIF si occupano dei valori che sono
più grandi del valore Massimo o più piccoli del valore minimo di tabella.
Il blocco ELSE gestisce qualsiasi cosa tra i valori Massimo e minimo della
tabella.
IF (angolo >= tabella(precedente)) THEN
passo = (255 - tabella(precedente)) + tabella(corrente)
OffsetAngolo = angolo - tabella(precedente)
ELSEIF (angolo <= tabella(corrente)) THEN
passo = tabella(corrente) + (255 - tabella(precedente))
OffsetAngolo = angolo + (255 - tabella(precedente))
ELSE
indice = indice - 1
DO
tabella(precedente) = tabella(corrente)
indice = indice + 1
IF (angolo <= tabella(corrente)) AND (angolo > tabella(precedente)) THEN
passo = tabella(corrente) - tabella(precedente)
OffsetAngolo = angolo - tabella(precedente)
EXIT
ENDIF
LOOP
ENDIF
'
'
'
'
'
'
'
Dopo aver determinato l’offset tra la misura dell’angolo corrente e la
successive misura più piccolo di tabella, questo blocco di codice la
usa assieme al passo tra le entrate in tabella sopra e sotto la misura
di angolo per risolvere: angolo(corretto) = angolo(offset) * 16 / passo.
Questo blocco di codice inoltre arrotonda verso l’alto o verso il basso
confrontando il resto della divisione OffsetAngolo / passo col valore di
(passo / 2).
OffsetAngolo = OffsetAngolo * 16
angolo = (OffsetAngolo / passo) + ((OffsetAngolo // passo) / (passo / 2))
angolo = ((indice - 1 & $F) * 16) + angolo
angolo = angolo & $ff
RETURN
Il vostro turno – Visualizzare "Gradi" come °
La visualizzazione del simbolo ° di grado nel terminale di Debug è stata introdotta per la
prima volta nel Capitolo #3, Attività #5.
√
Modificate il programma per visualizzare i gradi con il carattere ASCII 176, cioè
il simbolo °.
ATTIVITÀ #4: MIGLIORATE LE MISURE DI BUSSOLA CON LA MEDIA
Potete aver notato che le misure x ed y nel Terminale di Debug tendevano ad alternarsi
tra due o magari tre valori diversi. Questo è il risultato di molti tipi diversi di interferenza
chiamati collettivamente rumore. Alcuni comuni responsabili di questo sono la vicinanza
di dispositivi alimentati in CA e di linee di alimentazione elettrica, l’attività digitale del
BASIC Stamp, e inoltre l’attività digitale all’interno del chip HM55B.
Un modo efficace per eliminare gli effetti dei rumori è prendere una media delle misure
di bussola lungo gli assi x ed y. In questo modo, se il rumore produce una misura un po’
più alta, la successiva un po’ più piccola e quella ulteriore quasi corretta, la media di tutte
le misure elimina i valori alto e basso e imposta definitivamente il valore corretto.
Una delle ragioni per cui le attività di taratura e prova della taratura possono non aver
ottenuto i migliori risultati è proprio il rumore. Questa attività dimostra come potete
modificare qualsiasi tra i programmi esempio in questo capitolo, inclusi il programma di
taratura e di prova della taratura, per prendere misure medie ed eliminare l’effetto del
rumore.
Incorporare la media entro i programmi di bussola
Ci sono tre punti principali per incorporare l’operazione di media nei programmi esempio
di questo capitolo. Primo, aggiungere due direttive CON alla sezione Costanti del
programma.
Negativo
Positivo
CON
CON
1
0
' Word.bit15 = 1 -> negativo
' Word.bit15 = 0 -> positivo
Quindi, aggiungere quattro variabili alla sezione Variabili del programma.
ContaMis
SommaX
SommaY
segno
VAR
VAR
VAR
VAR
Nib
Word
Word
Bit
'
'
'
'
Conteggio Misura
Accumulatore misura asse x
Accumulatore misura asse y
Bit del Segno
Infine, modificate la subroutine Ottieni_Assi_Bussola come mostrato qui sotto. Il
codice della subroutine originale Ottieni_Assi_Bussola è annidato in un ciclo
FOR...NEXT che mantiene una somma in esecuzione delle misure lungo gli assi x ed y con
le variabili SommaX e SommaY. Dal momento che la media di un gruppo di misure è la
somma delle misure divisa per il numero delle misure prese, dopo il ciclo FOR...NEXT ci
sono blocchi di codice che pongono x uguale a SommaX ÷ 10 ed y uguale a SommaY ÷
10.
Ottieni_Assi_Bussola:
' Subroutine modificata
SommaX = 0
SommaY = 0
' Accumulatori a zero
FOR ContaMis = 1 TO 10
' Prende dieci misure
' *** Qui va il codice originale della subroutine
' Ottieni_Assi_Bussola ***
SommaX = SommaX + x
' Prende somma in esecuzione di x
SommaY = SommaY + y
' Prende somma in esecuzione di y
NEXT
' Divide SommaX
segno = SommaX.BIT15
'
SommaX = ABS(SommaX)
'
x = SommaX / 10
'
IF SommaX // 10 >=5 THEN x = x + 1 '
IF segno = Negativo THEN x = - x
'
Memorizza segno di SommaX
Prende valore assoluto
x = media delle misure
Decimale > .5? Arrotonda in alto
se SommaX negativo, nega x
segno = SommaY.BIT15
'
SommaY = ABS(SommaY)
'
y = SommaY / 10
'
IF SommaY // 10 >=5 THEN y = y + 1 '
IF segno = Negativo THEN y = - y
'
Memorizza segno di SommaY
y = media delle misure
se SommaY negativo, nega y
RETURN
Divisione PBASIC con numeri negativi
Gli operatori PBASIC divisione e modulo (/ e //) si usano con i numeri positivi. Se il
numeratore potrebbe essere negativo, l’approccio migliore è quello di memorizzare il segno
del numeratore prima di prendere il suo valore assoluto (segno = numeratore.BIT15).
Quindi, effettuare l’operazione di divisione. Opzionalmente, potete anche arrotondare verso
l’alto o verso il basso a seconda del resto della divisione. Prima di farlo, controllate il segno,
e se è negativo, rendete negativo il risultato (risultato = - risultato).
numeratore
denominatore
Risultato
Segno
VAR
VAR
VAR
VAR
Word
Word
Word
Bit
Negativo
Positivo
CON 1
CON 0
' Routine Divisione con un numeratore che potrebbe essere negativo.
segno = numeratore.BIT15
numeratore = ABS(numeratore)
risultato = numeratore / denominatore
IF numeratore // denominatore >= (denominatore / 2) THEN
risultato = risultato + 1
ENDIF
IF segno = Negativo THEN risultato = - risultato
Programma Esempio: ProvaBussolaMediata.bs2
Scarica gratuitamente Questo programma è disponibile come file .bs2 scaricabile
gratuitamente dalla pagina di prodotto “Smart Sensors and Applications Product” al sito web
www.parallax.com.
La procedura per convertire un programma in modo che faccia la media delle sue misure
lungo gli assi x ed y è stata applicata a ProvaBussola.bs2, che poi è stato salvato come
ProvaBussolaMediata.bs2.
√
√
√
√
Aprite ed eseguite ProvaBussola.bs2 dall’attività #1.
Osservate le misure sugli assi x ed y corrispondenti a pochi orientamenti diversi.
Esse saranno probabilmente rumorose, lampeggianti tra due o tre valori diversi.
Aprite ed eseguite ProvaBussolaMediata.bs2.
Le misure dovrebbero essere molto più stabili. Esse dovrebbero lampeggiare
soltanto quando siete molto vicini alla transizione tra due risultati diversi.
' -----[ Titolo ]------------------------------------------------------------' Sensori intelligenti e loro applicazioni - ProvaBussolaMediata.bs2
' Prova per essere certi che il modulo bussola Hitachi HM55B stia lavorando.
' {$STAMP BS2}
' {$PBASIC 2.5}
' -----[ Definizioni I/O ]---------------------------------------------------DinDout
Clk
En
PIN
PIN
PIN
2
0
1
' -----[ Costanti ]----------------------------------------------------------Reset
Misura
Riporta
Pronto
MaskNeg
CON
CON
CON
CON
CON
%0000
%1000
%1100
%1100
Negativo
Positivo
CON
CON
1
0
' Word.bit15 = 1 -> negativo
' Word.bit15 = 0 -> positivo
' -----[ Variabili ]---------------------------------------------------------x
y
stato
angolo
VAR
VAR
VAR
VAR
Word
Word
Nib
Word
'
'
'
'
dato asse x
dato asse y
Flag di stato
ContaMis
SommaX
SommaY
segno
VAR
VAR
VAR
VAR
Nib
Word
Word
Bit
'
'
'
'
Conteggio Misura
Accumulatore misura asse x
Accumulatore misura asse y
Bit del Segno
' -----[ Routine Principale ]------------------------------------------------DO
' Ciclo principale
angolo = x ATN -y
' Visualizza assi e gradi
SDEC y, CLREOL, CR, CR, "angolo = ",
PAUSE 150
' Ritarda per i PC più lenti
LOOP
' -----[ Subroutine - Ottieni_assi_bussola]---------------------------------Ottieni_assi_bussola:
SommaX = 0
SommaY = 0
' Accumulatori a zero
FOR ContaMis = 1 TO 10
' Prende dieci misure
HIGH En: LOW En
HIGH En: LOW En
stato = 0
DO
HIGH En:
SHIFTOUT
SHIFTIN
LOOP UNTIL
SHIFTIN
HIGH En
'
LOW En
'
'
stato = Pronto
' Esce
Ottiene Stato
' Disabilita modulo
SommaX = SommaX + x
SommaY = SommaY + y
' con segno
' Prende somma in esecuzione di x
' Prende somma in esecuzione di y
NEXT
segno = SommaX.BIT15
'
SommaX = ABS(SommaX)
'
x = SommaX / 10
'
IF SommaX // 10 >=5 THEN x = x + 1 '
IF segno = Negativo THEN x = - x
'
Memorizza segno di SommaX
x = media delle misure
se SommaX negativo, nega x
segno = SommaY.BIT15
'
SommaY = ABS(SommaY)
'
y = SommaY / 10
'
IF SommaY // 10 >=5 THEN y = y + 1 '
IF segno = Negativo THEN y = - y
'
Memorizza segno di SommaY
y = media delle misure
se SommaY negativo, nega y
RETURN
Il vostro turno – Inserimento della media nei programmi di Taratura e prova
della taratura
I programmi di taratura e prova della taratura migliorano in modo significativo la
precisione della vostra bussola digitale. Se incorporate la procedura della media in
entrambi i programmi, la precisione della vostra bussola digitale sarà ulteriormente
migliorata.
√
√
√
√
Seguite i passi descritti in questa attività per incorporare la media in una copia di
TaraBussola.bs2. Invece di modificare la subroutine di programma
Ottieni_Assi_Bussola, copiate semplicemente la subroutine da questo
programma (ProvaBussolaMediata.bs2) e incollatela sopra quella della vostra
copia di TaraBussola.bs2.
Eseguite la vostra copia modificata di TaraBussola.bs2 e ripetete i passi descritti
nell’Attività #2.
Fate una copia del ProvaBussolaTarata.bs2, e modificatela perché esegua la
media.
Ripetete le prove di precisione indicate nell’Attività #3. La vostra bussola
digitale dovrebbe funzionare davvero bene, adesso.
Questa attività vi mostra come sostituire il terminale di Debug con il LCD seriale
Parallax per rendere mobile la vostra bussola digitale.
Connessione del LCD seriale Parallax con un cavo di estensione
Il LCD seriale Parallax è una sorgente definita di disturbi del campo magnetico ed
occorre che sia fatta funzionare ben lontano dal modulo bussola. Si ottiene facilmente
questo utilizzando un cavo di estensione.
Parti richieste
(1) Modulo bussola Hitachi HM55B
(1) LCD seriale Parallax (2×16)
(1) Cavo di estensione LCD da 14 pollici
Se state lavorando con una scheda HomeWork BASIC Stamp oppure con una Board of
Education Rev A or B seriale, vi occorrerà anche:
(1) capocorda a 3-pin
(3) cavalotti di filo aggiuntivi
Connessioni del cavo LCD
Gli schemi mostrato in Figura 4-12 sono identici a quelli utilizzati per il modulo bussola
e per il LCD seriale Parallax fino a questo punto. L’unica cosa che sarà cambiata è il
modo in cui il LCD è collegato alla vostra scheda, tramite un cavo di estensione. Nessun
cambiamento dovrà essere fatto al cablaggio del modulo bussola.
LCD Parallax
Figura 4-12
Schemi del LCD seriale
Parallax e del modulo
bussola
Connessione via cavo a Board of Education Rev C e a Board of Education USB
Queste istruzioni sono per le schede che hanno porte servo con un cavallotto Vdd/Vss
posto tra le porte, come la Board of Education Rev C e la Board of Education USB. Per
tutte le altre schede, saltare a Per tutte le altre schede didattiche BASIC Stamp a
pagina 161.
√
√
Togliete l’alimentazione alla vostra scheda.
Posizionate il cavallotto tra i servo X4 ed X5 su Vdd (+5 V) come mostrato nella
Figura 4-13. Il cavallotto deve coprire i due pin più vicini alla Vdd, ed il terzo
pin vicino alla Vin deve restare visibile.
Figura 4-13
Impostazione del cavallotto tra
le porte Servo a Vdd
L’impostazione del cavallotto a Vdd oppure a Vin determina quale alimentazione
elettrica è connessa alle porte X4 ed X5. Quando il cavallotto è posto su Vdd, queste porte
ricevono tensione regolata a 5 V dal regolatore di tensione della scheda Board of Education.
Se il cavallotto è posto su to Vin, le porte ricevono alimentazione direttamente dalla batteria
o da un alimentatore. ATTENZIONE!! ACCERTATEVI CHE IL VOSTRO CAVALLOTTO
SIA IMPOSTATO CORRETTAMENTE SU Vdd, ALTRIMENTI DANNEGGERETE
PERMANENTEMENTE IL VOSTRO LCD!!
√
√
√
√
Inserite una delle estremità del cavo di estensione nella Porta 14 del capocorda
X4, assicurandovi che i contrassegni "Rosso" e "Nero" lungo il lato destro della
porta X5 siano allineati con i fili rosso e nero del cavo.
Verificate che il vostro cavo sia inserito in modo corretto controllandolo per
accertarvi che il filo bianco è più vicino all’etichetta 14 e il filo nero è più vicino
all’etichetta X4.
GND del LCD seriale Parallax, il filo rosso sia connesso al pin 5 V, e il filo
bianco sia connesso al pin RX.
Controllate i vostri collegamenti due volte e assicuratevi che siano corretti.
ATTENZIONE!
Non ricollegate l’alimentazione alla vostra scheda fin quando non siate positivamente
sicuri che le connessioni siano corrette. Se fate un errore con le connessioni del
LCD, il LCD seriale the Parallax sarà danneggiato in modo permanente.
Figura 4-14: Connessioni del LCD seriale Parallax alla porta Servo
√
√
√
Inserite di nuovo l’alimentazione sulla Board of Education.
Impostate l’interruttore a 3 posizioni della Board of Education sulla posizione 2.
Saltate al paragrafo Staffe opzionali di montaggio del LCD a pagina 163.
Per tutte le altre schede didattiche BASIC Stamp
Questo capitolo riguarda la connessione del Modulo bussola e del LCD seriale Parallax
ad una delle schede didattiche BASIC Stamp seguenti:
•
Scheda BASIC Stamp HomeWork
Scheda Board of Education Rev A (versione seriale)
Scheda Board of Education Rev B (versione seriale)
√
√
Scollegate l’alimentazione della vostra scheda.
Costruite la porta del cavo di estensione mostrata nella Figura 4-15.
•
•
Figura 4-15
Cablaggio Bread-board per la connessione
del cavo per il LCD seriale Parallax ed il
modulo bussola
√
√
Inserite una estremità del cavo di estensione nel capocorda a tre pin sulla scheda
come mostrato in Figura 4-16. Accertatevi che i fili bianco, rosso, e nero siano
orientati come mostrato. Il filo nero dovrebbe essere connesso a Vss, il filo rosso
a Vdd, e il filo bianco a P14.
GND del LCD seriale Parallax, il filo rosso sia connesso al pin 5 V, e il filo
bianco sia connesso al pin RX.
Figura 4-16: Modulo bussola e LCD seriale Parallax connessi con cavo di estensione
√
Controllate due volte tutte le vostre connessioni e accertatevi che siano corrette.
ATTENZIONE!
Non ricollegate l’alimentazione alla vostra scheda fin quando non siate positivamente
certi che le connessioni siano corrette. Se fate un errore con le connessioni del LCD,
il LCD seriale Parallax sarà danneggiato permanentemente.
√
Ricollegate l’alimentazione alla vostra scheda.
Staffe opzionali di montaggio del LCD
Se lo desiderate, potete montare il vostro LCD sulla vostra scheda Board of Education o
HomeWork con le staffe e gli accessori forniti con il vostro kit. L’elenco delle parti e le
istruzioni sono riportati alla pagina successiva con la Figura 4-17.
Figura 4-17: Montaggio delle staffe
opzionali del LCD
Parti richieste
(4) staffe di montaggio a 90 gradi
(2) #4 distanziali rotondi di nylon da ¼
di pollice
(2) viti a testa tonda da ½ pollice 4-40
(4) viti a testa tonda da ¼ pollice 4-40
(6) dadi zincati 4-40
√
√
√
√
Avvitate una vite da ¼" nel
foro esterno di una staffa e il
foro in alto a sinistra della
vostra scheda, e assicuratela
con un dado. Ripetete al foro
inferiore sinistro della vostra
scheda (figura in alto).
Avvitate una vite da ½"
attraverso il foro in basso a
sinistra della scheda del LCD,
un inserto di nylon, il foro
interno di una staffa, e
fissatela con un dado (2a
figura, a sinistra).
Avvitate una vite da ½"
attraverso il foro in basso a
destra nella scheda del LCD,
un inserto in nylon, il foro
esterno deella staffa, e fissatela
con un dado (2a figura, a
destra).
Utilizzando le viti rimaste da
¼" e i loro dadi, attaccate le
mensole del LCD alle staffe
sulla vostra scheda, usando
due viti e dadi da ¼" (3a
figura).
Programmazione del Display LCD
Questa routine di inizializzazione del LCD si preoccupa dell’inizializzazione base del
LCD, definisce il carattere personalizzato 7 come simbolo °, e poi visualizza testo statico
(testo che non cambia durante l’esecuzione del programma).
' routine di inizializzazione del LCD
PAUSE 200
' Aggira l’alimentazione
SEROUT 14, 84, [22, 12]
' Accende & cancella LCD
PAUSE 5
' ritardo di 5 ms per cancellare
' il comando
SEROUT 14, 84, [255,
' Definisce il carattere
' personalizzato 7
%01000,
'
*
%10100,
' *
*
%01000,
'
*
%00000,
'
%00000,
'
%00000,
'
%00000,
'
%00000]
'
SEROUT 14, 84, [129, "Orient. ...",
149, "x=",
158, "y="]
' Caratteri statici
Il commando SEROUT qui sotto posiziona il cursore del LCD, quindi visualizza degli
spazi per sovrascrivere il valore precedente. Poi posiziona il cursore nella stessa
posizione di partenza e visualizza il nuovo valore. Ciò evita l’apparizione di caratteri
fantasma quando il numero di cifre del valore cambia, ma senza i noiosi effetti laterali del
lampeggiamento dello schermo che otterreste cancellando il display tra ciascuna delle
misure.
' Intestazione del Display LCD in gradi sulla riga superiore e misure
' x ed y sulla riga inferiore.
SEROUT 14, 84, [139, "
151, "
", 151, SDEC X,
160, "
", 160, SDEC y]
Programma esempio: ProvaBussolaLcd.bs2
Scarico gratuito! Questo programma è disponibile come file scaricabile gratuitamente dalla
Questo programma esempio è una versione modificata del ProvaBussola.bs2, la quale
utilizza i comendi del display LCD invece dei comandi al terminale di Debug.
√
Aprite il ProvaBussolaLcd.bs2 e provate ad eseguirlo con il cavo seriale/USB
scollegato.
' -----[ Titolo ]------------------------------------------------------------' Sensori intelligenti e loro applicazioni - ProvaBussolaLcd.bs2
' Prova per assicurarsi che il modulo bussola Hitachi HM55B stia lavorando.
' {$STAMP BS2}
' {$PBASIC 2.5}
' -----[ Definizioni I/O]---------------------------------------------------DinDout
Clk
En
PIN
PIN
PIN
2
0
1
' -----[ Constants ]---------------------------------------------------------Reset
Misura
Riporta
Pronto
MaskNeg
CON
CON
CON
CON
CON
%0000
%1000
%1100
%1100
' -----[ Variabili ]---------------------------------------------------------x
y
stato
angolo
VAR
VAR
VAR
VAR
Word
Word
Nib
Word
'
'
'
'
dato asse x
dato asse y
Flag di stato
' -----[ Inizializzazione ]--------------------------------------------------' Inizializzazione LCD
PAUSE 200
SEROUT 14, 84, [22, 12]
PAUSE 5
SEROUT 14, 84, [255,
%01000,
%10100,
%01000,
' Aggira l’alimentazione
' Accende & cancella LCD
' ritardo di 5 ms per cancellare
' il comando
' Definisce il carattere
' personalizzato 7
'
*
' *
*
'
*
%00000,
%00000,
%00000,
%00000,
%00000]
'
'
'
'
'
SEROUT 14, 84, [129, "Orientaz. ...", ' Caratteri statici
149, "x=",
158, "y="]
' -----[ Routine principale ]------------------------------------------------DO
' Ciclo principale
angolo = x ATN -y
' Orientazione del Display LCD in gradi sulla riga superiore e
' misure x ed y sulla riga inferiore.
SEROUT 14, 84, [139, "
151, "
", 151, SDEC X,
160, "
", 160, SDEC y]
PAUSE 150
' Ritardo del Debug per i PC più lenti
LOOP
' -----[ Subroutine - Ottieni_assi_bussola]---------------------------------Ottieni_assi_bussola:
HIGH En: LOW En
HIGH En: LOW En
stato = 0
DO
HIGH En:
SHIFTOUT
SHIFTIN
LOOP UNTIL
SHIFTIN
HIGH En
'
LOW En
'
'
stato = Pronto
' Esce
Ottiene Stato
' Disabilita modulo
' con segno
RETURN
Il vostro turno
Provate ad estendere “Il vostro turno” dalla Attività #4 al caso con il LCD seriale
Parallax. Non preoccupatevi di aggiungere la funzionalità LCD al programma di taratura,
proprio al programma di prova taratura modificato dalla Attività #3. Potrà servirvi di
tarare ancora una volta per eliminare l’interferenza magnetica causata dalla eccessiva
vicinanza del LCD. Aggiungete un commando alla Routine Principale del programma
TaraBussola.bs2 che invia alcuni caratteri al LCD ogni volta che il ciclo esegue i
comandi prima di eseguirlo. Per liberare un po’ di spazio nel codice, provate a rimuovere
alcuni caratteri da uno dei comandi DEBUG nella subroutine Rivedi_Taratura.
SOMMARIO
Il modulo bussola Hitachi HM55B è un sensore di campo magnetico a due assi capace di
rilevare variazioni di microtesla (milionesimi di tesla) nelle componenti del campo
magnetico terrestre che agiscono sui suoi assi x ed y. L’angolo del modulo dal nord può
essere determinato dividendo la misura sull’asse x per la misura sull’asse −y, e poi
prendendo l’arcotangente del risultato. Il modulo bussola può essere usato anche per
rilevare campi magnetici prodotti da magneti a barra, e pure l’inclinazione del campo
magnetico terrestre nel locale dove siete.
Il BASIC Stamp può memorizzare le direzioni misurate nella porzione non utilizzata di
memoria programmi della EEPROM con un programma di taratura. Poi, un programma
di prova può accedere a questi valori memorizzati, ed utilizzarli per eseguire correzioni di
scala e interpolazone lineare delle misure. Queste tecniche di correzione possono
migliorare significativamente la misura della direzione. Facendo la media delle misure
lungo gli assi, la misura di direzione può essere rifinita ulteriormente. La direzione può
essere visualizzata in formato testo sul LCD seriale Parallax aggiungendo una piccola
routine di inizializzazione alla sezione Inizializzazione del programma e un comando
SEROUT al cilco principale DO...LOOP del programma.
Domande
1. Qual è la relazione tra la misura sull’asse x del modulo bussola ad un dato
angolo e la misura quando l’asse x è allineato con il nord magnetico?
2. Quali sono i nomi di ciascuno dei pin del modulo bussola che devono essere
collegati ai pin I/O del BASIC Stamp?
3. In quale modo aumenta l’angolo dal nord nelle bussole convenzionali?
4. Che cosa è la declinazione?
5. Se state misurando un campo magnetico vicino ad una barra magnetica, come si
può mettere in relazione la direzione del campo magnetico con le sue indicazioni
N e S?
6. Perché una bussola meccanica vicina può portare errori nelle misure del modulo
bussola?
7. Come fareste la media di venti misure?
8. Quali variabili dovete impostare a zero prima di effettuare la media degli assi x
ed y? Perché vanno impostate a zero?
9. Qual’è il commando SEROUT che definisce il simbolo di grado? Quanti byte
invia?
10. Se il numero delle cifre in una misura visualizzata potrebbe cambiare, come
evitereste che a destra caratteri fantasma appaiano?
Esercizi
1.
2.
3.
4.
5.
Calcolare l’angolo dal nord se la lettura sull’asse x è 34 e quella sull’asse y è 0.
Calcolare l’angolo dal nord se la lettura sull’asse x è 16 e quella sull’asse y è 31.
Calcolare il numero di nanotesla (tesla x 10-9) presenti in 1,6 microtesla.
Scrivere una routine che converta da microtesla a nanotesla.
Scrivere una routine che esamini una variabili e visualizzi se è o non è negativa.
Progetti
1. Visualizzate l’orientazione corrente sul LCD seriale. Premete e rilasciate un
pulsante per ricordare quella orientazione. Se l’orientazione è fuori di più di 5°,
Inviate un segnale di avvetimento con un piezo-altoparlante.
2. Progettate un prototipo che possa dire quando la vostra Bussola Digitale Hitachi
HM55B è mantenuta a livello orizzontale con l’aiuto dell’Accelerometro
Memsic 2125.
Soluzioni
Q1. Se N è il valore riportato da x quando è allineato con il nord magnetico, allora
per un dato angolo theta, x = Ncosθ.
Q2. Din, Dout, /Enable, e CLK.
Q3. In senso orario dal nord.
Q4. La Declinazione è la differenza, in gradi, tra il nord magnetico e il nord vero.
Q5. La direzione del campo magnetico sembrerà essere opposta ai segni di N e S, a
causa del modo in cui il campo magnetico si avvolge su se stesso.
Q6. La bussola meccanica contiene un piccolo magnete che può influenzare il
modulo bussola.
Q7. Prendete una soma in esecuzione delle venti misure, poi dividete la somma totale
per 20.
Q8. La soma in esecuzione di entrambi gli assi x ed y deve iniziare a zero. Una volta
fatto il calcolo, la soma conterrà un numero grande. Per fare un secondo calcolo,
dovrete ripristinare la soma a zero.
Q9. Il commando è 255, seguito da 8 byte di caratteri dato.
SEROUT Numeropin, tassobaud, [255, byte0…byte7]
Q10. Prima stampate degli spazi per sovrascrivere (riempire con spazi) il valore
precedente, poi posizionare il cursore indietro al punto di inizio e stampate il
nuovo valore.
E1. θ = 0° gradi dal Nord, o Nord dovuto.
E2. θ = 297.3° dal Nord.
E3. 1,6 microtesla = 1,6 x 10-6 T = 1600 x 10-9 T = 1600 nanotesla
E4. Routine esempio:
Converte:
nanoT = 1000 * microT
RETURN
E5. Routine esempio:
valore
VAR
Word
IF (valore.BIT15 = 1) THEN
DEBUG "Negativo", CR
ELSE
DEBUG "Positivo", CR
ENDIF
Assumendo che un pulsante attivo-basso sia connesso a P10 e che un piezoaltoparlante sia connesso a P11 (Si veda “What’s a Microcontroller?”, Capitoli 3
ed 8), il programma ProvaBussolaLcd.bs2 può essere modificato come segue:
Aggiungere alla sezione definizioni I/O queste direttive di pin:
pulsante
altoparlante
PIN
PIN
10
11
Aggiungere alla sezione Variabili queste variabili:
MemAngolo
differenza
AllarmeArm
VAR
VAR
VAR
Word
Word
Bit
Modificare l’ultimo comando SEROUT nella routine di inizializzazione:
SEROUT 14, 84, [128, "All. Ang. posto a ",
148, "OFF
"]
' Caratteri statici
Modificare la routine principale come mostrato qui di seguito:
GOSUB Ottieni_Assi_Bussola
angolo = x ATN -y
' ciclo principale
' Ottiene i valori di x ed y
' Converte x ed y in brad
' Il display LCD mostra prua in gradi su riga sup. e le misure di
' x ed y sulla riga inferiore.
SEROUT 14, 84, [154, "
", 154, DEC angolo, 7]
IF pulsante = 1 THEN
MemAngolo = angolo
ArmAllarme = 1
FREQOUT altoparlante, 20, 3000
SEROUT 14, 84, [148,"ON " ]
ENDIF
differenza = ABS(angolo - MemAngolo)
IF ArmAllarme = 1 THEN
SEROUT 14, 84, [160, "
", 160, DEC MemAngolo, 7]
IF differenza > 5 AND differenza < 355 THEN
FREQOUT altoparlante, 10, 4000
ENDIF
ENDIF
PAUSE 150
' Ritardo di Debug per PC più lenti
LOOP
P2. Soluzione esempio: Cap4_Progetto2.bs2
Questo programma è una combinaztione
ProvaBussola.bs2.
di
InclinOrizzontale.bs2
e
' -----[ Titolo ]------------------------------------------------------------' Sensori intelligenti e loro applicazioni - Cap4Progetto2.bs2
' Visualizza misure bussola digitale e inclinazione in un solo programma.
' {$STAMP BS2}
' {$PBASIC 2.5}
' Direttiva PBASIC
' -----[ Costanti ]----------------------------------------------------------Negativo
Positivo
CON
CON
1
0
' Segno - .bit15 di variabili Word
' -----[ Definizioni I/O ]-------------------------------------------------DinDout
Clk
En
PIN
PIN
PIN
6
5
4
Reset
Misura
Rapporto
Pronto
MaskNeg
CON
CON
CON
CON
CON
%0000
%1000
%1100
%1100
%1111100000000000
'
'
'
'
'
Riavvia comando per HM55B
Avvia comando misura
Ottiene stato/valori assi
11 -> Fatto, 00 -> senza errori
Per negativo 11-bit a 16-bits
' -----[ Variabili ]---------------------------------------------------------Inclx
Incly
lato
angoloIncl
segno
VAR
VAR
VAR
VAR
VAR
xBussola
yBussola
stato
angoloBussola
VAR
VAR
VAR
VAR
Word
Word
Word
Word
Bit
Word
Word
Nib
Word
'
'
'
'
'
misura di Memsic su asse x
misura di Memsic su asse y
angolo risultante – gradi
bit del segno
'
'
'
'
dato asse x
dato asse y
Flag di stato
' -----[ Inizializzazione ]---------------------------------------------------
DEBUG CLS
' Cancella Terminale Debug
PULSIN 6, 1, Inclx
' misura asse x
PULSIN 7, 1, Incly
' misura asse y
' Riduce in scala e offset dei valori su assi x ed y tra -127 e 127.
Inclx = (Inclx MIN 1875 MAX 3125) - 1875 ** 13369 - 127
Incly = (Incly MIN 1875 MAX 3125) - 1875 ** 13369 - 127
' Calcola e visualizza l’Arcoseno della misura su asse x.
lato = Inclx
GOSUB Arcoseno
DEBUG HOME, "angolo incl. x = ", CLREOL, SDEC3 InclAngolo, CR
' Calcola e visualizza l’Arcoseno della misura su asse y.
lato = Incly
GOSUB Arcoseno
DEBUG "angolo Incl. y = ", CLREOL, SDEC3 InclAngolo
GOSUB Ottieni_Assi_Bussola
' Ottiene valori di x ed y
angoloBussola = xBussola ATN -yBussola
angoloBussola = angoloBussola */ 361
' Converte x ed y in brad
DEBUG CR, "angolo Bussola = ",
DEC angoloBussola, " gradi", CLREOL
PAUSE 150
LOOP
' Ritardo Debug per PC più lenti
' Ripete DO...LOOP
' -----[ Subroutine - Arcoseno ]---------------------------------------------' Questa subroutine calcola l’arcoseno basato sulla coordinata y in un cerchio
' di raggio 127. Impostare la variabile lato uguale alla vostra coordinata y
' prima di richiamare questa subroutine.
Arcoseno:
' subroutine Inversa di seno
GOSUB Arccosine
' Ottiene inversa di coseno
angoloIncl = 90 - angoloIncl
' sin(angle) = cos(90 - angle)
RETURN
' -----[ Subroutine - Arcocoseno ]-------------------------------------------' Questa subroutine calcola l’arcocoseno basato sulla coordinata x in un
' cerchio di raggio 127. Impostare la variabile lato uguale alla vostra
' coordinata y prima di richiamare questa subroutine.
Arcocoseno:
segno = lato.BIT15
lato = ABS(lato)
angoloIncl = 63 - (lato / 2)
DO
IF (COS angoloIncl <= lato) THEN EXIT
angoloIncl = angoloIncl + 1
LOOP
angoloIncl = angoloIncl */ 361
IF segno = Negativo THEN
angoloIncl = 180 - angoloIncl
ENDIF
RETURN
'
'
'
'
'
'
'
subroutine Inversa di coseno
Memorizza segno del lato
Calcola positivo di lato
approssimazione Iniziale angolo
loop approssimazioni successive
Fatto quando COS angolo <= lato
Incrementa angolo
' Corregge se segno è negativo.
' -----[ Subroutine - Ottieni_Assi_Bussola ]-------------------------------Ottieni_Assi_Bussola:
HIGH En: LOW En
HIGH En: LOW En
stato = 0
' commando avvia misura su HM55B
DO
HIGH En:
SHIFTOUT
SHIFTIN
LOOP UNTIL
' Loop controllo flag stato
LOW En
' Camando stato misura
DinDout,clk,MSBPOST,[stato\4]
' Ottiene stato
stato = Pronto
' Esce dal loop quando stato è pronto
' Ottiene valori su assi x & y
SHIFTIN DinDout,clk,MSBPOST,[xBussola\11,yBussola\11]
HIGH En
' Disabilita modulo
' Memorizza 11-bits come parole con segno per entrambi gli assi
IF (yBussola.BIT10 = 1) THEN yBussola = yBussola | MaskNeg
IF (xBussola.BIT10 = 1) THEN xBussola = xBussola | MaskNeg
RETURN
Capitolo 5: Fondamenti Base di Gioco con l’Accelerometro · Pagina 179
Capitolo 5: Fondamenti Base di Gioco con
l’Accelerometro
Il Capitolo 3 vi ha presentato l’accelerometro a due assi Memsic. Apparecchiature simili
si possono trovare in molti HID (Human Interface Devices, Dispositivi a interfaccia
umana), una categoria che comprende mouse per computer, tastiere e, più in generale,
qualsiasi cosa che renda possibile ad un essere umano interagire con microprocessori.
Con lo spazio limitato che si ha nei PDA (Personal Digital Assistants, comunemente detti
Palmari) come quello della Figura 5-1, il controllo dell’inclinazione elimina il bisogno di
pulsanti extra. In questo esempio, inclinare consente all’utente di muoversi attorno ad
una mappa senza premere alcun pulsante. Il controllo dell’inclinazione è anche una
caratteristica molto popolare in alcuni controllori di giochi.
Figura 5-1: PDA (Palmare) ad inclinazione controllata
Foto dell’interfaccia del PDA RotoView® a inclinazione controlata in azione per concessione di
Innoventions®, www.innoventions.com
Questo capitolo ha quattro attività che mostrano le varie sfaccettature di utilizzo
dell’inclinazione per controllare un display. Ecco i sommari di ciascuna attività:
•
•
Attività #1: Display di caratteri grafici PBASIC – introduce alcuni controlli
del cursore nel terminale di Debug e le basi per il disegno di coordinate.
Attività #2: Memorizzazione e rinfresco di una EEPROM – Ogni volta che il
carattere del vostro gioco si muove, qualsiasi cosa stia coprendo sullo schermo
andrà riscritta. Questa attività mostra come possiate muovere il vostro carattere e
rinfrescare il fondo con l’aiuto della EEPROM del BASIC Stamp.
•
•
Attività #3: Inclinare il diagramma a bolle – Con un asterisco che si muove su
un grafico, questa prima applicazione illustra come si muove la tasca di aria
bollente dentro il MX2125 quando lo inclinate. Nello stesso tempo, essa pone i
fondamenti dell’accelerometro per continuare a lavorare con le tecniche dalla
Attività #2.
Attività #4: Controllo del Gioco – Siete ora pronti per usare l’inclinazione per
iniziare a controllare il carattere del vostro gioco. I caratteri di sfondo possono
essere utilizzati per prendere decisioni riguardo al fatto che il carattere del gioco
sia dentro o fuori dai limiti. Divertitevi a personalizzare ed espandere questo
video gioco controllato dall’inclinazione.
ATTIVITÀ #1: VISUALIZZAZIONE DI CARATTERI GRAFICI COL PBASIC
Questa attività introduce alcune tecniche di programmazione che utilizzerete per
visualizzare graficamente le coordinate con il terminale di Debug. Alcuni elementi delle
tecniche introdotte in questa attività e nella successiva vi saranno familiari dai capitoli
precedenti sull’Accelerometro e sul LCD.
Il CRSRXY ed altri caratteri di controllo
Il carattere di controllo CRSRXY del commando DEBUG può essere utilizzato per porre il
cursore in una posizione determinata sulla finestrella di ricezione del terminale di Debug.
Ad esempio, DEBUG CRSRXY, 7, 3, "*" pone il carattere asterisco sette spazi a destra e
tre caratteri in basso. Invece di usare costanti come 7 e 3, potete utilizzare variabili per
rendere il posizionamento del cursore regolabile. Diciamo che avete due variabili di
nome x ed y. I valori che queste variabili memorizzano possono controllare il
posizionamento dell’asterisco nel comando DEBUG CRSRXY, x, y, "*".
Il programma che segue fa anche uso del carattere di controllo CLRDN. Il comando DEBUG
CLRDN cancella tutte le righe sotto la posizione corrente del cursore.
Più caratteri di controllo
Potete trovare maggiori notizie sui caratteri di controllo cercando il comando DEBUG, sia
nella Guida Sintattica PBASIC, sia nel Manuale BASIC Stamp. Potete ottenere la Guida
Sintattica PBASIC tramite il vostro Editor BASIC Stamp (v2.0 o più recenti). Basta cliccare
Help (Aiuto) e scegliere Index (Indice). Il Manuale BASIC Stamp è disponibile per lo scarico
dal sito www.parallax.com.
Programma esempio – TracciaCrsrxy.bs2
Con questo programma, potete digitare coppie di cifre nella finestrella di trasmissione
come mostrato in Figura 5-2, per posizionare asterischi nella finestrella di ricezione.
Cliccate semplicemente la finestrella di trasmissione ed iniziate a digitare. Il primo
numero che digitate è il numero degli spazi a destra per posizionare il cursore, e il
secondo numero è il numero di ritorni carrello verso il basso. Prima di digitare una
nuova coppia di cifre (numeri), premete una volta la barra spaziatrice.
Figura 5-2: Finestrelle di Trasmissione e Ricezione del terminale di Debug
finestrella di
trasmissione
finestrella di
ricezione
Digita coordinata X: 9
Digita coordinata Y: 1
Premi un tasto … …
√
√
√
√
√
√
√
Digitate, memorizzate, ed eseguite TracciaCrsrxy.bs2.
Ridimensionate il Terminale di Debug in modo che ci sia ampio spazio per
visualizzare sia l’area del diagramma che le domande.
Cliccate nella finestrella di Trasmissione del terminale di Debug, e seguite le
domande per digitare le cifre che posizionano gli asterischi sul grafico.
Provate la sequenza 11, 22, 33, 43, 53, 63, 73, 84, 95. Gli asterischi nel vostro
Terminale di Debug corrispondono al tracciato nella Figura 5-2?
Provate a predire le sequenze per varie forme, come un quadrato, un triangolo, e
un cerchio.
Inserite le sequenze per provare le vostre predizioni.
Correggete le sequenze per quello che serve.
' Sensori intelligenti e loro applicazioni - TracciaCrsrxy.bs2
' Digita coppie di cifre entro il Terminale di Debug per posizionare
' asterischi.
'{$STAMP BS2}
'{$PBASIC 2.5}
x
y
temp
VAR
VAR
VAR
Word
Word
Byte
DEBUG CLS,
"0123456789X",
"1
",
"2
",
"3
",
"4
",
"5
",
"Y
",
CR,
CR,
CR,
CR,
CR,
CR,
CR, CR
DO
DEBUG "Digita coordinata X: "
DEBUGIN DEC1 x
DEBUG CR, "Digita coordinata Y: "
DEBUGIN DEC1 y
DEBUG CRSRXY, x, y, "*"
DEBUG CRSRXY, 0, 10, "Premi un tasto..."
DEBUGIN temp
DEBUG CRSRXY, 0, 8, CLRDN
LOOP
Il vostro turno – Mantenere i caratteri nell’area del grafico
Se digitate la cifra 8 in risposta alla domanda "Digita coordinata Y: ", il vostro
testo sarà sovrascritto. Problemi analoghi si verificano se digitate 0 per ciascuna delle
coordinate X o Y. L’asterisco è tracciato sopra il testo che mostra quale riga e colonna
CRSRXY sta diagrammando. Un modo per correggere questo è tramite gli operatori MAX e
MIN. Aggiungete semplicemente la frase y = y MAX 5 MIN 1. L’operatore DEC1 del
comando DEBUGIN risolve questo problema per il massimo della coordinata X, dato che
essa è limitata ad un valore tra 0 e 9. Quindi, tutto ciò che vi occorrerà per agganciare il
valore di X è x = x MIN 1.
√
√
√
Provate a digitare valori fuori-dei-limiti per la coordinata Y (0 e da 6 a 9) e 0 per
la coordinata X.
Osservate gli effetti sullo sfondo del display.
Modificate TracciaCrsrxy.bs2 come mostrato qui e provatelo di nuovo
DEBUGIN DEC1 y
Y = y MAX 5 MIN 1
X = x MIN 1
' <--- Aggiungete
' <--- Aggiungete
Scalatura e Offset
La scalatura (riduzione in scala) e l’offset sono stati introdotti nel Capitolo 3 per gestire i
valori di ingresso dall’accelerometro. Nel Capitolo 3, abbiamo utilizzato l’operatore **
per la scalatura (moltiplicazione) a valori frazionari (decimali). In questo esempio,
utilizzeremo l’operatore * poiché una delle variabili dell’esempio che segue deve soltanto
essere moltiplicata per il valore intero 2.
Date uno sguardo alla Figura 5-3, dove è stato stampato nel terminale di Debug un
diagramma con assi sia positivi che negativi. L’asse orizzontale, o x, ha uno spazio tra
ciascun numerale, e l’asse verticale, y, non ce l’ha. Per posizionare il cursore in un
punto particolare tramite il comando CRSRXY, ci serve il tracciamento tra gli assi stampato
nel terminale di Debug e gli assi utilizzati dal comando CRSRXY.
Figura 5-3: Inserimento e visualizzazione delle coordinate
Premi un tasto…
Per esempio, dove gli assi del grafico si intersecano alle coordinate (0, 0), è in realtà la
posizione 6,3 di CRSRXY. (Confrontate con la Figura 5-2 finché non vedete che è così.)
Per questo programma vorremmo poter digitare “-3-3” nel terminale di Debug e veder
apparire l’asterisco nelle coordinate (-3, -3) del grafico, che sarebbero la posizione 0,6 di
CRSRXY. Come altro esempio, quando digitate 2,2, CRSRXY in realtà deve posizionare
l’asterisco a 10,1. Ora, è il momento di capire come fare questa traduzione di mappatura
tramite la scalatura e l’offset.
Per i valori nell’intervallo tra -3 e 3, il valore X deve essere moltiplicato per 2 ed
aggiunto a 6 perché CRSRXY posizioni l’asterisco il numero corretto di spazi avanti. Cioè
faremo una scalatura di 2, ed un offset di 6. Ecco una istruzione PBASIC che fa la
conversione dalla coordinata X al numero di spazi.
x = (x * 2) + 6
Il valore di Y deve essere moltiplicato per -1, quindi sommato a 3. Cioè una scalatura di
-1 ed un offset di 3. Ecco una istruzione PBASIC che fa la conversione dalla coordinata
Y al numero di ritorni carrello.
y = 3 - y
√
Provate a sostituire le coordinate X ed Y nel membro destro di ciascuna di queste
equazioni, fate i conti, e verificate che ciascuna equazione fornisce il numero
corretto di spazi e di ritorni carrello.
Programma esempio –TracciaGraficoXY.bs2
√
√
√
Digitate ed eseguite TracciaGraficoXY.bs2.
Provate a digitare la sequenza di valori: -3-3, -2-2, -1-1, 00, 11, 22, 33, e
verificate che si accorda con l’esempio di Terminale di Debug in Figura 5-3.
Provate altre sequenze e/o forme di disegno tramite le loro coordinate.
' Sensori intelligenti e loro applicazioni - TracciaGraficoXY.bs2
' Posiziona interattivamente cursore sul grafico nel Terminale di Debug
'{$STAMP BS2}
'{$PBASIC 2.5}
x
y
temp
DEBUG CLS,
VAR
VAR
VAR
Word
Word
Byte
"
3|
",
"
2|
",
"
1|
",
"------+------",
"-3-2-1| 1 2 3",
"
-2|
",
"
-3|
",
CR,
CR,
CR,
CR,
CR,
CR,
CR, CR
DO
DEBUGIN SDEC1 x
DEBUGIN SDEC1 y
x = (x * 2) + 6
y = 3 - y
DEBUGIN temp
LOOP
Il vostro turno – Mantenere caratteri ancora nell’area del grafico
Gli operatori MAX e MIN sono stati introdotti prima in questo testo, per evitare che
l’asterisco appaia fuori dall’area di visualizzazione. Potete usare anche istruzioni
IF…THEN per manipolare valori fuori dai limiti. Ecco un esempio di come si possa
modificare TracciaGraficoXY.bs2 con istruzioni IF…THEN. Invece di catturare i valori e
posizionare l’asterisco entro i limiti consentiti, questo programma aspetta semplicemente
che sia digitato un valore corretto.
√ Modificare TracciaGraficoXY.bs2 sostituendo l’istruzione DEBUG CRSRXY, x,
y, "*" con il blocco IF...THEN...ELSE...ENDIF mostrato sotto, e quindi
eseguirlo.
x = (x * 2) + 6
y = 3 – y
IF (x > 12) OR (y > 6) THEN
DEBUG CRSRXY, 0, 8, CLRDN,
"Digita valori tra -3 e 3.", CR,
"Prova di nuovo "
' <--- Aggiungere codice da
'
qui...
'
'
'
ELSE
'
'
ENDIF
'
' <--- fino a qui
DEBUGIN temp
√
Verificate che questo programma non consente di digitare caratteri fuori
dall’intervallo da -3 a 3.
Che succede con i numeri negativi?
Le condizioni delle istruzioni IF...THEN nella versione modificata del vostro programma
TracciaGraficoXY.bs2 sono (x > 12) OR (y > 6). Questo copre i numeri positivi più grandi di
12 o di 6, ma copre anche tutti i numeri negativi. Ciò avviene perché il BASIC Stamp usa un
sistema chiamato complemento a due per memorizzare i numeri negativi. Nel complemento
a due, la versione senza segno di qualsiasi valore negativo è superiore a qualsiasi valore
positivo. Ad esempio, -1 è 65535, -2 è 65534, e così via, giù fino a -32768, che è in realtà
32768. I valori positivi con segno variano soltanto tra 1 e 32767.
Algebra per determinare scalatura ed offset
Il grafico XY visualizzato nel terminale di Debug in questa attività è chiamato sistema di
coordinate Cartesiane. Questo sistema prende il nome dal matematico del 17mo secolo
René Descartes, ed è la base per le tecniche grafiche utilizzate in molte ricerche di
matematica. Mostrato nella Figura 5-4a, il sistema di coordinate cartesiane è molto
frequentemente visualizzato con (0, 0) al centro del grafico. I suoi valori crescono
andando verso l’alto (asse y) e verso destra (asse x). Molte visualizzazioni si comportano
in modo diverso, con la coordinata 0, 0 che inizia in alto a sinistra come in Figura 5-4b.
Mentre l’asse x cresce verso destra, l’asse y cresce verso il basso.
Figura 5-4: Coordinate cartesiane confrontate con le coordinate visualizzate
a. Coordinate cartesiane
b. Coordinate visualizzate
Potete usare una tecnica standard dell’algebra, risolvendo un sistema di due equazioni in
due incognite, per trovare le istruzioni che vi servono per trasformare le coordinate
cartesiane in coordinate di visualizzazione per il terminale di Debug. L’esempio che
segue mostra come sia stato fatto questo per le istruzioni che convertono x ed y da
coordinate cartesiane a coordinate visualizzate in TracciaGraficiXY.bs2.
Aggiungendo due comandi DEBUG al programma TracciaGraficiXY.bs2, potete
visualizzare le versioni prima e dopo del valore X che avete digitato.
DEBUGIN SDEC1 x
DEBUGIN SDEC1 y
DEBUG CRSRXY, 0, 12, "x prima: ", SDEC x
' <--- Aggiungere
x = (x * 2) + 6
y = 3 - y
DEBUG CRSRXY, 0, 14, "x dopo:
", SDEC x
' <--- Aggiungere
√
√
√
Memorizzate TracciaGraficiXY.bs2 sotto altro nome, ad esempio
TracciaGraficiXYPrimaDopo.bs2.
Aggiungete i due comandi DEBUG che visualizzano i valori di x "prima" e
"dopo".
Aggiungete due ulteriori comandi DEBUG per visualizzare i valori di y “prima” e
“dopo”.
√
√
Digitate le coordinate (3,1) e (-2,- 2) nella finestrella di trasmissione del
terminale di Debug. Si veda la Figura 5-5.
Registrate i valori Dopo nella Tabella 5-1.
Tabella 5-1: Valori di X Prima e Dopo
Coordinate
Prima
(3, 1)
3
(-2, -2)
-2
Dopo
Figura 5-5
Prova Coordinate
Premi un tasto…
Quando si progetta una visualizzazione per mostrare coordinate cartesiane, è utile
prendere una coppia di valori prima e dopo come quelli della Tabella 5-1. Potete quindi
usarli per risolvere la scalatura (K) e l’offset (C) usando due equazioni con due incognite.
X dopo = (K × Xprima) + C
I passi consueti per le due equazioni in due incognite sono:
(1) Sostituite i vostri due punti dato prima e dopo in due copie separate dell’equazione.
12 = (K × 3) + C
2 = (K × − 2 ) + C
(2) Se necessario, moltiplicate una delle due equazioni per un termine che renda uguale
il numero di una delle incognite nell’equazione superiore ed in quella inferiore.
Non necessario , poiché il coefficien te di C in entrambe le equazioni è 1.
(3) Sottrarre un’equazione dall’altra per rendere zero una delle incognite.
12 = (K × 3) + C
− [ 2 = (K × -2) + C ]
10 = K × 5
(4) Risolvere nell’incognita che non si annulla nella sottrazione.
10 = K × 5
10
K=
5
K =2
(5) Sostituire il valore ricavato al punto 4 in una delle due equazioni originali.
12 = (2 × 3) + C
(6) Risolvere nella seconda incognita.
12 = (2 × 3) + C
12 = 6 + C
C = 12 - 6
C =6
(7) Incorporare i valori ricavati per le incognite nella vostra equazione.
(
)
Xdopo = K × Xprima + C
K =2 e C =6
(
)
Xdopo = 2 × Xprima + 6
Il vostro turno – Calcoli sull’asse Y
√
√
Modificate il vostro programma perché visualizzi i valori sull’asse Y prima e
dopo.
Riempite la Tabella 5-2 con i valori per l’asse Y:
Tabella 5-2: Valori Y Prima e Dopo
Coordinate
Prima
(3, 1)
1
(-2, -2)
-2
Dopo
Figura 5-6
Coordinate di prova
Premi un tasto…
√
Ripetete i passi da 1 a 7 per l’equazione sull’asse Y. La risposta corretta è:
(
)
ydopo = − 1× yprima + 3
ATTIVITÀ #2: MEMORIZZAZIONE E RINFRESCO (REFRESH) NELLA
EEPROM
In un video gioco, quando il carattere del vostro gioco non è sullo schermo, tutto ciò che
è visibile è lo sfondo. Non appena il vostro carattere di gioco entra sullo schermo, esso
blocca parte dello sfondo. Quando il carattere si muove, debbono accadere due cose: (1)
il carattere di gioco dev’essere ridisegnato nella nuova posizione, e (2) lo sfondo che il
carattere di gioco stava bloccando dev’essere ridisegnato. Se il punto 2 non è mai
capitato nel vostro programma, il vostro schermo si riempirebbe con copie del vostro
carattere di gioco.
I monitor per la televisione e i CRT per computer rinfrescano (refresh) ciascun pixel
molte volte per ogni secondo. La velocità di refresh sui televisori è intorno a 30 Hz, e
alcune delle velocità di refresh più comuni nei CRT sono 60, 70, e 72 Hz. Altri
dispositivi come certi LCD e display a LED mantengono l’immagine automaticamente, o
a volte con l’aiuto di un altro microcontrollore. Tutto ciò che debbono fare i programmi
o i microcontrollori che controllano questi dispositivi è dire loro cosa debbono
viualizzare o modificare. Questo è anche il modo in cui la compressione video opera sul
vostro computer. Per ridurre la dimensione dei file, alcuni file video compressi
memorizzano i cambiamenti dell’immagine invece di tutti i pixels in un dato schema di
immagine.
Quando viene usata con display che non debbono essere rinfrescati (come il terminale di
Debug o un LCD), la EEPROM del BASIC Stamp può memorizzare un’immagine di un
gioco o uno sfondo grafico nella sua EEPROM. Quando un carattere di gioco si muove
ed è ridisegnato in posizione differente, il BASIC Stamp può leggere solo la sua
EEPROM e ridisegnare i caratteri di sfondo nella posizione del carattere di gioco
precedente. Per far questo, memorizzate semplicemente le vecchie coordinate del
carattere di gioco prima che venga mosso e quindi usate quelle coordinate per reperire il
carattere di sfondo dalla EEPROM. In funzione delle dimensioni del display, questo
metodo può risparmiare una considerevole quantità di tempo, di cui il BASIC Stamp
potrebbe necessitare per eseguire altri compiti.
Questa attività introduce tre elementi per caratteri di gioco e sfondi:
1. Memorizzazione e visualizzazione dello sfondo dalla EEPROM
2. Osservazione delle vecchie e nuove coordinate di un carattere
3. Ridisegno delle vecchie coordinate dalla EEPROM
Visualizzazione dello sfondo dalla EEPROM
Questa visualizzazione non dev’essere fatta con un singolo comando DEBUG,
specialmente se serve che sia mantenuta come sfondo mentre i caratteri viaggiano su di
essa in primo piano. Invece, è meglio memorizzare i caratteri nella EEPROM e poi
visualizzarli singolarmente con un ciclo FOR…NEXT che usa i comandi READ e DEBUG per
visualizzare caratteri singoli. La Figura 5-7 è una visualizzazione generata con questa
tecnica.
Figura 5-7
Sfondo da
una direttiva DATA
Potete usare la direttiva DATA per memorizzare uno sfondo nella EEPROM. Notate come
questa direttiva DATA memorizza 100 caratteri (da 0 a 99). Notate anche che ciascuna
riga è larga 14 caratteri quando aggiungete il carattere di controllo CR. La
programmazione diventa più facile se ciascuna riga ha la stessa larghezza. Altrimenti,
trovare il carattere che volete diventa un problema più complesso.
DATA CLS,
"
3|
",
"
2|
",
"
1|
",
"------+------",
"-3-2-1| 1 2 3",
"
-2|
",
"
-3|
",
CR,
CR,
CR,
CR,
CR,
CR,
CR, CR
'
'
'
'
'
'
'
'
0
14
28
42
56
70
84
98 + 1 = 99
Per visualizzare l’intero sfondo una sola volta all’inizio del programma, potete quindi
usare un ciclo FOR…NEXT. Questo ciclo reperisce e visualizza ciascun carattere
memorizzato nella EEPROM. Tenete a mente che, mentre l’effetto che ottenete è lo
stesso di quello di un lungo comando DEBUG, la EEPROM è più flessibile perché potete
anche andare a prendere e visualizzare singoli caratteri quando vi occorre rinfrescare lo
sfondo.
FOR indice = 0 TO 99
READ indice, carattere
DEBUG carattere
NEXT
Programma esempio –DisplaySfondoEeprom.bs2
√
√
Digitate, memorizzate ed eseguite il programma.
Verificate che la visualizzazione è la stessa di TracciaGraficiXy.bs2.
' Sensori intelligenti e loro applicazioni - DisplaySfondoEeprom.bs2
'
'{$STAMP BS2}
'{$PBASIC 2.5}
indice
carattere
' Direttive Stamp & PBASIC
VAR
VAR
DATA CLS,
"
3|
",
"
2|
",
"
1|
",
"------+------",
"-3-2-1| 1 2 3",
"
-2|
",
"
-3|
",
Byte
Byte
CR,
CR,
CR,
CR,
CR,
CR,
CR, CR
DEBUG carattere
NEXT
' Variabili
'
'
'
'
'
'
'
'
0
14
28
42
56
70
84
98 + 1 = 99
' Memorizza sfondo in EEPROM
' Trova e visualizza sfondo
END
Il vostro turno – Vedere i caratteri nella EEPROM
√
√
√
√
Nell’Editor BASIC Stamp, cliccare Run e selezionare Memory Map.
Cliccare la box Display ASCII nell’angolo in basso a sinistra della finestra
Memory Map.
Le cifre, i trattini, e le barre verticali dovrebbero apparire nella Mappa EEPROM
esattamente come mostrato in Figura 5-8.
Invece di 14 caratteri per riga, la Mappa EEPROM ne mostra 16. Verificate che
avete un totale di 100 (da 0 a 99) caratteri memorizzati in EEPROM per scopo di
visualizzazioni.
Figura 5-8: Caratteri per Display memorizati in EEPROM
Osservazione delle vecchie e nuove coordinate di un carattere
Diciamo che volete osservare le precedenti coordinate X ed Y nel programma originale
non modificato TracciaGraficoXY.bs2 dalla Attività #1. Ci vogliono due passaggi:
(1) Dichiarare una coppia di variabili per memorizzare i vecchi valori, per esempio
xVec ed yVec.
x
y
VAR
VAR
Word
Word
xVec
yVec
VAR
VAR
Nib
Nib
temp
VAR
Byte
' <--- Aggiungi
' <--- Aggiungi
(2) Prima di caricare nuovi valori nelle variabili x ed y, memorizzate il valore attuale di
x in xVec e il valore attuale di y in yVec.
DO
xVec = x
yVec = y
' <--- Aggiungi
' <--- Aggiungi
Perché x ed y sono word mentre xVec ed yVec sono nibble?
Quando si lavora con valori con segno, le variabili word memorizzano sia valore che segno.
Nel posto particolare in cui xVec ed yVec sono usate nel programma, esse stanno soltanto
memorizzando valori che variano tra 0 e 12, quindi ci servono soltanto variabili nibble.
Ecco un terzo passaggio che potete usare per provare e verificare che funziona:
(3) Aggiungete comandi DEBUG per visualizzare i valori attuali e precedenti di x, y.
DEBUG CRSRXY, 0, 10,
"Entrata attuale: (",
DEC x, ",", DEC y, ")"
"Entrata preced.: (",
DEC xVec, ",", DEC yVec, ")"
' <--- Aggiungere
' <--- Aggiungere
' <--- Modificare
' <--- Modificare
DEBUGIN temp
√
Iniziate con la versione originale, non modificata di TracciaGraficoXY.bs2,
memorizzatelo con il nome RichiamaTracciaGrafXY.bs2, e provate le modifiche
appena discusse qui sopra nei passaggi da (1) a (3). Tenete a mente che entrambi
i valori visualizzati saranno in termini di coordinate del terminale di Debug.
Tenete anche in mente che la prima volta che lo eseguite, le vecchie coordinate
saranno (0, 0) poiché tutte le variabili sono inizializzate a zero in PBASIC.
Ridisegnare lo Sfondo
Fino a questo punto, tutti i nostri diagrammi hanno accumulato asterischi appena abbiano
digitato più valori nella finestrella di trasmissione. L’effetto netto che vogliamo ottenere
per il controllo di gioco è far scomparire l’asterisco dalla sua posizione precedente e farlo
apparire nella nuova posizione non appena la ridefiniamo, per dare la sensazione di un
asterisco che si muove.
Date uno sguardo alla Figura 5-9. Notate che sei coppie ordinate sono state inserite nel
Terminale di Debug, ma c’è soltanto un asterisco, che corrisponde all’ultima coppia
inserita. Questo fatto capita perché il programma usato qui fa scomparire il vecchio
asterisco prendendo le vecchie coordinate x, y per trarre il carattere di sfondo dalla
EEPROM, e poi visualizzandolo con DEBUG. Per far apparire l’asterisco nella sua nuova
posizione, il programma usa semplicemente un comando DEBUG con le coordinate x, y
attuali, come hanno fatto i nostri programmi esempio precedenti.
Figura 5-9
Display con la EEPROM.
Refresh dello sfondo
Premi un tasto…
Il programma usato per creare la Figura 5-9 combina la tecnica di sfondo definita con le
DATA dal DisplaySfondoEEPROM.bs2, con il tracciamento dell’asterisco e la tecnica di
osservazione della posizione dal RichiamaTracciaGrafXY.bs2. Questa combinazione ci
consente di ridisegnare il carattere di sfondo sopra il vecchio asterisco con questo codice:
IF (x <> xVec) AND (y <> yVec) THEN
index = (14 * yVec) + xVec + 1
DEBUG CRSRXY, xVec, yVec, carattere
ENDIF
'
'
'
'
Controlla se asterisco è mosso
Indirizzo carattere sfondo
Ottiene carattere sfondo
Visualizza carattere sfondo
La variabile indice sceglie il carattere corretto dalla EEPROM. Il valore x è il numero
di spazi sopra e il valore y è il numero di ritorni carrello sotto. Per ottenere l’indirizzo
corretto di un carattere nella terza riga, il vostro programma dave aggiungere tutti i
caratteri nelle prime due righe. Dato che ciascuna riga ha 14 caratteri, yVec dev’essere
moltiplicato per 14 prima di poterlo aggiungere a xVec. Il valore extra 1 è aggiunto per
scavalcare il comando CLS all’indirizzo 0.
Indipendentemente dal fatto che si tratta di display del computer, o del display a cristalli
liquidi del vostro telefono cellulare, o del display della vostra applicazione BASIC
Stamp, si applica sempre la stessa tecnica. Il processore memorizza due immagini
diverse, l’una sullo sfondo e l’altra in primo piano. Appena l’oggetto in primo piano “si
muove” è visualizzato in una posizione diversa e l’area che l’oggetto in primo piano ha
svuotato è ridisegnata.
La cosa più importante da tenere a mente su questa tecnica di programmazione è che
risparmia molto tempo al processore. Essa deve solo ottenere un carattere dalla
EEPROM ed inviarlo al terminale di Debug. Confrontato con i 99 caratteri, c’è un
risparmio di tempo significativo, e il BASIC Stamp può fare altre cose in quel tempo,
come ad esempio controllare altri sensorsi, controllare i servo, ecc.
Programma Esempio – RinfrescaSfondoEEPROM.bs2
Questo programma combina TracciaGraficoXY.bs2 con DisplaySfondoEeprom.bs2,
usando il display di sfondo, la memorizzazione delle coordinate, e la tecnica per
ridisegnare lo sfondo appena discussa.
√
√
Digitate, salvate ed eseguite RinfrescaSfondoEEPROM.bs2.
Provatelo e verificate che l’asterisco scompare dalla sua posizione vecchia ed
appare nella nuova posizione che avete inserito.
' -----[ Titolo ]----------------------------------------------------------' Sensori intelligenti e loro applicazioni – RinfrescaSfondoEeprom.bs2
'{$STAMP BS2}
'{$PBASIC 2.5}
' direttive Stamp/PBASIC
' -----[ Variabili ]------------------------------------------------------x
y
VAR
VAR
Word
Word
' Memorizza posizione attuale
xVec
yVec
temp
VAR
VAR
VAR
Nib
Nib
Byte
' Memorizza posizione precedente
indice
VAR
Byte
' Memorizza READ indice/carattere
' Variabile finta per DEBUGIN
carattere
VAR
Byte
' -----[ EEPROM Data ]----------------------------------------------------DATA CLS,
"
3|
",
"
2|
",
"
1|
",
"------+------",
"-3-2-1| 1 2 3",
"
-2|
",
"
-3|
",
' Dati per sfondo
CR,
CR,
CR,
CR,
CR,
CR,
CR, CR
'
'
'
'
'
'
'
14
28
42
56
70
84
98 + 1 = 99
' -----[ Inizializzazione ]-----------------------------------------------FOR indice = 0 TO 99
DEBUG carattere
NEXT
' Visualizza sfondo
' -----[ Routine principale]----------------------------------------------DO
xVec = x
yVec = y
' Memorizza coordinate precedenti
DEBUGIN SDEC1 x
DEBUGIN SDEC1 y
' Ottiene nuove coordinate
x = (x * 2) + 6
y = 3 - y
' Da Cartesiane a valori x DEBUG
' Visualizza asterisco
IF (x <> xVec) AND (y <> yVec) THEN
indice = (14 * yVec) + xVec + 1
ENDIF
'
'
'
'
DEBUG CRSRXY, 0, 10, "Premi un Tasto..."
DEBUGIN temp
' Attende input utente
LOOP
Controlla se asterisco mosso
Indirizzo carattere sfondo
Ottiene carattere sfondo
Visualizza carattere sfondo
' Cancella vecchie info
Il vostro turno - Ridisegnare lo sfondo senza variabili extra
Non sempre è necessario tenere traccia della vecchia posizione del carattere di primo
piano. Pensatelo in questo modo: nel RinfrescaSfondoEeprom.bs2 le variabili x ed y
memorizzano i vecchi valori finché non inserite valori nuovi.
Risistemando
semplicemente l’ordine in cui sono visualizzate le variabili x ed y, potete eliminare il
bisogno di xVec ed yVec.
Poi c’è una Routine principale in sostituzione che potete provare nel
RinfrescaSfondoEeprom.bs2. Non appena premete la barra spazio, il vostro vecchio
asterisco scompare. Il nuovo asterisco riappare quando digitate la seconda delle due
coordinate. Come vedrete nella prossima attività, questa tecnica funziona davvero bene
con controllo di inclinazione quando la velocità di rinfresco è parecchie volte al secondo.
√
√
√
√
Memorizzate RinfrescaSfondoEEPROM.bs2 come
RinfrescaSfondoEEPROMTuoTurno.bs2.
Commentate le dichiarazioni di variabili xVec ed yVec.
Sostituite la Routine Principale in RinfrescaSfondoEeprom.bs2 con questa.
Provatela ed esaminate il cambiamento nel comportamento del programma.
' -----[ Routine Principale]------------------------------------------DO
indice = (14 * y) + x + 1
DEBUG CRSRXY, x, y, carattere
' Rivisualizza sfondo
DEBUG CRSRXY, 0, 8,
"Diigita coordinata X: "
DEBUGIN SDEC1 x
DEBUGIN SDEC1 y
' Ottieni nuove coordinate
x = (x * 2) + 6
y = 3 - y
' da Cartesiane a valori di DEBUG
DEBUG CRSRXY, 0, 10, "Premi un Tasto..." ' Aspetta input utente
DEBUGIN temp
' Cancella vecchia info
LOOP
Animazione e ridisegno dello sfondo
Ecco un esempio di qualcosa che potete fare se utilizzate singoli caratteri, ma che non
funziona se tentate di ridisegnare l’intero display con un comando DEBUG.
√
√
√
Memorizzate RinfrescaSfondoEEPROM.bs2 col nome EsempioAnimazione.bs2.
Sostituite la Routine principale nel programma con quella mostrata qui.
Eseguite il programma ed osservatene gli effetti.
DO
FOR y = 0 TO 6
FOR temp = 1 TO 2
FOR x = 0 TO 12
IF (temp.BIT0 = 1) THEN
ELSE
index = (14 * yVec) + xVec + 1
xVec = x
yVec = y
ENDIF
PAUSE 50
NEXT
NEXT
NEXT
LOOP
ATTIVITÀ #3: INCLINARE IL GRAFICO A BOLLA
Questa attività combina i concetti grafici introdotti nelle Attività #1 e #2 con le tecniche
per la misura dell’inclinazione con l’accelerometro introdotte nel Capitolo 3. Il risultato
è una “bolla” di asterischi che illustra il movimento della tasca di gas surriscaldato
interna alla camera del MX2125. La Figura 5-11 della pagina successiva mostra che cosa
visualizza il terminale di Debug in questa attività, quando l’accelerometro è inclinato in
alto e a sinistra.
Parti richieste
(2) Cavallotti di filo da 3 pollici
(2) Resistenze – 220 Ω
(1) Accelerometro Memsic MX2125 a due assi
√
Collegare il modulo accelerometro usando la Figura 5-10 come guida.
Figura 5-10: Schema elettrico e diagramma di cablaggio dell’Accelerometro
Figura 5-11: Posizione del gas bollente nell’Accelerometro
L’asterisco indica la
L’asterisco
posizione indica
del
gas bollente
la posizione del gas
La Figura 5-12 mostra una legenda per i diversi modi in cui potete inclinare la scheda sui
suoi assi e l’effetto di ciascuna inclinazione sulla posizione della tasca di gas bollente.
Inclinazione
Centro gas bollente
Livellato
(0, 0)
Inclina a
destra
(-3, 0)
Inclina a
sinistra
(3, 0)
Inclina
in basso
(0, -3)
Inclina
in alto
(0, 3)
Figura 5-12:
Inclinazione
dell’Accelerometro
e posizione del
cursore
Controllo inclinazione del Display con asterisco
GraficoBolla.bs2 aggiorna la posizione della macchia bollente entro la camera
dell’accelerometro circa 8 volte al secondo (8 Hz). Dopo aver visualizzato lo sfondo
(assi X ed Y) sul Terminale di Debug, ripete gli stessi passaggi indefinitamente.
•
•
•
•
•
•
Sostituisce l’asterisco con il carattere di sfondo e fa pausa per l’effetto
lampeggio.
Ottiene l’inclinazione sull’asse X dall’accelerometro.
Ottiene l’inclinazione sull’asse Y dall’accelerometro.
Regola il valore in modo che si adatti all’asse X del grafico.
Regola il valore in modo che si adatti all’asse Y del grafico.
Visualizza l’asterisco e fa di nuovo pausa per l’effetto lampeggiante.
Ciascuno di questi passi è discusso con maggior dettaglio nel capitolo che segue il
programma esempio.
Programma esempio – GraficoBolla.bs2
√
'
'
'
'
Digitate ed eseguite GraficoBolla.bs2.
-----[ Titolo ]------------------------------------------------------------Sensori intelligenti e loro applicazioni - GraficoBolla.bs2
Visualizza la posizione della bolla nel sensore di inclinazione
sul grafico nel Terminale di Debug
'{$STAMP BS2}
'{$PBASIC 2.5}
' -----[ Dati in EEPROM ]----------------------------------------------------' Memorizza sfondo in EEPROM
' Indirizzo ultimo car su riga
DATA CLS,
"
5^Y
",
"
4|
",
"
3|
",
"
2|
",
"
1|
X",
"----------+--------->",
"-5-4-3-2-1| 1 2 3 4 5",
"
-2|
",
'
'
'
'
'
'
'
'
'
CR,
CR,
CR,
CR,
CR,
CR,
CR,
CR,
0
22
44
66
88
110
132
154
176
"
"
"
-3|
-4|
-5|
", CR,
", CR,
", CR
' 198
' 220
' 242
' -----[ Variabili ]---------------------------------------------------------x
y
VAR
VAR
indice
car
VAR
VAR
Word
Word
Word
Byte
' Memorizza posizione attuale
' memoria indice/carattere READ
' -----[ Inizializzazione ]--------------------------------------------------FOR indice = 0 TO 242
READ indice, car
DEBUG car
NEXT
' Legge & visualizza sfondo
' Inizia routine principale
' Sostituisce asterisco con carattere di sfondo.
indice = (22 * y) + x + 1
' Coordinate -> indirizzo EEPROM
READ indice, car
' Ottiene carattere sfondo
DEBUG CRSRXY, x, y, car
' Visualizza carattere sfondo
PAUSE 50
' Pausa per effetto lampeggio
' Misura inclinazione.
PULSIN 6, 1, x
PULSIN 7, 1, y
' Ottiene
'
x
y
y
' Calcola posizione x
' Calcola posizione y
Calcola posizione cursore.
= (x MIN 1875 MAX 3125) - 1875 ** 1101
= (y MIN 1875 MAX 3125) - 1875 ** 576
= 10 - y
Ax ed Ay
' Visualizza asterisco alla nuova posizione del cursore.
PAUSE 50
' Pausa di nuovo per effetto lamp
LOOP
√
√
√
' Ripete routine principale
Tenete la vostra scheda come mostrato in alto nella Figura 5-12.
Prendete pratica del controllo dell’asterisco inclinando la scheda.
Oltre a tenere la vostra scheda orizzontale e ad inclinarla, provate a tenerla
verticale e a ruotarla in cerchio. L’asterisco deve descrivere un arco di cerchio
intorno al grafico mentre voi lo fate.
Come lavora GraficoBolla.bs2
La prima cosa che fa la Routine principale è visualizzare il carattere di sfondo nella
posizione attuale del cursore. Con una pausa di 50 ms, essa completa la porzione “off” di
un asterisco lampeggiante.
' Sostituisce asterisco con carattere di sfondo.
indice = (22 * y) + x + 1
READ indice, car
' Ottiene carattere sfondo
PAUSE 50
Quindi, il programma acquisisce l’inclinazione x ed y.
' Misura inclinazione.
PULSIN 6, 1, x
PULSIN 7, 1, y
' Ottiene Ax ed Ay
Il programma deve effettuare scalatura ed offset delle misure di inclinazione sugli assi x
ed y in modo che l’asterisco sia posizionato correttamente nel terminale di Debug. A
questo scopo lavorano la stessa scalatura ed offset introdotti nel Capitolo 3, Attività #3.
Per l’asse x, i valori di impulso dell’accelerometro da 1875 a 3125 debbono essere scalati
ai posizionamenti dell’asterisco da 0 a 20. Sottraendo 1875 dalla misura
dell’accelerometro prima della scalatura, avremo una scala di ingresso tra 0 e 1250 (1251
elementi) e una scala di uscita tra 0 e 20 (21 elementi). L’equazione per il calcolo della
costante ** di scala è:
CostanteScala = Int[65536(elementi scala uscita)/(elementi scala ingresso - 1)]
Sostituendo il numero di elementi nelle scale di ingresso e uscita si ottiene una costante
** di scala di 1101.
CostanteScala = Int[65536(21/(1251-1))]
CostanteScala = Int[65536(21/1250)]
CostanteScala = Int[1101,0048]
CostanteScala = 1101
Con operazioni simili si ottiene una costante ** di scala di 576 per l’asse y, e il codice
risultante per scalatura ed offset di entrambi gli assi è:
' Calcola posizione cursore.
x = (x MIN 1875 MAX 3125) - 1875 ** 1101
y = (y MIN 1875 MAX 3125) - 1875 ** 576
y = 10 - y
Se le misure dell’accelerometro sono leggermente fuori della scala tra 1875 e 3125, ciò
può causare strani sintomi di visualizzazione. Gli operatori MIN e MAX prevengono questo
problema. Inoltre, 1875 è sottratto da ciascun asse prima della scalatura con l’operatore
**. Il risultato per l’asse x è che la misura tra 0 e 1250 è scalata tra 0 e 20. Per l’asse y,
la misura tra 0 e 1250 è scalata tra 0 e 10.
Mentre le misure di inclinazione sull’asse y diminuiscono, la posizione verso il basso del
cursore deve aumentare. Quindi, invece di adattare la scala tra 1875 e 3125 a quella tra 0
e 10, il programma dovrà adattarla a quella tra 10 e 0. L’istruzione y = 10 - y risolve
questo problema. Se y è 0, dopo la scalatura diventa 10. Analogamente se y è 10, dopo
la scalatura diventa 0. Se è 9, dopo la scalatura diventa 1, se è 8, dopo la scalatura
diventa 2, e così via.
L’ultimo passaggio prima di ripetere il ciclo nella Routine principale è la visualizzazione
del nuovo asterisco nelle sue nuove coordinate x ed y, quindi c’è una pausa di altri 50 ms
per completare la porzione “on” dell’asterisco lampeggiante.
' Visualizza asterisco alla nuova posizione del cursore.
PAUSE 50
Il vostro turno – Una bolla più grande
Si può visualizzare e cancellare un gruppo di asterischi come quello mostrato nella Figura
5-13, ma a paragone di un singolo carattere, è un pochino più difficile. Il programma
deve assicurare che nessuno degli asterischi sarà visualizzato fuori dell’area del grafico.
Esso deve anche assicurare che tutti gli asterischi saranno sovrascritti con i caratteri
corretti presi dalla EEPROM. Ecco un esempio di come modificare GraficoBolla.bs2 in
modo che visualizzi un indicatore di coordinata a 5 asterischi:
√
√
Memorizzate GraficoBolla.bs2 come GraficoBollaTuoTurno.bs2.
Aggiungete questa dichiarazione di variabile alla sezione Variabili del
programma:
temp
√
VAR
Byte
Sostituite la routine “Sostituisce asterisco con carattere di sfondo” con:
' Sostituisce asterisco con carattere di sfondo (modificata).
FOR temp = (x MIN 1 – 1) TO (x MAX 19 + 1)
indice = (22 * y) + temp + 1
READ indice, car
DEBUG CRSRXY, temp, y, car
NEXT
FOR temp = (y MIN 1 – 1) TO (y MAX 9 + 1)
indice = (22 * temp) + x + 1
READ indice, car
DEBUG CRSRXY, x, temp, car
NEXT
PAUSE 50
√
Sostituite la routine “Visualizza asterisco alla nuova posizione del cursore” con:
' Visualizza asterisco alla
DEBUG CRSRXY, x,
CRSRXY, x MAX 19 + 1,
CRSRXY, x,
CRSRXY, x MIN 1 - 1,
CRSRXY, x,
PAUSE 50
√
nuova posizione del cursore (modificata).
y,
"*",
y,
"*",
y MAX 9 + 1, "*",
y,
"*",
y MIN 1 - 1, "*"
Eseguite il programma e provatelo. Accertatevi che non si verifichino problemi
quando uno degli asterischi più esterni è forzato fuori dell’area del grafico.
Figura 5-13
Gruppo di Asterischi
con rinfresco dello sfondo
MIN e i numeri negativi
Una "gotcha" (ottieni carattere) in complemento a due evita di sottrarre 1 da 0 e quindi di
impostare il valore MIN più tardi. Ricordate dal Capitolo 3 che il sistema del complemento a
due memorizza il valore con segno -1 come 65535. Questo è il motivo per cui il valore MIN
è stato impostato ad 1 prima di sottrarre 1. Il risultato è quindi un minimo corretto di 0. La
stessa tecnica è stata usata per impostare i valori di MAX anche se in questo caso non c‘è
alcun problema reale con y + 1 MAX 10.
ATTIVITÀ #4: CONTROLLO DI GIOCO
Ecco le regole dell’esempio di gioco a controllo di inclinazione di questa Attività,
mostrato in Figura 5-12. Inclinate la vostra scheda per controllare l’asterisco. Se
attraversate il labirinto e ponete l’asterisco su uno qualsiasi dei caratteri "WIN", sarà
visualizzata la schermata "YOU WIN" (“HAI VINTO!”). Se urtate in uno qualsiasi dei
segni di libbra "#" prima di raggiungere la fine del labirinto, sarà visualizzata la
schermata "YOU LOSE" (“HAI PERSO”). Mentre navigate nel labirinto, provate a
muovere il vostro carattere di gioco “asterisco” verso il segno di dollaro "$" per ottenere
più punti.
Convertire GraficoBolla.bs2 in GiocoInclinaOstacoli.bs2
GiocoInclinaOstacoli.bs2 è senza dubbio una versione più spedita del GraficoBolla.bs2.
Ecco un elenco dei principali cambiamenti ed aggiunte:
•
•
•
•
Cambia il grafico in un labirinto.
Aggiunge ai dati EEPROM due sfondi per vinci e perdi.
Dà a ciascuno sfondo un nome Symbol.
Scrive un blocco di codice per un giocatore che rileva quale carattere di sfondo il
carattere di gioco ha di fronte ed usa quell’informazione per forzare le regole del
gioco.
Figura 5-14: Gioco Corsa ad Ostacoli
Labirinto di sfondo (a sinistra)
Display “Hai vinto” (sotto a sinistra)
Display “Hai perso” (sotto a destra)
Punteggio : 000
HAI PERSO
HAI VINTO
Provate prima a giocare, e poi guarderemo con attenzione come lavora.
Programma esempio –GiocoInclinaOstacoli.bs2
Scarico gratuito! Questo programma è disponibile come scarico gratuito di file .bs2 dalla
pagina di prodotto Smart Sensors and Applications al sito www.parallax.com.
√
√
√
'
'
'
'
Aprire (o digitare) e memorizzare GiocoInclinaOstacoli.bs2.
Prima di eseguire il programma, accertatevi che la vostra scheda sia orizzontale
(livellata). Accertatevi anche che state tenendola nello stesso modo in cui lo
facevate nell’Attività 3, con la breadboard verso di voi, e il cavo seriale lontano
da voi.
Se volete rinfrescare i caratteri “$”, cliccate il pulsante Run del vostro Editor
BASIC Stamp. Se volete soltanto prendere pratica con la navigazione e non
preoccuparvi sui punti, premete e rilasciate il pulsante Reset della vostra scheda.
-----[ Titolo ]------------------------------------------------------------Sensori intelligenti e loro applicazioni - GiocoInclinaOstacoli.bs2
Inclina accelerometro per guidare cursore nel labirinto, raccoglie $
in Terminale di Debug
'{$STAMP BS2}
'{$PBASIC 2.5}
' -----[ Dati EEPROM ]-------------------------------------------------------' Memorizza sfondi in EEPROM
' 3 sfondi usati nel gioco
Maze DATA @0, HOME,
"#####################",
"######
$
########",
"##
###
###",
"#
###########
###",
"#$
#
####",
"##### #
$ #####WIN",
"#
##
## $
#",
"# $ ########### # #",
"#
##$##
# #",
"#
######## #",
"#####################",
' Sfondo labirinto
CR,
CR,
CR,
CR,
CR,
CR,
CR,
CR,
CR,
CR,
CR
YouLose DATA @243, HOME,
"#####################", CR,
"#####################", CR,
' Sfondo YouLose (HaiPerso)
"###
#######
####",
"###
#######
####",
"#####################",
"########## ##########",
"#####################",
"###
####",
"### HAI PERSO
####",
"###
####",
"#####################",
CR,
CR,
CR,
CR,
CR,
CR,
CR,
CR,
CR
YouWin DATA @486, HOME,
"
###########
",
" ################# ",
"#####
#####
#####",
"####
###
####",
"# ###
#####
### #",
"# ############### #",
"##
###########
##",
"##
##",
" #### HAI VINTO #### ",
"
####
####
",
"
#########
",
CR,
CR,
CR,
CR,
CR,
CR,
CR,
CR,
CR,
CR,
CR
' Sfondo YouWin (Hai vinto)
' -----[ Variabili ]---------------------------------------------------------x
VAR
Word
' inclin. x & y & coordinate grafiche
y
VAR
Word
indice
car
VAR
VAR
Word
Byte
' indirizzo e carattere in EEPROM
symbol
punti
VAR
VAR
Word
Byte
' Indirizzo Simbolico per DATA EEPROM
' Punti durante il gioco
' -----[ Inizializzazione ]--------------------------------------------------x = 10
' Inizia gioco carattere in centro
y = 5
DEBUG CLS
' Cancella schermo
' Visualizza labirinto.
symbol = Maze
' Pone Symbol a Maze DATA in EEPROM
READ indice + symbol, car
DEBUG car
NEXT
' Visualizza labirinto
' Visualizza sfondo alla posizione cursore.
indice = (22 * y) + x + 1
PAUSE 50
' Ottiene carattere di sfondo
' Misura inclinazione e calcola posizione cursore.
PULSIN 6, 1, x
' Ottiene Ax ed Ay
PULSIN 7, 1, y
x = (x MIN 1875 MAX 3125) - 1875 ** 1101
y = (y MIN 1875 MAX 3125) - 1875 ** 576
y = 10 - y
' Visualizza asterisco in nuova posizione.
PAUSE 50
' Nuova pausa per effetto lampeggio
' Visualizza punteggio
"Punteggio: ", DEC3 punti
' Visualizza punti
' Avete mosso l’asterisco sopra un $, W, I, N, o #?
SELECT car
' Controlla carattere sfondo
CASE "$"
' Se "$"
punti = punti + 10
' Aggiunge punti
WRITE indice, "%"
' Scrive "%" sopra "$"
CASE "#"
' Se "#", pone Symbol a YouLose
symbol = YouLose
CASE "W", "I", "N"
' Se W,I,o N, Symbol -> YouWin
symbol = YouWin
ENDSELECT
' Questa routine vi fa saltare se symbol è ancora = Maze. Se symbol
' è cambiato a YouWin o YouLose, visualizza il nuovo sfondo e termina il
' gioco.
IF (symbol = YouWin) OR (symbol = YouLose) THEN
' 242 caratteri
' Ottiene carattere
DEBUG car
' Visualizza carattere
NEXT
' Iterazione successiva
END
' Fine gioco
ENDIF
' Fine blocco codice symbol-if
LOOP
Come lavora – Da GraficoBolla.bs2 a GiocoInclinaOstacoli.bs2
Qui sono state utilizzate due caratteristiche opzionali delle direttive DATA. Ciascuno dei
tre sfondi ha ricevuto un nome Symbol, Maze, YouWin, e YouLose. Questi nomi Symbol
facilitano al programma la scelta di quale sfondo visualizzare. È stao inoltre usato
l’operatore opzionale @Address per impostare l’indirizzo EEPROM iniziale di ciascuna
direttiva. Nello sfondo di GraficoBolla.bs2, il primo carattere è CLS per cancellare lo
schermo. Il problema con il CLS in queste direttive DATA è che cancella l’intero terminale
di Debug, compreso il punteggio, che è visualizzato sotto lo sfondo. Sostituendo CLS con
HOME, l’intero sfondo può essere disegnato e ridisegnato senza cancellare il punteggio.
Maze DATA @0, HOME,
"#####################",
"######
$
########",
·
·
·
YouLose DATA @243, HOME,
"#####################",
"#####################",
·
·
·
YouWin DATA @486, HOME,
"
###########
",
" ################# ",
·
·
CR,
CR,
CR,
CR,
CR,
CR,
Verificate i Valori di Symbol
Potete provare anche comandi come DEBUG DEC YouWin per verificare che YouWin
memorizza il valore 486.
Sono state aggiunte due variabili, symbol per tenere traccia dello sfondo dal quale
reperire caratteri, e punti per tener traccia del punteggio del giocatore.
symbol
punti
VAR
VAR
Word
Byte
I valori iniziali di x ed y debbono iniziare al centro del percorso ad ostacoli. Visto che
tutte le variabili sono inizializzate a zero nel PBASIC, se ci si dimentica di inizializzarle
si ottiene che il carattere di gioco inizia all’angolo in alto a sinistra, invece che al centro.
x = 10
y = 5
La variabile symbol è impostata al valore Maze prima di eseguire il ciclo FOR…NEXT che
visualizza lo sfondo. Poiché tutte le variabili sono inizializzate a zero in PBASIC, questo
fatto accade comunque. Però, se avete inserito una direttiva DATA prima dello sfondo
Maze, sarebbe cruciale avere questa istruzione.
' Visualizza labirinto.
symbol = Maze
Il blocco di codice che segue l’inizializzazione delle variabili visualizza lo sfondo.
Osservate attentamente il comando READ. È stato cambiato da READ indice, car a
READ indice + symbol, car. Poiché la variabile symbol era stata impostata al
valore Maze, saranno visualizzati tutti i caratteri del primo sfondo. Se symbol è stata
impostata a YouLose, saranno visualizzati tutti i caratteri del secondo sfondo. Se è stata
impostata a YouWin, saranno visualizzati tutti i caratteri del terzo sfondo. Poiché
dovranno essere visualizzati sia "You Lose" sia "You Win", questa routine sarà utilizzata
ancora nel programma, più avanti.
FOR index = 0 TO 242
DEBUG car
NEXT
Tre routine devono essere aggiunte al DO...LOOP della Routine principale. La prima
visualizza semplicemente il punteggio del giocatore:
"Punteggio: ", DEC3 punti
' Visualizza punti
La seconda routine è cruciale; è una istruzione SELECT…CASE che rafforza le regole del
gioco. L’istruzione SELECT…CASE guarda il carattere di sfondo presente nella posizione
attuale dell’asterisco. Se l’asterisco è sopra uno spazio " ", l’istruzione SELECT…CASE
non deve fare alcun cambiamento, quindi il ciclo DO…LOOP della Routine principale ripete
se stesso, controllando le misure dell’accelerometro ed aggiornando la posizione
dell’asterisco. Se l’asterisco è stato mosso sopra un carattere "$", il programma deve
aggiungere 10 alla variabile punti, e scrivere un carattere "%" sopra il "$" nella
EEPROM. Ciò evita che il programma aggiunga 10 punti parecchie volte al secondo
mentre l’asterisco è mantenuto sopra il "$". Se l’asterisco è mosso sopra un "#", nella
variabile symbol viene memorizzato il simbolo YouLose. Se l’asterisco è mosso sopra
uno qualsiasi delle lettere "W" "I" or "N", nella variabile symbol viene memorizzato il
simbolo YouWin.
' Hai mosso l’asterisco sopra un $, W, I, N, o #?
SELECT car
' Controlla carattere di sfondo
CASE "$"
punti = punti + 10
WRITE index, "%"
CASE "#"
symbol = YouLose
CASE "V", "I", "N", "T", "O"
symbol = YouWin
ENDSELECT
'
'
'
'
Se "$"
Aggiunge punti
Scrive "%" sopra "$"
Se "#", pone Symbol a YouLose
' Se V,I,N,T o O Symbol -> YouWin
Mentre fate navigare il vostro asterisco sopra " ", "$", o "%", questa routine che segue
vi fa saltare perché symbol memorizza ancora Maze. L’istruzione SELECT…CASE la
cambia soltanto quando l’asterisco è stato mosso sopra "#", "V", "I", "N", "T", "O".
Ogni volta che l’istruzione SELECT…CASE cambia symbol o a YouWin o a YouLose,
questa routine visualizza lo sfondo corrispondente, poi termina il gioco.
' Questa routine vi fa saltare se symbol è ancora = Maze. Se symbol
' è cambiato a YouWin o YouLose, visualizza il nuovo sfondo e termina il
' gioco.
IF (symbol = YouWin) OR (symbol = YouLose) THEN
' 242 caratteri
' Ottiene carattere
DEBUG car
' Visualizza carattere
NEXT
' Iterazione successiva
END
' Fine gioco
ENDIF
' Fine blocco codice if-symbol
Il vostro turno – Modifiche e correzioni degli errori
Il gioco non rinfresca i simboli "$" quando rieseguite il programma con il pulsante Reset
della Board of Education. Lavora solamente quando cliccate sul pulsante Run del Editor
BASIC Stamp. Questo si verifica perché la direttiva DATA scrive soltanto nella
EEPROM quando il programma viene trasferito alla BoE. Se il programma viene
riavviato con il pulsante Reset, l’Editor del BASIC Stamp non dà la possibilità di
memorizzare gli spazi, i segni dollaro, ecc, quindi i segni percento che erano stati scritti
nella EEPROM sono ancora lì. Per correggere il problema, tutto ciò che dovete fare è
controllare ogni carattere che viene letto dalla EPROM durante l’inizializzazione. Se
quel carattere capita che sia un "%", usate il comando WRITE per cambiarlo di nuovo in
un "$".
√
√
Memorizzate GiocoInclinaOstacolo.bs2 come GiocoInclinOstacTuoTurno.bs2
Modificate il ciclo FOR...NEXT che visualizza il labirinto nell’inizializzazione
così:
FOR index = 0 TO 242
IF(car = "%") THEN
car = "$"
WRITE indice + symbol, car
ENDIF
DEBUG car
NEXT
√
' Visualizza labirinto
' <--- Aggiungere
' <--- Aggiungere
' <--- Aggiungere
' <--- Aggiungere
Verificate che sia il pulsante Run dell’Editor BASIC Stamp e il pulsante Reset
della Board of Education si comportano nello stesso modo dopo questa modifica.
Se il giocatore cambia rapidamente l’inclinazione della scheda, è possible saltare sopra i
muri di "#". Ci sono due modi per correggere questo. Si potrebbe aggiungere una
animazione di salto e chiamarla una "caratteristica". Un altro modo di correggere questo
comportamento sarebbe consentire all’asterisco di muoversi soltanto di 1 carattere sia in
direzione X, sia in Y. Per correggere questo, il programma ha bisogno di mantenere
traccia della posizione precedente. Questo è un compito assolto dalle variabili xVec ed
yVec introdotte nell’Attività #2.
√
√
Aggiungete queste dichiarazioni di variabile alla sezione Variabili nel
programma GiocoInclinOstacTuoTurno.bs2:
x
y
VAR
VAR
Word
Word
' inclinazioni x & y & coordinate
xVec
yVec
VAR
VAR
Word
Word
' <--- Aggiungere
' <--- Aggiungere
Aggiungete istruzioni che inizializzano xVec ed yVec.
x
xVec
y
yVec
√
=
=
=
=
10
10
5
5
' Inizia car di gioco in centro
' <--- Aggiungere
' <--- Aggiungere
Modificate la Routine principale in modo che x possa soltanto essere maggiore
di o minore di xVec di un incremento o decremento di 1. Ripetete per y e yVec.
y = 10 - y
' Offset Cartesiano -> Debug
IF (x > xVec) THEN x = xVec MAX 19 + 1
IF (x < xVec) THEN x = xVec MIN 1 - 1
' <--- Aggiungere
' <--- Aggiungere
IF (y > yVec) THEN y = yVec MAX 9 + 1
IF (y < yVec) THEN y = yVec MIN 1 - 1
' <--- Aggiungere
' <--- Aggiungere
' Visualizza asterisco alla nuova posizione.
PAUSE 50
' Nuova Pausa per effetto lampeggio
xVec = x
yVec = y
' <--- Aggiungere
' <--- Aggiungere
√
Eseguite e provate il vostro programma modificato e verificate che l’asterisco
non può più saltare i muri di "#".
SOMMARIO
L’Attività #1 ha introdotto i caratteri di controllo, le tecniche per mantenere i caratteri
entro i confini di un display, e l’algebra per mappare le coordinate in un display. Esempi
di caratteri di controllo hanno incluso CRSRXY e CLRDN. Esempi di confinamento in un
Display hanno incluso gli operatori MIN e MAX ed una tecnica IF…THEN. Tecniche di
mappaggio hanno incluso semplici equazioni PBASIC per cambiare i valori delle
coordinate X ed Y da Cartesiane nei loro equivalenti per il terminale di Debug.
L’Attività #2 ha introdotto un sistema per memorizzare, visualizzare e rinfrescare
l’immagine visualizzata di un carattere di sfondo preso dalla EEPROM. Questo è un
ingrediente utile per molti prodotti display, e risulta anche molto maneggevole per
display ad inclinazione e giochi. Un intero sfondo visualizzato può essere stampato con
un ciclo FOR…NEXT. Un comando READ nel ciclo permette, tramite la variabile indice
del ciclo, di indirizzare il successivo carattere nella sequenza. Dopo che il comando READ
carica nella variabile il carattere successivo, si utilizza il comando DEBUG per inviare il
carattere al terminale di Debug. Per cancellare le tracce lasciate da un carattere che si
muove sopra lo sfondo, si può memorizzare la posizione precedente del carattere in una o
più variabili. L’informazione della posizione precedente è utilizzata poi assieme al
comando READ per andare a trovare il carattere che dovrà sostituire il carattere in
movimento dopo che questo è stato mosso alla posizione successiva.
L’Attività #3 dimostra come le misure dell’accelerometro prese nel Capitolo 3 si possano
combinare con il posizionamento del cursore e con le tecniche di richiamo dei caratteri
descritte nell’Attività #2, per creare un display controllato dall’inclinazione. Per misurare
l’inclinazione dell’accelerometro lungo gli assi x ed y sono state utilizzate semplici
misure con PULSIN. I valori di inclinazione sono stati poi ridotti in scala (scalati) e
spostati (offset) tramite le tecniche introdotte nel Capitolo 3, Attività #3. I valori
modificati di x ed y hanno suggerito il posizionamento del cursore per stampare
l’asterisco nel Terminale di Debug. La posizione dell’asterisco rispetto al piano
Cartesiano, visualizzata sullo sfondo, ha rappresentato il centro della tasca di aria bollente
interna alla camera del MX2125. Man mano che l’asterisco si muoveva, lo sfondo della
sua posizione precedente era ridisegnato con le tecniche introdotte nell’Attività #2.
L’Attività #4 ha introdotto il controllo di gioco con modalità inclinazione. Si possono
implementare le regole di semplici giochi con istruzioni SELECT...CASE che usano il
carattere in sfondo nella posizione del carattere di gioco per decidere quale azione
intraprendere successivamente. In un gioco possono essere incorporati più sfondi
facendo uso dell’operatore opzionale @Address della direttiva DATA e di un nome in
Symbol. Dato che il nome in Symbol è in realtà l’indirizzo EEPROM all’inizio di una
determinata direttiva DATA, il vostro programma può aver accesso ad elementi contenuti
in sfondi diversi aggiungendo il valore di Symbol all’argomento Address del comando
READ.
Domande
1. Cosa significa HID?
2. Quale carattere di controllo fa cancellare tutte le righe sotto la posizione corrente
del cursore?
3. Quale conando e quale formattatore potete usare per memorizzare nella variabile
X una singola cifra che digitate nella finestrella di trasmissione del Terminale di
Debug?
4. Esistono altre tecniche di codifica che potete utilizzare con altri operatori per
evitare che il valore memorizzato in una variabile superi un determinato valore
massimo o minimo?
5. Quali sono le velocità di refresh (rinfresco) dei più comuni monitor CRT per
computer?
6. Che tipo di routine vi occorre per visualizzare tutti i caratteri di sfondo
memorizzati in una direttiva DATA?
7. Perchè per memorizzare valori con segno in PBASIC sono necessarie variabili
word?
8. Qando inclinate l’accelerometro sulla sinistra, in che modo si sposta la bolla di
asterischi?
9. Se le coordinate dell’asterisco originano a (-5, 0), e terminano a (5, 0), cosa
pensate che sia accaduto all’accelerometro?
10. Quale asse era il fulcro se l’accelerometro originava a (2, 2) e terminava a
(-2, 2)?
11. Se le letture dell’accelerometro viaggiano tra (0, 5) e (0, -5), quindi di nuovo
daccapo ripetutamente, qual è probabilmente la sequenza di movimento?
12. Qual’è il valore di HaiVinto(YouWin)?
13. Qualle comando potete utilizzare per controllare il valore del nome Symbol di
una direttiva DATA?
14. Se cambiate l’operatore @Address nella direttiva DATA Maze da 0 a 10, cosa
dovrete fare alle altre direttive DATA nel programma?
15. Nel programma GiocoInclinaOstacolo.bs2, che specie di blocco di codice
rinforza le regole di gioco?
16. Quale comando riporta i valori "%" di nuovo ai valori "$" nella EEPROM?
Esercizi
1. Scrivere un comando DEBUG che posiziona il cursore cinque spazi in su, sette
spazi in giù, e poi stampi il messaggio “* questa è la coordinata (5, 7) nel
terminale di Debug”.
2. Scrivere un comando DEBUG che visualizzi un sistema coordinate cartesiane da
-2 a 2 sugli assi X ed Y.
3. Calcolare la scalatura e l’offset che vi occorre per visualizzare coppie ordinate,
introdotte nella finestrella di trasmissione del terminale di Debug, in un sistema
di coordinate cartesiane che vada da -5 a 5 su entrambi gli assi X ed Y.
4. Scrivere una routine che disegni un rettangolo tramite asterischi. Questa routine
dovrebbe essere larga 15 asterischi e alta 5 asterischi.
5. Se il vostro sfondo è largo 5 caratteri e alto 3 caratteri, predire la dimensione
minima di variabile che potrete usare per impostare l’indirizzo per il vostro
comando READ e spiegare la vostra scelta. Avrete abbastanza spazio per caratteri
aggiuntivi come ad esempio CLS?
Progetti
1. Modificate TracciaCrsrXY.bs2 in modo che ridisegni lo sfondo prima di fare il
grafico con gli asterischi.
2. Modificate TracciaGraficiXY.bs2 in modo che visualizzi le coordinate
dell’asterisco posizionato più di recente a destra dell’area di grafica.
Soluzioni
Q1.
Q2.
Q3.
Q4.
Dispositivo a interfaccia umana (Human Interface Device).
CLRDN.
DEBUGIN DEC1 x.
Si, potete anche usare istruzioni IF…THEN per controllare se i valori siano o meno
fuori dei limiti.
Q5. 60, 70, e 72 Hz.
Q6. Potete usare un ciclo FOR…NEXT, con istruzioni per reperire e visualizzare ciascun
carattere memorizzato. Le variabili word memorizzaono sia il valore che il
segno.
Q7. Le variabili word memorizzano sia il valore che il segno.
Q8. La bolla si sposta verso la destra.
Q9. E’ andato da una posizione inclinata a destra ad una posizione inclinata verso
sinistra.
Q10. L’asse Y, cioè l’asse lungo della Board of Education.
Q11. Inclinando ripetutamente la scheda in alto e in basso.
Q12. Indirizzo EEPROM 486.
Q13. Quando volete visualizzare il valore di qualsiasi altra quantità numerica,
potete usare il comando DEBUG e usare il modificatore DEC.
DEBUG DEC symbol
Q14. Avrete bisogno di sommare 10 a ciascun valore symbol, in modo che il vostro
programma diventerà:
YouLose DATA @253…
YouWin DATA @496 …
Q15. Una istruzione SELECT…CASE.
Q16. Il comando WRITE.
DEBUG CRSRXY, 5, 7,
"* questa è la coordinata (5,7) nel Terminale di Debug "
DEBUG CLS,
"
2|
",
"
1|
",
"----+----",
"-2-1| 1 2",
" -2|
",
CR,
CR,
CR,
CR,
CR, CR
E3. La scalatura dell’asse X è 2 e l’offset è 10; per l’asse Y, la scalatura è -1 e
l’offset è 5.
x
y
VAR
VAR
Byte
Byte
FOR x = 1 TO 15
FOR y = 1 TO 5
NEXT
NEXT
E5. Il numero di caratteri da memorizzare è uguale a 5 x 3 = 15. La dimensione
minima di variabile da usare sarà una Nib (4 bit), con la quale l’indirizzo potrà
variare tra 0 e 15. Ci sarà spazio soltanto per un (1) carattere aggintivo.
P1. La chiave per risolvere questo problema è muovere il grafico dentro il ciclo
DO…LOOP, e cambiare CLS in HOME. Ci saranno anche altri modi per risolvere il
problema. Soluzione esempio:
DO
DEBUG HOME,
"0123456789X", CR,
"1
", CR,
"2
", CR,
"3
", CR,
"4
", CR,
"5
", CR,
"Y
", CR, CR
DEBUGIN DEC1 x
DEBUGIN DEC1 y
DEBUGIN temp
LOOP
P2. Modificate TracciaGraficiXY.bs2 in modo che visualizzi le coordinate
dell’asterisco posizionato più di recente a destra dell’area grafica. Per
visualizzare correttamente le coordinate negative, usate il modificatore SDEC.
DO
DEBUGIN SDEC1 x
DEBUGIN SDEC1 y
DEBUG CRSRXY, 15, 3, "(X,Y) = (",
SDEC x, ",", SDEC y, ")", CLREOL
x = (x * 2) + 6
y = 3 - y
DEBUGIN temp
LOOP
Capitolo 6: Progetti con l’Accelerometro · Pagina 227
Capitolo 6: Ulteriori progetti con l’Accelerometro
In questo capitolo sono illustrati tre tipi di progetti. Il primo è un’applicazione diretta
dell’hardware e dei programmi che sono stati usati nei capitoli precedenti. Il secondo
tipo richiede la registrazione dei dati sulle misure di accelerazione, e quindi molte delle
sue attività sono dedicate ad un programma di registrazione di dati. Il terzo tipo richiede
ancora la registrazione dati per calcolare quali misure sarnno prese dall’accelerometro.
Quindi, basandovi sui risultati della registrazione dati, avrete informazioni sufficienti per
scrivere un programma che renda affidabile il lavoro del dispositivo.
ATTIVITÀ #1: MISURA DELL’ALTEZZA DI EDIFICI, ALBERI, E ALTRO.
Arrampicarsi in cima ad un oggetto per misurare la sua altezza non è sempre conveniente,
pratico, o perfino sicuro. Quest’attività introduce un modo originale per utilizzare alcune
delle misure dell’accelerometro sviluppate nel Capitolo 3 per prendere misure di altezza
da un punto sul terreno di sicuro vantaggio.
Osservare la cima e determinare l’altezza
La Figura 6-1 mostra uno schema per misurare l’altezza di un oggetto, utilizzando
l’accelerometro e il display LCD per una visione da un certo angolo. Prima di tutto,
guardate la cima di un oggetto col bordo della vostra scheda, e registrate quale angolo
misurate. Quindi, misurate la distanza tra il punto dal quale avete preso la vostra misura
e l’oggetto, che è il lato adiacente mostrato in Figura 6-1. La distanza adiacente, l’angolo
θ, e l’altezza dell’accelerometro sopra il terreno sono le tre porzioni chiave di
informazione che vi occorrono per calcolare l’altezza dell’oggetto.
Figura 6-1: Determinazione dell’altezza con la Linea-di-Visione
Linea di visione
Edificio
Linea di
visione
Opposto
Altezza
oggetto
Adiacente
Altezza accelerometro
Parti Richieste
Usate l’elenco delle parti e il circuito descritti nel Capitolo 3, Attività #2 a pagina 75 e 76
per la vostra visione da un angolo.
Programma Esempio
Usate il programma esempio RotazioneVertRuota.bs2 di pagina 101 (Capitolo 3, Attività
#5) assieme alle modifiche del display LCD nel capitolo Il vostro turno - Display LCD a
pagina 102.
Procedura
√
√
√
√
Usate la vostra scheda per la visione ad angolo della cima dell’oggetto, e
registrate l’angolo.
Misurate la distanza tra punto di visione e oggetto (lato adiacente, Figura 6-1).
Misurate l’altezza alla quale è stato tenuto l’accelerometro.
Usate i calcoli introdotti qui di seguito per determinare l’altezza dell’oggetto.
Calcoli
Sappiamo dai capitoli precedenti che θ è uguale al lato opposto diviso per il lato
adiacente di un triangolo rettangolo. Moltiplicando entrambi i lati per la distanza
adiacente si ottiene una espressione per ricavare l’altezza opposta. È la distanza adiacente
moltiplicata per la tangente dell’angolo.
tan θ =
opposto
adiacente
opposto = adiacente tan θ
Dopo aver determinato l’altezza opposta (mostrata in Figura 6-1), tutto quello che
dovrete fare è aggiungere a questa l’altezza a cui avete mantenuto l’accelerometro
quando avete preso la misura.
altezza oggetto = opposto + altezza accelerome tro
altezza oggetto = adiacente tan θ + altezza accelerome tro
Esempio
Diciamo che la distanza adiacente ad un oggetto è 10 m, e a quella distanza
l’accelerometro è stato mantenuto ad 1,5 m dal terreno per ottenere la linea di visione
della cima di un oggetto. L’angolo riportato dall’unità accelerometro è stato 61°. Da
queste considerazioni, possiamo stimare che l’altezza dell’oggetto sia 19,54 m, come
mostrato qui sotto.
Distanza adiacente = 10 m
L'accelerome tro ha misurato θ = 61°
Altezza dell'accelerome tro = 1.5 m
opposto = adiacente tan θ
= 10 m tan θ
= (10 m )(1,804 )
= 18,04
altezza oggetto = opposto + altezza accelerome tro
= 18,04 m + 1,5 m
= 19,54 m
ATTIVITÀ #2: REGISTRAZIONE E RIPRODUZIONE
Nei progetti con l’accelerometro, sarà spesso necessario registrare e riprodurre grandi
quantità di misure dell’accelerometro. In alcuni casi, la funzione desiderata è registrare il
valore, come prendere i dati del modo in cui un’automobile si comporta in curva. In altri
casi, come la rilevazione del moto della camminata umana, sarà necessario comprendere
a cosa somiglino le misure prima di poter scrivere un programma che registri i passi. In
entrambi i casi, registrare e riprodurre le misure di accelerazione è ingrediente necessario.
Questa attività introduce un programma con subroutine che dimostra come registrare,
riprodurre, e cancellare valori memorizzati nella porzione non utilizzata della memoria di
programma EEPROM del BASIC Stamp.
Memorizzazione in EEPROM con istruzioni DATA, WRITE e READ
Se non sono necessarie per registrare e riprodurre dati misurati, le direttive DATA possono
essere utilizzate per mettere da parte grosse fette di memoria di programma non
utilizzate. Il nome Symbol opzionale della direttiva DATA è particolarmente utile per
prendere registrazioni. La direttiva DATA Records non memorizza realmente qualsiasi
valore negli indirizzi EEPROM da 0 a 9. Provvede soltanto a prenotare questi byte per il
vostro codice PBASIC, e dà un nome all’indirizzo del primo byte: Records. La direttiva
DATA RecordsEnd riserva un singolo byte all’indirizzo EEPROM 10.
Records
RecordsEnd
DATA
DATA
(10)
I nomi Symbol (Records e RecordsEnd) diventano costanti che memorizzano l’indirizzo
iniziale EEPROM delle direttive DATA che li seguono. La Tabella 6-1 mostra come
funziona questo fatto per le due direttive DATA. Poiché Records è la prima direttiva
DATA, mette da parte i prmi dieci byte (indirizzi da 0 a 9). Dal momento che l’indirizzo 0
è l’indirizzo iniziale, Records diventa una costante per il valore 0 nel programma.
Analogamente, poiché la direttiva RecordsEnd DATA mette da parte un byte all’indirizzo
10, RecordsEnd diventa la costante di valore 10 nel programma.
Tabella 6-1: direttive DATA e indirizzi EEPROM
Contenuti
dei Byte
00
00
00
00
00
00
00
00
00
00
00
00
Indirizzi
0
1
2
3
4
5
6
7
8
9
10
11
Records = 0
I
byte
EEPROM
RecordsEnd = 10 non
contengono
necessariamente
zero.
Con
il
comando
Records DATA (10), valori qualsiasi che siano già là non saranno modificati. Se volete
inizializzare i valori della EEPROM a zero, usate Records DATA 0 (10). Questo
comando memorizzerà 0 negli indirizzi EEPROM da 0 a 9. L’Editor BASIC Stamp fa questo
soltanto quando scarica il programma (sulla board). Se premete e rilasciate il pulsante
Reset della vostra scheda o scollegate e ricollegate l’alimentazione, nessun valore viene
scritto in questi indirizzi EEPROM. Questa è una caratteristica conveniente, come vedrete
nella prossima attività.
La subroutine Cancella_Dati del prossimo programma esempio ha un ciclo FOR...NEXT
che si ripete da Records a RecordsEnd (da 0 a 10). In ciascuna esecuzione degli ordini
dentro il ciclo, la variabile eeIndice aumenta di 1, quindi il comando WRITE
eeIndice, 100 memorizza 100 in ciascuno dei byte EEPROM, dall’indirizzo 0
all’indirizzo 10.
Cancella_Dati:
FOR eeIndice = Records TO RecordsEnd
WRITE eeIndice, 100
NEXT
DEBUG CR, "Record cancellati."
PAUSE 1000
RETURN
La subroutine Registra_Dati del prossimo programma esempio raccoglie i valori che
digitate nella finestrella di trasmissione del terminale di Debug. Nella prossima attività,
questa subroutine sarà modificata per memorizzare, invece, le letture dell’accelerometro.
Il ciclo FOR...NEXT parte di nuovo da Records e viene ripetuto finché eeIndice supera
RecordsEnd. In ciascuna ripetizione del ciclo, la variabile valore riceve un numero
decimale con segno dalla finestrella di trasmissione del terminale di Debug e lo
memorizza all’indirizzo EEPROM scelto da eeIndice con il comando
WRITE eeIndice, valore.
Registra_Dati:
DEBUG CR, "Digita valori tra -100 e 100", CR
DEBUG "Registro ", DEC eeIndice, " >"
DEBUGIN SDEC valore
valore = valore + 100
WRITE eeIndice, valore
NEXT
DEBUG CR, "Fine registrazioni.",
CR, "Premi Invio per il menu..."
DEBUGIN car
RETURN
Risparmiare spazio con valore = valore + 100
Prima che ciascun contenuto della variabile valore sia copiato in EEPROM, gli viene
aggiunto 100. Così, invece di un valore tra −100 e 100, nella EEPROM è memorizzato un
valore tra 0 e 200. Questo perché ciascuna cella di memoria EEPROM può memorizzare un
valore a dimensione byte tra 0 e 255. Memorizzare numeri negativi richiede una memoria
organizzata a dimensione word.
Potete anche memorizzare valori a dimensione word con direttive DATA se ponete il
modificatore Word prima di DataItem. Per esempio WRITE eeIndice, Word
valore. Tenete a mente che questo comando utilizza due byte EEPROM per
memorizzare il valore a dimensione word, quindi eeIndice dovrà essere incrementato di
2 prima di scrivere il valore successivo. Aggiungendo 100, abbiamo memorizzato una cella
a dimensione byte per ogni comando write.
Per reperire e visualizzare i valori memorizzati, la subroutine Visualizza_Dati ha un
ciclo FOR...NEXT con il comando READ eeIndice, valore. Poiché a ciascun valore era
stato aggiunto 100 prima che fosse memorizzato con il comando WRITE, dopo il comando
READ è sottratto 100 dalla variabile valore per riportare valore entro l’intervallo di
scala da −100 a 100.
Visualizza_Dati:
DEBUG CR, "Indice Record",
CR, "------ ------",
CR
READ eeIndice, valore
valore = valore - 100
DEBUG DEC eeIndice, CRSRX, 7, SDEC valore, CR
NEXT
DEBUG CR, "Premi Invio per il menu..."
DEBUGIN car
RETURN
Programma Esempio: MemoriaDatiEeprom.bs2
Questo programma esempio visualizza un menu a tre scelte nella finestrella di ricezione
del terminale di Debug, mostrato in Figura 6-2. Digitando C nella finestrella di
trasmissine del terminale di Debug, i valori nella EEPROM tenuti da parte per la
memoria sono cancellati. Se si digita R, il programma registra in EEPROM i valori
digitati nella finestrella di ricezione. Se si digita D, sono visualizzati i valori che erano
stati memorizzati in EEPROM.
Finestrella
di trasmissione
Digita C, R o D
C – Cancella record
R – Registra record
D – Visualizza record
>r
Digita valori da -100 a 100
Finestrella di
ricezione
Figura 6-2
Digitazione di valori
nel programma
MemoriaDatiEeprom.
bs2
Record 0 >-100
Record 1 >-75
Record 2 >-50
Record 3 >-25
√
√
√
Digitate, memorizzate, ed eseguite MemoriaDatiEeprom.bs2.
Cliccate sulla finestrella di trasmissione del terminale di Debug.
Digitate R, e quindi inserite undici valori tra −100 e 100. Premete il tasto Invio
quando viene richiesto, dopo l’undicesimo valore, per tornare al menu.
√
√
√
'
'
'
'
Digitate D e verificate che i valori che avete digitato siano visualizzati in modo
corretto. Premete il tasto Invio per tornare al menu.
Digitate C per cancellare la memoria.
Digitate D per verificare che i valori di memoria siano stati cancellati (posti a
zero).
-----[ Titolo ]------------------------------------------------------------Sensori intelligenti e loro applicazioni - MemoriaDatiEeprom.bs2
Dimostra memorizzazione, reperimento e cancellazione di valori in memoria
EEPROM.
'{$STAMP BS2}
'{$PBASIC 2.5}
' -----[ Direttive DATA]---------------------------------------------------Records
RecordsEnd
DATA
DATA
(10)
' -----[ Variabili ]---------------------------------------------------------car
eeIndice
valore
VAR
VAR
VAR
Byte
Word
Word
' -----[ Main Routine ]------------------------------------------------------DO
DEBUG CLS,
"Digita C, R o D", CR,
"C - Cancella record", CR,
"R - Registra record", CR,
"D - Visualizza record", CR,
">"
DEBUGIN car
DEBUG CR
SELECT car
CASE "C", "c"
GOSUB Cancella_Dati
CASE "R", "r"
GOSUB Registra_Dati
CASE "D", "d"
GOSUB Visualizza_Dati
CASE ELSE
DEBUG CR, "Digitazione non valida.",
CR, "Prova ancora."
PAUSE 1500
ENDSELECT
LOOP
' -----[ Subroutine - Cancella_Dati ]----------------------------------------Cancella_Dati:
WRITE eeIndice, 100
NEXT
PAUSE 1000
RETURN
' -----[ Subroutine - Registra_Data ]----------------------------------------Registra_Dati:
DEBUGIN SDEC valore
NEXT
DEBUGIN car
RETURN
' -----[ Subroutine - Visualizza_Dati ]--------------------------------------Visualizza_Dati:
CR, "------ ------",
CR
NEXT
DEBUGIN car
RETURN
Il vostro turno – Quanti byte volete memorizzare?
MemoriaDatiEeprom.bs2 usa Records e RecordsEnd per tutti i cicli che effettuano
operazioni READ e WRITE. Per tale ragione, potete cambiare il numero di valori che il
programma memorizza cambiando semplicemente il numero di elementi nella direttiva
Records DATA.
√
√
Provate a cambiare il numero di elementi che il programma memorizza da 11 a
7. Tutto ciò che dovete fare è cambiare Records DATA (10) in Records
DATA (6).
Provate e verificate che funziona.
Nell’Attività #4, useremo questa caratteristica per cambiare il numero dei record che il
programma memorizza in 1000, con il comando Records DATA (1000).
ATTIVITÀ #3: USARE LA EEPROM PER COMMUTARE TRA I MODI
Questa attività introduce un trucco di EEPROM che potete utilizzare per convertire il
pulsante Reset della Board of Education in un interruttore per la scelta tra i diversi modi
di un programma.
Codice che rende il pulsante Reset un selettore di modo
Se mettete da parte un byte della EEPROM, questo può darvi la possibilità di scegliere tra
un massimo di 256 modi diversi di programma. Nel programma esempio che segue,
useremo soltanto due modi: un modo menu, e un modo che salta, dopo un leggero ritardo,
alla registrazione dati. Ecco una direttiva DATA che dà ad un byte della EEPROM il nome
Reset, e inizializza il valore memorizzato da questo byte a zero.
Reset
DATA
0
La forma più semplice di inizializzazione è una configurazione di interruttore on/off
(acceso/spento). Ecco le istruzioni che leggono il valore del byte EEPROM Reset, gli
aggiungono 1, e quindi scrivono il valore modificato nel byte Reset. Il valore
modificato è quindi esaminato per vedere se è dispari o pari con il commando IF valore
// 2 = 0 THEN...
READ Reset, valore
valore = valore + 1
WRITE Reset, valore
IF valore // 2 = 0 THEN END
In questo esempio, se la condizione è vera, il programma termina proprio là. La volta
successiva in cui premete e rilasciate il pulsante Reset della vostra scheda, valore sarà
pari, la condizione sarà falsa, e il blocco di codice non arresterà il programma prima che
abbia raggiunto la Routine principale. Se il pulsante Reset è premuto e rilasciato ancora
una volta, il blocco di codice arresterà di nuovo il programma. La volta successiva, non
arresterà il programma, e così via. Quindi il programma utilizza il pulsante di Reset della
vostra Board of Education come un pulsante che commuta on/off.
Segue un esempio che utilizza il blocco di codice in modo diverso. Invece di arrestarlo o
consentire al programma di continuare, il blocco di codice IF...THEN è scavalcato quando
il programma viene eseguito la prima volta, quindi eseguito quando il programma viene
eseguito la seconda volta (dopo aver premuto e rilasciato il pulsante Reset). È quindi
saltato la volta successiva ed eseguito di nuovo nella volta dopo questa. L’effetto netto è
che il programma o conta in basso e salta direttamente alla subroutine Registra_Dati,
o si muove al menu principale nel programma, a seconda che il pulsante Reset della
vostra scheda sia stato premuto/rilasciato un numero dispari o pari di volte.
' -----[ Inizializzazione ]--------------------------------------READ Reset, valore
valore = valore + 1
WRITE Reset, valore
IF valore // 2 = 0 THEN
FOR car = 15 TO 0
DEBUG CLS, "Inizia registrazione Dati ", CR,
"in ", DEC2 car, " secondi",
CR, CR,
"Premi/rilascia Reset", CR,
"per tornare al menu..."
FREQOUT 4, 50, 3750
PAUSE 950
NEXT
GOTO Registra_Dati
ENDIF
Programma Esempio: MemoriaDatiEepromConReset.bs2
Questo programma mostra come usare un indirizzo in EEPROM per controllare il modo
in cui si comporta il programma, a seconda che sia stato eseguito o rieseguito un numero
dispari o pari di volte. Il numero di volte che il programma è stato eseguito sarà
controllato dal pulsante Reset, dopo lo scarico (download). Se il pulsante Reset è stato
premuto/rilasciato un numero pari di volte, il programma parte con il menu visto
nell’attività precedente. Se è stato premuto/rilasciato un numero dispari di volte, effettua
un conteggio alla rovescia, e quindi richiama la subroutine Registra_Dati.
√
√
√
'
'
'
'
Digitate ed eseguite MemoriaDatiEepromConReset.bs2.
Verificate che potete commutare il modo di avvio del programma premendo e
rilasciando il pulsante Reset.
Provate le caratteristiche del programma, e accertatevi che funzionino tutte.
-----[ Titolo ]------------------------------------------------------------Sensori intelligenti e loro applicazioni - MemoriaDatiEepromConReset.bs2
Mostra memorizzazione, reperimento e cancellazione di valori in memoria
EEPROM.
'{$STAMP BS2}
'{$PBASIC 2.5}
' -----[ Direttive DATA]---------------------------------------------------Reset
Records
RecordsEnd
DATA
DATA
DATA
0
(10)
' -----[ Variabili ]---------------------------------------------------------car
eeIndice
valore
VAR
VAR
VAR
Byte
Word
Word
' -----[ Inizializzazione ]--------------------------------------READ Reset, valore
valore = valore + 1
WRITE Reset, valore
FOR car = 15 TO 0
DEBUG CLS, "Inizia registrazione Dati ", CR,
CR, CR,
"per il menu..."
FREQOUT 4, 50, 3750
PAUSE 950
NEXT
GOTO Registra_Dati
ENDIF
' -----[ Routine principale]-------------------------------------------------DO
DEBUG CLS,
"Premi/Rilascia Reset per ", CR,
"avviare registrazione dati ", CR, CR,
" - oppure - ", CR, CR,
">"
DEBUGIN car
DEBUG CR
SELECT car
CASE "C", "c"
GOSUB Cancella_Dati
CASE "R", "r"
GOSUB Registra_Dati
CASE "D", "d"
CASE ELSE
CR, "Prova di nuovo."
PAUSE 1500
ENDSELECT
LOOP
WRITE eeIndice, 100
NEXT
PAUSE 1000
RETURN
' -----[ Subroutine - Registra_Dati ]----------------------------------------Registra_Dati:
DEBUGIN SDEC valore
NEXT
DEBUGIN car
RETURN
' -----[ Subroutine - Visualizza_Dati ]-------------------------------------Visualizza_Dati:
CR, "------ ------",
CR
NEXT
DEBUGIN car
RETURN
Il vostro turno – L’indirizzamento automatico in EEPROM della direttiva DATA
Avevate notato che i numeri dei record cambiavano in questo programma? Invece che da
0 a 10, essi andavano da 1 a 11. Provate a spostare la direttiva Reset DATA dopo le altre
due. Dopo, eseguite il programma modificato ed esaminate il risultato. Fate tabelle simili
alla Tabella 6-1 che mostra i valori memorizzati da Reset, Records, e RecordsEnd.
Fate la prima tabella per illustrare il programma originale, e la seconda per illustrare il
programma modificato in cui avete cambiato l’ordine delle direttive DATA.
ATTIVITÀ #4: REGISTRAZIONE DATI REMOTA DELL’ACCELERAZIONE
In questa attività, aggiungerete un altoparlante piezo al circuito esistente
dell’accelerometro. Poi, modificherete il programma in modo che vi fornisca uno
strumento di registrazione remota dei dati facile da far funzionare. L’altoparlante piezo
sarà comodo per indicare il conto alla rovescia, l’avvio e l’arresto. Il circuito
dell’accelerometro sarà quello utilizzato nel Capitolo #3, e l’altoparlante piezo sarà
aggiunto sotto di esso sulla breadboard.
Parti Richieste
(1) Accelerometro Memsic 2125
(2) Resistenze da 220 Ω
(1) Altoparlante piezo
Circuito
√
Costruire i circuiti dell’accelerometro e dell’altoparlante piezo mostrati in Figura
6-3.
Figura 6-3
Schema elettrico (a sinistra) e
Diagramma di Cablaggio (qui sotto)
dell’Accelerometro e dell’altoparlante
Piezo
Modifiche al programma
Il successivo programma esempio, RegDatiDiAccelerazione.bs2, è un ampliamento di
MemoriaDatiEepromConReset.bs2. È stato modificato in modo che potete avviare,
fermare e far ripartire la registrazione dei dati col pulsante Reset della vostra scheda.
Potete scollegare la scheda dal vostro computer per effettuare la registrazione dati, e
ricollegarlo per visualizzare le misure nel terminale di Debug. Questa è una caratteristica
cruciale per prelevare misure sul campo e poi visualizzarle più tardi.
RegDatiDiAccelerazione.bs2 ha una sezione Inizializzazione modificata che fa emettere
un bip al piezo altoparlante una volta al secondo per dieci secondi prima di iniziare
registrare i dati.
' -----[ Inizializzazione ]-------------------------------------------Init:
.
.
.
FOR char = 10 TO 0
.
.
.
FREQOUT 4, 50, 3750
PAUSE 950
NEXT
.
.
.
RegDatiDiAccelerazione.bs2 ha inoltre una subroutine Registra_Dati modificata che
ottiene i valori di x ed y dall’accelerometro, li riduce alla scala (-100, 100), e li scrive
entrambi nella EEPROM. Il ciclo FOR...NEXT è incrementato in passi di 2 con
l’argomento STEP 2 poiché, ogni volta che esegue il ciclo, la routine memorizza due
byte. La subroutine Visualizza_Dati ha modifiche analoghe per visualizzare in una
tabella entrambi i valori x ed y.
Registra_Dati:
FREQOUT 4, 75, 4000
PAUSE 200
FREQOUT 4, 75, 4000
DEBUG CLS, "In registrazione..."
FOR eeIndice = Records TO RecordsEnd STEP 2
PULSIN 6, 1, x
PULSIN 7, 1, y
x = (x MIN 1875 MAX 3125) - 1875 ** 10538
y = (y MIN 1875 MAX 3125) - 1875 ** 10538
WRITE eeIndice, x
WRITE eeIndice + 1, y
NEXT
FREQOUT 4, 200, 4000
DEBUG CR, "Fine dei record.",
DEBUGIN car
RETURN
Inoltre l’altoparlante piezo fa due bip con tono più alto proprio all’inizio della
registrazione dati. Una caratterstica importante di questo conto alla rovescia di dieci
secondi è che potete fermare la registrazione dati prima che inizi, semplicemente
premendo e rilasciando il pulsante Reset della vostra scheda. Poi, per riavviare il conto
alla rovescia, vi basta premere e rilasciare di nuovo il pulsante Reset.
Programma esempio: RegDatiDiAccelerazione.bs2
Scarico gratuito! Questo programma è disponibile come file .bs2 di libero scarico dalla
pagina di prodotto “Smart Sensors and Applications” al sito www.parallax.com.
Questo programma effettua e memorizza 500 misure sugli assi x ed y dell’accelerometro
in circa 15 secondi. Ciò equivale a una frequenza di campionamento di circa 33 misure
al secondo. E’ una buona situazione per una grande varietà di misure. Per misurare
processi più lunghi e più lenti, la subroutine Registra_Dati può essere rallentata con
un comando PAUSE.
√
√
√
√
√
√
Aprite ed eseguite RegDatiDiAccelerazione.bs2.
Cliccate la finestrella di trasmissione del terminale di Debug.
Digitate R per iniziare a registrare, inclinate il vostro accelerometro a questo
modo e fatelo per quindici secondi.
Quando vi è richiesto, premete Invio per tornare al menu del programma.
Digitate D per visualizzare le misure. Rivedetele e verificate che corrispondano
a come avete inclinato l’accelerometro.
Scollegare la vostra scheda dal cavo seriale. Se inizia a fare bip appena lo fate,
premere e rilasciare il pulsante reset per fermare il programma.
Quando siete pronti a iniziare ad inclinare l’accelerometro per quindici secondi, premete
e rilasciate il pulsante Reset. La registrazione dei dati farà bip per un conteggio alla
rovescia di dieci secondi, quindi terminerà con due bip di tono più alto che segnalano
l’inizio della registrazione dati. Alla fine della registrazione, verrà eseguito un solo bip di
tono più alto.
√
√
√
√
√
Premete e rilasciate il pulsante reset. Aspettare per dieci secondi, poi inclinate il
vostro accelerometro in una sequenza che possiate ricordare, per 15 secondi.
Collegate di nuovo il vostro accelerometro al vostro computer. Se inizia a fare
bip, premete e rilasciate il pulsante reset per fermare il conto alla rovescia.
Cliccate il pulsante Run dell’Editor del BASIC Stamp per scaricare il
programma nel BASIC Stamp e rinfrescare la visualizzazione del Menu del
terminale di Debug.
Digitate D per visualizzare le misure dei dati registrati.
Confrontatele con le direzioni in cui avete inclinato la scheda e assicuratevi che
corrispondano.
' -----[ Titolo ]------------------------------------------------------------' Sensori intelligenti e loro applicazioni - RegDatiDiAccelerazione.bs2
' Registra i dati di 500 misure di accelerazione sugli assi x ed y.
'{$STAMP BS2}
'{$PBASIC 2.5}
' -----[ Direttive DATA ]---------------------------------------------------Reset
Records
RecordsEnd
DATA
DATA
DATA
0
(1000)
' -----[ Variabili ]---------------------------------------------------------car
eeIndice
valore
x
y
VAR
VAR
VAR
VAR
VAR
Byte
Word
Word
valore
Word
' -----[ Inizializzazione ]--------------------------------------------------Init:
READ Reset, valore
valore = valore + 1
WRITE Reset, valore
FOR car = 10 TO 0
DEBUG CLS, "Inizio registrazione dati ", CR,
CR, CR,
"Premere/rilasciare Reset", CR,
"per tornare a menu..."
FREQOUT 4, 50, 3750
PAUSE 950
NEXT
GOSUB Registra_Dati
ENDIF
DEBUG CLS,
"Premere/Rilasciare Reset", CR,
"per armare la registrazione dati ", CR, CR,
"Digitare C, R o D", CR,
"D – Visualizza record", CR,
">"
DEBUGIN car
DEBUG CR
SELECT car
CASE "C", "c"
GOSUB Cancella_Dati
CASE "R", "r"
GOSUB Registra_Dati
CASE "D", "d"
CASE ELSE
PAUSE 1500
ENDSELECT
LOOP
DEBUG CR, "Sto cancellando..."
WRITE eeIndice, 0
NEXT
PAUSE 1000
RETURN
FREQOUT 4, 75, 4000
PAUSE 200
FREQOUT 4, 75, 4000
DEBUG CLS, "Sto registrando..."
PULSIN 6, 1, x
PULSIN 7, 1, y
x = (x MIN 1875 MAX 3125) - 1875 ** 10538
y = (y MIN 1875 MAX 3125) - 1875 ** 10538
WRITE eeIndice, x
NEXT
FREQOUT 4, 200, 4000
DEBUGIN car
RETURN
DEBUG CR, "Indice asse x asse y",
CR, "------ ------ ------",
CR
READ eeIndice, x
x = x - 100
READ eeIndice + 1, y
y = y - 100
DEBUG DEC eeIndice, CRSRX, 7, SDEC x, CRSRX, 14, SDEC y, CR
NEXT
DEBUGIN car
RETURN
Il vostro turno – Registrazione dati come angoli di rotazione
Il capitolo 3, Attività #5 ha introdotto le misure di rotazione verticale con
l’accelerometro. Dal momento che i radianti binari sono valori tra 0 e 255, potete
memorizzare una singola misura di angolo in un byte EEPROM. Questo raddoppierà il
numero di misure che l’applicazione potrà acquisire. Occorrono soltanto poche modifiche
a RegDatiDiAccelerazione.bs2 per fargli memorizzare l’angolo di rotazione. Ecco come:
√
√
√
√
Memorizzate RegDatiDiAcclerazione.bs2 col nome RegDatiAngolo.bs2.
Aggiornate i commenti nella sezione Titolo.
Rimuovete l’argomento STEP 2 dai cicli FOR...NEXT nelle subroutine
Registra_Dati e Visualizza_Dati.
Nella subroutine Registra_Dati, sostituite questi due comandi WRITE:
WRITE eeIndice, x
...con questa operazione ATN e quest’altro commando WRITE:
valore = x ATN y
√
Modificate la testata della visualizzazione nella subroutine Visualizza_Dati
in modo che sia come questa:
DEBUG CR, "Indice
CR, "-----CR
√
angolo ",
------ ",
Sostituite questi quattro comandi:
READ eeIndice, x
x = x - 100
READ eeIndice + 1, y
y = y - 100
...con questi due:
valore = valore */ 361
√
Memorizzate i vostri cambiamenti e provate il programma modificato.
ATTIVITÀ #5: STUDIO DELL’ACCELERAZIONE DI UN’AUTOMOBILE RC
Questa attività mostra come si usa il programma RegDatiDiAccelerazione.bs2
dell’attività precedente per analizzare le forze di accelerazione agenti su un’automobile
radiocomandata (RC) durante una serie di manovre. Quest’attività mostra inoltre come si
possano utilizzare i dati registrati delle forze di accelerazione per registrare e
diagrammare velocità e posizione dell’automobile. Sebbene l’apparecchiatura reale e i
calcoli siano un pò complicati, ricavare la posizione da misure consecutive di
accelerazione è una componente dei sistemi di guida inerziale utilizzati su razzi e navi
spaziali. Questi sistemi usano una combinazione della versione a 3 assi delle misure di
accelerazione trattate in questa attività, assieme ai giroscopi che misurano la rotazione di
un veicolo.
Parti, apparecchiature e diagrammi circuitali
In aggiunta alle parti elencate nell’Attività #4, vi occorrerà una automobile
radiocomandata RC e il relativo telecomando, non inclusi nel kit “Smart Sensors and
Applications”. I diagrammi circuitali da costruire sulla vostra scheda sono all’inizio
dell’Attività #4 in questo capitolo.
Componenti fisici e messa a punto iniziale
La Figura 6-4a mostra un’automobile RC molto economica acquistabile in molti negozi
di hobbistica (o modellismo) e di elettronica al dettaglio. La Figura 6-4b mostra come
montare la scheda. Sul lato inferiore della scheda sono già stati applicati i piedini di
gomma per prevenire il contatto delle connessioni elettriche con qualsiasi parte metellica
o elettrica dell’automobile RC. Sarà anche possibile usare nastro bi-adesivo per fissare la
scheda al tetto di plastica della carrozzeria. La scheda è orientata con la breadboard verso
la parte anteriore dell’auto.
Figura 6-4: Automobile RC con registratore di dati di Accelerazione
a.
b.
Evitate corti circuiti occasionali. Accertatevi che la vostra scheda sia montata
sull’automobile in modo che la parte metallica esposta sottostante la scheda non abbia
alcun modo di venire a contatto con qualsiasi parte metallica dell’automobile RC o con
connettori elettrici.
Come funziona
La Figura 6-5 mostra un grafico delle misure lungo l’asse y dell’accelerometro mentre
l’automobile accelera in avanti, rallenta fino a uno stop, e poi accelera all’indietro. Le
misure sono state acquisite con il programma RegDatiDiAccelerazione.bs2 della Attività
#4. Dopo averle visualizzate nel Terminale di Debug, esse sono state oscurate, copiate ed
incollate nel Blocco Note di Windows. Da qui, sono state importate nel programma
foglio elettronico Microsoft Excel e poi diagrammate.
Accelera
indietro
Decelera
RC Car Forward and Backward
30
20
gravity/100
10
0
0
50
100
150
200
250
-10
-20
-30
Stop
300
Figura 6-5
Misure sull’asse Y
dell’Accelerometro per
una automobile RC
-40
seconds/30
Accelera
avanti
Decelera
Il motivo per cui l’accelerazione in avanti è negativa è che l’asse ym sensorio è orientato
verso la parte posteriore dell’auto RC come mostrato in Figura 6-6. Quindi, mentre
l’automobile sta accelerando in avanti, l’accelerazione è negativa. Quando una macchina
rallenta, in realtà sta accelerando all’indietro. Questo fatto è mostrato in Figura 6-5.
Dapprima, l’automobile accelera in avanti, poi gli si applicano i freni e viene rallentata
(decelerata). La misura di y era positiva, quindi l’accelerazione era negativa. Dopo un
breve arresto, l’automobile ha accelerato all’indietro. Si noti che la y è di nuovo positiva.
Quindi, quando l’auto rallenta (decelera) dalla sua velocità all’indietro per fermarsi di
nuovo, l’automobile, in effetti, sta accelerando in avanti, e la misura y è di nuovo
negativa.
Accelerazione
a = xm
Parte anteriore
Parte anteriore
Figura 6-6
Accelerazione
dell’automobile RC vs
Asse sensorio
dell’Accelerometro
Accelerazione
a = ym
a.
b.
Se state guidando un’automobile, quando accelera in avanti, potete sentire il sedile che vi
spinge in avanti. Bene, se fate una curva brusca a destra, il lato sinistro dell’auto vi
spingerà a destra. Ciò avviene perché state accelerando verso destra mentre fate la curva.
Lo dimostra la Figura 6-7, che mostra un oggetto che sta marciando in avanti a velocità
costante, e per farlo girare, dovrà sempre essere accelerato verso il centro del cerchio
entro il quale sta marciando.
Figura 6-7
Marcia in cerchio
Questo fatto produce
accelerazione continua
verso il centro.
La Figura 6-8 mostra un grafico della misura sull’asse x dell’accelerometro quando
l’automobile RC è guidata prima in cerchi che girano a sinistra, poi in cerchi che girano a
destra. Notate come la misura sull’asse x mostra accelerazione positiva mentre l’auto RC
gira verso sinistra, e accelerazione negativa mentre l’auto gira a destra.
Cerchi
in senso
Left Turn
sinistro
Marcia
Straighten
rettilinea
Out
Circles
RC Car Left then Right
60
40
gravity/100
20
0
0
100
200
300
400
-20
-40
-60
-80
500
600
Figura 6-8
Misure con
l’Accelerometro di
un’automobile RC
mentre si guida in cerchi
-100
seconds/30
Cerchi
in senso
destro
La Figura 6-9 mostra com’è orientato l’asse x dell’accelerometro, e l’accelerazione che
misura. Per una curva a sinistra, l’automobile sta accelerando a sinistra, e questa per
l’accelerometro è una misura di accelerazione positiva sull’asse x. Quando si gira a
destra, l’accelerazione è nella direzione opposta all’asse x positivo, quindi la misura
lungo l’asse x è negativa.
Figura 6-9: Sentire l’accelerazione durante le curve
Anteriore
Anteriore
Accelerazione
a = - xm
Accelerazione
a = +xm
a.
b.
Procedura
La procedura per misurare e poi riportare in grafico l’accelerazione dell’automobile RC è
la seguente.
√
√
√
√
√
√
√
√
Attaccate sull’automobile RC la vostra scheda.
Scaricate RegDatiDiAccelerazione.bs2 nel BASIC Stamp.
Ponete l’automobile sul terreno in una zona libera e premete/rilasciate il pulsante
Reset della vostra scheda.
Aspettate che il conto alla rovescia dica che la registrazione dati è stata avviata.
Guidate l’auto facendo queste manovre, in circa 15 secondi:
o Accelerate l’auto in avanti, poi fermatevi.
o Accelerate l’auto all’indietro, poi fermatevi.
o Guidate in modo da fare la figura di un otto.
Quando la scheda fa di nuovo un bip (dopo circa quindici secondi) significa che
la registrazione dati è terminata. Collegate la scheda da capo al vostro PC.
Eseguite di nuovo RegDatiDiAccelerazione.bs2.
Cliccate sulla finestrella di trasmissione del Terminale di Debug.
√
√
√
√
√
√
Digitate D per visualizzare i dati.
Usate il mouse per coprire le intestazioni della tabella e tutte le misure nella
finestrella blu di ricezione del Terminale di Debug. (Non coprite il menu.)
Premete CTRL + C per copiare le registrazioni.
Aprite Blocco Note.
Cliccate Modifica e scegliete Incolla.
Memorizzate il file.
Le istruzioni che seguono spiegano come importare il file .txt entro Microsoft Excel 2002
e trasformarlo in grafico. Se state utilizzando un altro programma foglio elettronico, le
parole chiave come delimitatore spazio, grafico diffuso XY possono fornire indicazioni
su come effettuare le stesse operazioni con il vostro software foglio elettronico specifico.
√
√
√
√
√
√
√
√
In Excel, cliccate File e scegliete Apri.
Nel campo Tipi di file, scegliete Tutti i file (*.*).
Trovate il file .txt che avete memorizzato col Blocco Note, sceglietelo, e cliccate
il pulsante Apri.
Nel Passo 1 del Wizard Importa Testo, cliccate il pulsante di scelta Delimitato,
poi cliccate Successivo.
Cliccate la finestrina di fianco alla scritta Spazio per indicare che il file è
delimitato da spazi.
Assicuratevi che sia anche selezionata la checkbox "Tratta i delimitatori
consecutivi come uno solo ", poi cliccate Successivo.
Assicuratevi che sia scelto il pulsante di scelta formato colonna dati Generale,
poi cliccate Fine.
Il vostro foglio elettronico dovrebbe essere largo tre colonne e lungo circa 503
righe.
Il passo successivo, anch’esso documentato per Microsoft Excel 2002, è quello di
eseguire la utility “Creazione guidata grafico” e comunicarle i dati da portare nel grafico
e il tipo di grafico.
√
√
√
Ponete il cursore su una cella un pò a destra delle vostre tre colonne di dati.
Cliccate su Inserisci e scegliete Diagramma.
Nella scheda Tipi di Grafico, scegliete XY (Dispers…). Cliccate poi il grafico
che lo configura come "Dispersione con coordinate unite da linee smussate e
senza indicatori di dati ". Poi, cliccate Avanti.
√
√
√
Supponendo che i vostri dati sull’asse y iniziino in C3 e finiscano in C503,
digitate C3..C503 nella finestrella Intervallo Dati. Cliccate il pulsante vicino a
Colonne per indicare che la serie di punti dato è in una colonna. Poi, cliccate
Avanti.
Riempite il titolo del grafico e le informazioni sull’asse, poi cliccate Fine.
Ripetete per l’asse x.
Soltanto parti del grafico sono importanti. Tenete in mente che i dati significativi per
l’asse y riguardano gli intervalli di tempo in cui l’automobile accelera in avanti e indietro.
Analogamente, la parte di grafico significativa per l’asse x è la porzione in cui l’automobile fa
una curva.
Grafico della posizione e della velocità dell’automobile
Se conoscete la posizione e la velocità iniziali di un oggetto, potete usare l’accelerazione
durante un periodo di tempo per calcolare la sua posizione. Questi calcoli si possono fare
ripetutamente all’interno di un foglio elettronico per diagrammare la velocità e il percorso
dell’automobile RC.
Scaricate il Foglio Elettronico (Spreadsheet). I fogli elettronici MS Excel utilizzati per fare
questi diagrammi sono disponibili per essere scaricati dalle pagine prodotto “Smart Sensors
and Applications” al sito www.parallax.com. Scaricate i fogli elettronici ed esaminate le
equazioni nelle varie colonne assieme alle impostazioni per ciascun diagramma.
Ad esempio, il diagramma dell’accelerazione in Figura 6-10 mostra un grafico della
automobile RC mentre accelera in avanti e all’indietro. (Il foglio elettronico è stato
modificato in modo che i valori positivi indicano l’accelerazione in avanti e i valori
negativi indicano quella all’indietro o decelerazione.) Quindi, questo grafico mostra che
l’automobile ha accelerato in avanti ad una media di circa 0,16 g per un po’ meno di 2
secondi. Poi, ha decelerato ad una media di circa 1,4 g per un po’ più di 2 secondi. Poi si
è fermata per circa 1 secondo. Dopo questa sosta, ha accelerato all’indietro, e poi ha
decelerato (accelerato in avanti) fino ad un secondo stop.
Figura 6-10: Grafico modificato dell’accelerazione con accelerazione positiva nel moto in
avanti
gravità/100
Accelerazione dell’auto RC in avanti e indietro
secondi/30
Scelta dei dati per il grafico. Cliccate col pulsante destro sulla linea del Diagramma col
titolo "accelerazione dell’auto RC in avanti e indietro” Quindi scegliete i dati sorgente e
cliccate la linguetta Serie. Notate che la serie da portare in grafico va da F229 a F492.
Questa è la seconda di due prove avanti/indietro eseguite durante la sessione di
registrazione dati. La stessa cosa vale per i grafici di Velocità e Posizione.
Al foglio elettronico è stata aggiunta una colonna con una equazione che calcola la
variazione di velocità per ciascuna misura di accelerazione. L’equazione per la velocità
in linea retta è v = v0 + at. Cioè la velocità iniziale (v0) più il prodotto dell’accelerazione
(a) per la durata di quell’accelerazione (t). Sommando al foglio elettronico una colonna
che ricalcola la velocità per ciascuna misura di accelerazione si rende possibile fare il
diagramma della velocità mostrato in Figura 6-11. Come ci si aspettava, quando
l’automobile accelera in avanti, la sua velocità aumenta. Poi, quando rallenta, la sua
velocità diminuisce.
Quando accelera all’indietro, la sua velocità diminuisce
ulteriormente (aumenta in direzione negativa). Poi, quando rallenta il suo movimento
all’indietro, la sua velocità ritorna quasi a zero.
Figura 6-11: Grafico della velocità dedotto dai dati di posizione iniziale e accelerazione
velocità
(m/sec)
Accelerazione dell’auto RC in avanti e indietro
secondi/30
I calcoli per questo grafico sono stati fatti nella colonna F del foglio elettronico. Se
cliccate sulla cella F-17 nel foglio elettronico, nel campo funzione dovrebbe apparirvi
questa equazione:
=F16 + (0,03*9,8*E17/100)
In questo caso, F16 è la cella propro sopra la F17, e contiene la velocità precedente.
Questa velocità precedente è utilizzata come valore di V0 per l’intervallo campione. 0,03
è t, l’intervallo di tempo tra i campioni, e 9,8 * E17 / 100 porta con sé la misura in E17,
che è espressa in centesimi di g e la converte in metri per secondo2 (m/s2). Dividendo per
100 si ottiene un valore da centesimi di un g di nuovo a g e quindi, moltiplicando per 9,8
si converte da g a m/s2. Questo perché 1 g è circa 9,8 m/s2.
Con le colonne del foglio elettronico contenenti accelerazione e velocità, è ora possible
tenere anche traccia della posizione dell’automobile utilizzando l’equazione s = s0 + v0t +
1
/2 at2. Cioè, la posizione dell’automobile (s) è uguale alla posizione iniziale (s0) più il
prodotto della velocità iniziale per il tempo (v0t), più metà del prodotto dell’accelerazione
per il quadrato del tempo (1/2 at2). Il grafico risultante della posizione mostrato in Figura
6-12 è sorprendentemente preciso. L’automobile ha realmente marciato in avanti per
circa 3,5 metri prima di arrestarsi. Poi, ha indietreggiato e si è fermata quasi un metro
dietro il punto dove è partita.
Figura 6-12: Grafico della posizione ricavato dai dai di posizione iniziale, velocità iniziale ed
accelerazione
Posizione auto RC – Marcia avanti e indietro
Distanza, m
secondi/30
L’equazione che calcola la posizione nella cella G17 è:
=G16+(F16*0,03)+((0,5*E17*9,8/100)*(0,03^2))
dove G16 è la posizione dopo il campione precedente, che è S0, la posizione iniziale.
F16*0,03 è v0t, la velocità iniziale moltiplicata per il tempo. E il termine
(0,5*E17*9,8/100)*(0,03^2) è 1/2 at2, dove t è ancora una volta 0,03 secondi.
Mentre questa tecnica è molto precisa su brevi periodi di tempo, un certo errore si
inserisce in ciascuna misura, portato da molte sorgenti. Le superfici scabre e la
vibrazione possono inficiare le misure di accelerazione. Inoltre, mentre le equazioni
assumono che l’accelerazione tra ciascuna misura rimanga costante, in molti casi
l’accelerazione cambierà durante gli intervalli di tempo tra i campioni. Inoltre, ogni
misura dell’accelerometro tenderà ad essere leggermente (per una piccola percentuale)
fuori a causa della natura del MX2125. Il foglio informativo del MX2125 (disponibile sul
sito web del Memsic - www.memsic.com) spiega questi errori, tra cui i più grandi sono
gli errori di offset zero e di sensibilità. Questi errori variano da un chip all’altro, e sono
anche influenzati dalla temperatura. Assumere misure precise con il MX2125 comporta
l’uso di un convertitore A/D, un coprocessore per virgola mobile, e una raccolta dati da
prove di taratura. Questa procedura di taratura esula dagli scopi di questo testo. Per
sapere di più su questo argomento, consultate la pubblicazione #AN-00MX-002 Thermal
Acceleromters Temperature Compensation, disponibile sul sito web del Memsic.
Il vostro turno – Registrazione di accelerazione/velocità/posizione della vostra
automobile RC
Come detto prima, i fogli elettronici MS Excel utilizzati per disegnare questi grafici sono
disponibili per essere scaricati dalle pagine prodotto “Smart Sensors and Applications” al
sito www.parallax.com. Scaricate i fogli elettronici ed esaminate le equazioni nelle varie
colonne assieme alle impostazioni per ogni diagramma. Poi, sperimentate il disegno di
grafici con dati raccolti dalla vostra automobile RC. Qualsiasi gruppo di dati voi
riportate in grafico dovrebbe iniziare da una posizione nota, con l’automobile ferma. In
quel modo conoscete la posizione iniziale (s0) e, cosa più importante, la velocità iniziale,
v0 è 0 m/s.
ATTIVITÀ #6: STUDIO DEL TRUCCO DI ACCELERAZIONE DI UNO
SKATEBOARD
Questa attività osserva un secondo esempio di studio dell’accelerazione. Questo esempio
registra i dati di un trucco dello skateboard chiamato Ollie. L’impostazione per la
registrazione dati del Ollie mostrata in Figura 6-13 è una scheda BASIC Stamp
HomeWork condotta, attaccata con nastro adesivo alla parte inferiore di uno skateboard.
Questa attività è stata inserita qui soltanto a scopo illustrativo – il lettore non si
aspetti di ottenerla davvero su uno skateboard! Questo è soltanto un esempio di come
il lettore potrebbe usare l’accelerometro per studiare movimenti con attività dei suoi sport o
hobby preferiti; l’autore è casualmente un utente di skateboard. Con tutte le vostre
applicazioni BASIC Stamp, usate il buon senso e apposite attrezzature di protezione, e
potrete condurre esperimenti a vostro rischio (si veda la clausola Scarico di Responsabilità
nel retro della pagina di titolo del manuale).
Figura 6-13: Scheda BASIC Stamp HomeWork condotta-fissata con nastro adesivo allo
Skateboard dell’Autore
Sul trucco Ollie
Il primo Ollie documentato è stato fatto da Alan (Ollie) Gelfand nel lontano 1970.
Gelfand è stato un pioniere di questo trucco su rampe e buche. La versione per
terraferma del Ollie è stata evoluta nel lontano 1980. Quando un pattinatore fa un Ollie,
egli salta, e sembra come se il suo pattino sia attaccato ai suoi piedi, anche se non lo è
affatto. Indipendentemente dal terreno o dallo stile di pattinaggio, la maggior parte dei
trucchi odierni di skateboard sono variazioni del Ollie.
Meccanica del Ollie
La Figura 6-14 mostra la meccanica di un Ollie. Quando il pattinatore salta, (a) i suoi
piedi spingono entrambi il pattino in basso. Appena prima che il pattinatore sia in aria,
(b) egli solleva il suo piede anteriore e allo stesso tempo estende il piede posteriore verso
la punta delle dita, e la coda del pattino bacia il cemento. Il momento (meccanico) della
parte anteriore del pattino lo fa salire (c), e il pattinatore adesso solleva il suo piede
posteriore, e spinge il suo piede anteriore in avanti. Questo fa sollevare la parte posteriore
del pattino in alto (d), e lo muove leggermente in avanti. Quando il piano del pattino
incontra il piede posteriore del pattinatore (e), il pattinatore applica una pressione
sufficiente a mantenere il pattino contro i suoi piedi e il pattino ricade di nuovo a terra (f).
L’Ollie più alto mai eseguito, effettuato da Danny Wainwright, ha raggiunto un’altezza
superiore a cinque piedi (un metro e mezzo circa).
Figura 6-14: Meccanica del Ollie
Riportare in grafico l’accelerazione del Ollie
La Figura 6-15 mostra un grafico dell’asse y dell’accelerometro per il primo dei due Ollie
registrati con il successivo programma esempio. Ciascuno dei passi della Figura 6-14 è
contrassegnato sul grafico.
Accelerazione in funzione del tempo per il primo ollie
Acceleration vs Time for First Ollie
3.5
f
3
2.5
gravità (g)
2
1.5
1
0.5
0
170
-0.5
190
210
230
250
270
Figura 6-15
Accelerazione
durante un
Ollie
-1
-1.5
tempo (ms)
a, b
c, d e
Questo primo Ollie era un pò carente nei passi b e c di Figura 6-14, così che la parte
posteriore della scheda non incontrava proprio il piede posteriore nel passo e. Notate che
l’impatto della scheda durante il passo f era di 3,5 g. Gli alti e bassi che seguono il passo
f somigliano alle oscillazioni di quando si colpisce una campana. La ragione di questo
fatto è in parte dovuta alle vibrazioni della scheda e in parte alla turbolenza del gas dentro
l’accelerometro provocata dall’impatto.
La Figura 6-16 mostra i dati per un Ollie leggermente migliore. È stato un Ollie un pò
più alto, ed ha portato ad un passo eseguito con maggior grazia. Notate che i passi da a a
b sono più ripidi, e portano a -1,25 g prima di risalire fino a più di 1 g per i passi c e d.
Questi valori, che sono più grandi di quelli del grafico precedente, indicano un Ollie più
alto. Notate anche che l’impatto è stato sotto 3 g, perché il pattinatore non stava tentando
di saltare con il pattino che puntava in basso.
Accelerazione vs Tempo per il secondo Ollie
3.5
3
gravità, (g)
f
2.5
2
1.5
1
0.5
0
775
-0.5
795
815
835
855
875
-1
Figura 6-16
Grafico di un Ollie
leggermente
migliore
-1.5
tempo (ms)
a, b
c, d
e
Registrazione dei dati di un Ollie
La Figura 6-17 mostra come sia allineato l’asse y di sensibilità dell’accelerometro per
sentire le varie inclinazioni e rotazioni dello skateboard. Questo è l’unico asse che
vogliamo registrare nel programma esempio che segue.
Asse x
Ava
nti
Asse y
Figura 6-17
Assi di sensibilità
dell’accelerometro
sullo Skateboard
Il programma originario dell’attività #4 è stato modificato per memorizzare proprio le
misure grezze dell’accelerometro sull’asse y senza riduzioni di scala o di offset. Il valore
di y varierà tra 1875 e 3125 (per ± 1 g) se non c’è alcuna accelerazione. Quando
l’accelerazione è di 3,5 g, si ha una misura di 4687. In qualsiasi evento, questi sono
valori word, e quindi il comando WRITE nella subroutine Registra_Dati deve essere
modificato in modo che memorizzi variabili word. Dal momento che un valore word
occupa due byte, il ciclo FOR...NEXT dovrà ancora contare in incrementi di 2.
PULSIN 7, 1, y
WRITE eeIndice, Word y
NEXT
Modifiche analoghe saranno fatte al ciclo FOR...NEXT nella subroutine Visualizza_Dati
qui riportata.
READ eeIndice, Word y
DEBUG DEC eeIndice, CRSRX, 7, SDEC y, CR
NEXT
Programma esempio: RegDatiAsseYNonScalato.bs2
Il programma esempio che segue è utilizzato per registrare i dati riportati in grafico nella
Figura 6-15 e nella Figura 6-16. Vi fornisce circa dieci secondi di registrazione dati, che
è un tempo sufficiente a compiere due o tre Ollie. Il trasferimento dei dati ad un foglio
elettronico e il riportarli in grafico si basa sulla procedura nella Attività #5. Il foglio
elettronico è stato modificato per generare i grafici mostrati in questa attività
aggiungendo una colonna con una formula che prende i dati dell’asse y, sottrae loro 2500,
quindi li divide per 625. Questo fornisce una misura in unità di gravità terrestre (g).
' -----[ Titolo ]------------------------------------------------------------' Sensori intelligenti e loro applicazioni - RegDatiAsseYNonScalato.bs2
' Registra 500 misure di accelerazione su asse y, dimensionate word.
'{$STAMP BS2}
'{$PBASIC 2.5}
' -----[ Direttive DATA ]---------------------------------------------------Reset
Records
RecordsEnd
DATA
DATA
DATA
0
(1000)
' -----[ Variabili ]---------------------------------------------------------car
eeIndice
valore
x
VAR
VAR
VAR
VAR
Byte
Word
Word
valore
y
VAR
Word
READ Reset, valore
valore = valore + 1
WRITE Reset, valore
FOR car = 10 TO 0
DEBUG CLS, "La registr. Dati partirà ", CR,
CR, CR,
"per il menu..."
FREQOUT 4, 50, 3750
PAUSE 950
NEXT
GOSUB Registra_Dati
ENDIF
DEBUG CLS,
"Premi/Rilascia Reset", CR,
"per iniziare a registrare ", CR, CR,
">"
DEBUGIN car
DEBUG CR
SELECT car
CASE "C", "c"
GOSUB Cancella_Dati
CASE "R", "r"
GOSUB Registra_Dati
CASE "D", "d"
CASE ELSE
DEBUG CR, "Entrata non valida.",
CR, "Prova ancora."
PAUSE 1500
ENDSELECT
LOOP
' -----[ Subroutine - Cancella_Dati ]------------------------------------------Cancella_Dati:
DEBUG CR, "Cancello..."
WRITE eeIndice, 0
NEXT
PAUSE 1000
RETURN
FREQOUT 4, 75, 4000
PAUSE 200
FREQOUT 4, 75, 4000
DEBUG CLS, "Regisro..."
PULSIN 7, 1, y
WRITE eeIndice, Word y
NEXT
FREQOUT 4, 200, 4000
DEBUGIN car
RETURN
' -----[ Subroutine - Visualizza_Dati ]---------------------------------------
Visualizza_Dati:
DEBUG CR, "Indice
CR, "-----CR
asse x
------
asse y ",
------",
READ eeIndice, Word y
DEBUG DEC eeIndice, CRSRX, 7, SDEC y, CR
NEXT
DEBUGIN car
RETURN
Il vostro turno – Cosa produce un Ollie alto?
Sarebbe interessante registrare e confrontare i dati degli Ollie di diversi pattinatori. Il
miglior modo di farlo sarebbe di riprendere un filmato video di ciascun Ollie, e quindi
osservare i video ed esaminare i grafici contemporaneamente. Un’altra cosa che si può
misurare è il tempo in aria, cioè il tempo tra i passi a ed f nei grafici.
ATTIVITÀ #7: DISTANZA IN BICICLETTA
La Figura 6-18 nella pagina seguente mostra come si possano montare la scheda e
l’accelerometro sulla ruota di una bicicletta, per misurare la distanza che la bicicletta
percorre. Poiché la bicicletta è verticale, questo potrebbe in un primo momento sembrare
un problema di angolo di rotazione, come nella Attività #5 del Capitolo 3. Però, è
presente anche una accelerazione verso il centro della ruota che l’asse misurerà. Questo
perché l’accelerometro viaggia in un percorso circolare, proprio come l’automobile RC
della precedente attività #5. Questa accelerazione verso il centro della ruota sarà diversa
alle diverse velocità, e ne risulteranno misure in un angolo più stretto. Le misure
dell’accelerometro saranno anche interessate da quando il ciclista frenerà, accelererà ed
entrerà in curva. In aggiunta, quale criterio andrà utilizzato per aggiungere uno al
numero dei cerchi completi che la ruota della bicicletta ha percorso? Questa attività
introduce l’isteresi come metodo per misurare la rotazione della ruota. Essa dimostra
anche come le tecniche di registrazione dati utilizzate in attività precedenti possono
essere impiegate per esaminare ciascuno di questi elementi e provarli per garantire
l’affidabilità del prototipo.
Non lasciate che il metallo della parte inferiore della vostra scheda entri in contatto
con i raggi della ruota. Usate un materiale isolante come plastica, cartone, o schiuma di
esd per isolare la parte inferiore della scheda dai raggi.
Figura 6-18
Scheda HomeWork con
l’accelerometro montata
sulla ruota di una bicicletta
a.
b.
Conteggio dei giri della ruota con l’isteresi
Uno dei problemi nel contare i giri di una ruota è assicurarsi che il programma non vada
avanti nel conteggio fin quando la ruota ha compiuto un giro completo. L’errore più
comune che si fa quando si misurano i giri di una ruota è quello di impostare una soglia
singola. Cosa accade se il ciclista si ferma ad un semaforo rosso, e sta muovendo la sua
bicicletta avanti e indietro di uno o due pollici? Se c’è una soglia singola, il contatore dei
giri della ruota continuerà ad aumentare ogni volta che il ciclista si muove avanti e
indietro (stando fermo).
Il programma esempio che segue mostra un metodo di risoluzione di questo problema
con l’isteresi. L’isteresi è il metodo di impostare due diversi valori che devono essere
superati prima che avvenga un cambiamento di stato. Nel nostro caso, il cambiamento di
stato è un aumento del conteggio dei giri della ruota. Con l’isteresi, la misura deve
cadere al di sotto di un valore basso, ed allora il programma aspetta fin quando è salita di
nuovo sopra un valore alto prima di riconoscere un cambiamento verso l’alto (aumento).
Quindi, la misura dovrà andare di nuovo sotto la soglia bassa prima che venga accreditato
un cambiamento da alto a basso. Ogni volta che il programma accredita che la misura è
andata sotto il valore basso e poi sopra il valore alto, aumenta il conteggio dei giri della
ruota di 1.
Ecco un segmento di codice che effettua l’isteresi. Nel primo dei due blocchi annidati
DO...LOOP, il programma attende finché l’asse y sale al di sopra di 2650. Allora, il
secondo dei due comandi annidati DO...LOOP aspetta fin quando la misura dell’asse y
scende sotto 2350. Soltanto allora esso aggiungerà 1 alla variabile contatore. Dopo
questo, il programma fa emettere un bip all’altoparlante piezo, e quindi ripeterà il ciclo
DO...LOOP più esterno. A questo punto, il programma torna ad aspettare che la misura
dell’asse y, che era sotto 2350, risalga di nuovo sopra 2650. Tenete a mente che questo
non è necessariamente il modo ottimale per misurare i giri della ruota. Sta a voi
determinarlo.
DO
DO UNTIL y > 2650
PULSIN 7, 1, y
LOOP
DO UNTIL y < 2350
PULSIN 7, 1, y
LOOP
contatore = contatore + 1
FREQOUT 4, 200, 3750
LOOP
Banda morta: L’intervallo tra 2350 e 2650 nel blocco di codice riportato qui sopra è detto
banda morta.
Programma esempio: ProvaContatoreRuota.bs2
√
√
√
Montate la vostra scheda entro una ruota di bicicletta come mostrato in Figura 618. Assicuratevi che ci sia un buon isolamento tra i raggi e il lato inferiore della
scheda.
Digitate, memorizzate, ed eseguite ProvaContatoreRuota.bs2.
Fate girare la ruota, e verificate che il programma fa un bip una volta ogni giro.
' Sensori intelligenti e loro applicazioni - ProvaContatoreRuota.bs2
' Mostra i giri di una ruota di bicicletta.
'{$STAMP BS2}
'{$PBASIC 2.5}
x
VAR
Word
y
contatore
VAR
VAR
Word
Word
DEBUG CLS
DO
DO UNTIL y > 2650
PULSIN 7, 1, y
LOOP
DO UNTIL y < 2350
PULSIN 7, 1, y
LOOP
FREQOUT 4, 200, 3750
LOOP
Registrazione dati di varie condizioni di funzionamento
A questo punto potreste pensare che l’applicazione sia pronta per una porzione di codice
che converta i giri in distanza, e forse a un display LCD e ad un paio di pulsanti che
scelgano gli elementi di menù sul LCD. Il problema qui è che noi abbiamo esaminato
due velocità della ruota che gira. Cosa dire del caso in cui il ciclista sta curvandosi in
curve strette – in tal caso l’accelerazione cambia? Cosa dire in casi di temperature fredde
e bollenti – provocheranno misure diverse? Certamente non vogliamo avere sul mercato
un prodotto che registri la distanza di una bicicletta soltanto alcune volte. Il prodotto
otterrebbe molto rapidamente una pessima reputazione.
La Figura 6-19 mostra la registrazione dati di uno studio di accelerazione della bicicletta
a due velocità leggermente diverse. L’area intorno ai 400 ms è dove la ruota è stata
rallentata. La cosa importante da notare da questo grafico è l’offset delle misure sugli
assi x ed y. Alla velocità più alta, il segnale dell’asse y è variato tra 1 e −0,5 g mentre le
misure sull’asse x sono variate tra −1,5 e 0,25 g. Dopo che la ruota è stata rallentata, la
misura lungo l’asse y è variata tra 1 e -1 g, mentre la misura lungo l’asse x è variata tra
circa 0,7 e −1,3 g.
La Figura 6-19 è soltanto il grafico di due velocità diverse. Certo, il codice di isteresi del
programma ProvaContatoreRuota.bs2 lavora in entrambe queste condizioni, ma lo farà in
TUTTE le condizioni? Con questo tipo di domanda, gli ingegneri potrebbero applicare
poche equazioni per predire le accelerazioni in varie condizioni estreme che esse
anticipano. Per verificate le previsioni si potrebbe usare anche un software di
simulazione. Perfino se questo tipo di stima è disponibile, il prodotto deve ancora essere
collaudato in una gran varietà di condizioni della "vita reale", specialmente per escludere
la possibilità di supposizioni errate da parte degli ingegneri. E’ qui che la registrazione
dati torna in scena. Il prototipo reale deve essere anche preso in varie condizioni che
potrebbero verificarsi sulla bicicletta di chiunque prima che sia sicuro investire in: un
involucro di plastica, un progetto elettronico raffinato che caratterizza parti a basso costo,
produzione in massa e costi di inventario.
Figura 6-19: Studio della accelerazione della ruota di una bicicletta
Asse y
Ruota di bicicletta a due velocità differenti
2
1.5
gravità,
1
g
0.5
0
0
100
200
300
400
500
600
700
800
900
1000
-0.5
-1
-1.5
-2
tempo, ms
Asse x
Con queste considerazioni in mente, possiamo tornare ad eseguire gli studi di
accelerazione, in quante più situazioni differenti sia possibile. Ecco il programma
utilizzato per registrare i dati per il grafico in Figura 6-19. Notate che esso sta
registrando valori dimensionati a word per le misure di entrambi gli assi x ed y. Il foglio
elettronico ha il compito di cambiare le misure grezze di PULSIN dell’accelerometro in
misure di gravità.
Programma Esempio: AccelerazioneRuotaBici.bs2
Come progetto, provate il misuratore della bicicletta con diverse temperature e condizioni
di marcia, curve, salite, discese, marcia lenta, marcia veloce, ecc. Cercate una sequenza
di cambiamenti nelle misure che possa essere registrata indipendentemente dalle
condizioni di marcia. Se non c’è un intervallo di isteresi per tutte le condizioni, il vostro
codice può aver bisogno di aggiornare periodicamente i valori alti e bassi più recenti, e
poi cercare l’isteresi in quell’intervallo.
' -----[ Titolo ]------------------------------------------------------------' Sensori intelligenti e loro applicazioni - AccelerazioneRuotaBici.bs2
' Registra i dati di 500 misure di accelerazione sugli assi x ed y.
'{$STAMP BS2}
'{$PBASIC 2.5}
' -----[ Direttive DATA ]----------------------------------------------------Reset
Records
RecordsEnd
DATA
DATA
DATA
0
(1000)
' -----[ Variabili ]---------------------------------------------------------car
eeIndice
valore
x
y
VAR
VAR
VAR
VAR
VAR
Byte
Word
Word
valore
Word
READ Reset, valore
valore = valore + 1
WRITE Reset, valore
FOR car = 10 TO 0
DEBUG CLS, "Inizia registraz. dati ", CR,
CR, CR,
"per il menu..."
FREQOUT 4, 50, 3750
PAUSE 950
NEXT
GOSUB Registra_Dati
ENDIF
DEBUG CLS,
"Premi/Rilascia Reset", CR,
"per iniziare a registrare ", CR, CR,
">"
DEBUGIN car
DEBUG CR
SELECT car
CASE "C", "c"
GOSUB Cancella_Dati
CASE "R", "r"
GOSUB Registra_Dati
CASE "D", "d"
CASE ELSE
DEBUG CR, "Entrata non valida.",
PAUSE 1500
ENDSELECT
LOOP
DEBUG CR, "Cancello..."
WRITE eeIndice, 0
NEXT
PAUSE 1000
RETURN
FREQOUT 4, 75, 4000
PAUSE 200
FREQOUT 4, 75, 4000
DEBUG CLS, "Registro..."
PULSIN 6, 1, x
PULSIN 7, 1, y
WRITE eeIndice, Word x
WRITE eeIndice + 2, Word y
NEXT
FREQOUT 4, 200, 4000
DEBUGIN car
RETURN
DEBUG CR, "Indice asse x asse y",
CR, "------ ------ ------",
CR
READ eeIndice, Word x
READ eeIndice + 2, Word y
DEBUG DEC eeIndice, CRSRX, 7, SDEC x, CRSRX, 14, SDEC y, CR
NEXT
DEBUGIN car
RETURN
Il vostro turno
Un’altra cosa da esaminare è il modo in cui vengono effettuate le misure di rotazione nel
piano verticale in varie condizioni della ruota di bicicletta.
√
La sezione “Il vostro turno” dell’Attività #4 registra le misure in brad. Usate
queste per registrare i dati in brad della rotazione della ruota della vostre
bicicletta.
√
Riportate in grafico la rotazione in funzione del tempo nelle varie condizioni di
marcia discusse in questa Attività.
C’è un comportamento della misura di angolo per cui si possa applicare l’isteresi in tutte
le condizioni di marcia?
SOMMARIO
Questo capitolo ha introdotto un gran numero di applicazioni diverse dell’accelerometro
e di tecniche di registrazione di dati che possono essere utilizzate per studiare le misure
dell’accelerometro nelle varie condizioni, e in alcuni casi, per raffinare i vostri
programmi. Quando si osserva la cima di un oggetto, si possono impiegare le misure di
rotazione nel piano verticale, assieme alla distanza dell’oggetto e ad un po’ di
trigonometria, per determinare l’altezza dell’oggetto.
Le direttive DATA con i nomi opzionali Symbol sono state introdotte come modo per
semplificare l’acquisizione dei record nei programmi di registrazione dati (datalogging).
Esse possono essere utilizzate per definire gli intervalli di memoria di programma
EEPROM non utilizzata. Poiché i nomi Symbol memorizzano l’indirizzo di partenza
delle direttive DATA, questi sono molto comodi nei cicli FOR...NEXT che effettuano
operazioni READ/WRITE fuori dell’intervallo dei byte EEPROM definiti dalle direttive
DATA iniziali e finali.
È atata anche introdotta una tecnica per utilizzare una direttiva DATA che riserva un byte
all’impostazione del modo operativo del programma. In ciascun avviamento del
programma, una routine di inizializzazione legge il byte, ci aggiunge uno, e sostituisce il
valore precedente nella EEPROM con il valore modificato. Ciascuna volta che il
programma viene riavviato premendo e rilasciando il pulsante Reset della scheda, il
programma potrà utilizzare il nuovo valore in EEPROM per scegliere tra modi diversi.
Per abilitare (on) o disabilitare (off) uno dei modi nel programma, è stata usata una
istruzione IF...THEN che esamina se il resto del valore diviso per due sia zero. Questo
rende possibile avviare ed arrestare la registrazione dei dati senza essere collegati al
computer.
Le applicazioni dell’accelerometro con registrazione dei dati includono l’accelerazione di
una automobile radiocomandata (RC), le misure di trucchi di uno skateboard, e le misure
della distanza percorsa dalla ruota di una bicicletta. Ciascuna di queste impiega un
programma che è una variazione del programma di registrazione dati remoti introdotto
nell’attività #4. I dati visualizzati nel terminale di Debug sono stati ombreggiati, copiati,
ed incollati in file di testo. I file di testo sono stati poi importati in un programma foglio
elettronico e riportati in grafico. I grafici sono stati analizzati per esaminare le
accelerazioni, le inclinazioni, e gli angoli interessati nell’automobile RC, nello
skateboard, e nei movimenti della ruota di bicicletta.
Domande
1. Quali tre elementi di informazione vi occorrono per misurare l’altezza di un
edificio partendo da una distanza?
2. Che differenza c’è tra DATA (100) e DATA 20 (100)?
3. Cosa c’è di errato in questo commando? WRITE eeIndice, 1000. Come potete
correggere l’errore?
4. Quali altre direttive e comandi debbono essere presenti perché l’istruzione IF
value // 2 = 0 THEN... possa rendere possible scegliere la modalità di
funzionamento del prgramma premendo il pulsante Reset della vostra scheda?
5. Qual’è il compito dell’altoparlante piezo in RegDatiDiAccelerazione.bs2?
6. Coome si può modificare una direttiva DATA per farle mettere da parte più
valori?
7. In che modo l’accelerazione in avanti differisce dalla decelerazione in avanti?
8. Quando si guida in cerchio a velocità e raggio costante, qual è la direzione
dell’accelerazione?
9. In che cosa differiscono il programma registratore di dati che misura l’ollie di
uno skateboarder e il programma che misura il moto di un’automobile RC? E in
che cosa si somigliano?
Esercizi
1. La cima di un edificio è stata osservato che è a 75° da un punto di osservazione
distante 15 m dall’edificio e 1 m dal terreno. Quanto è alto l’edificio?
2. Scrivere due direttive DATA che riservino 1501 byte. Usare nomi symbol.
3. Scrivere un ciclo FOR...NEXT che reperisca 751 word. Assumere che i nomi
Symbol della vostra direttiva DATA siano StartData ed EndData.
4. Modificare un blocco di codice nel RegDatiDiAccelerazione.bs2 in modo che il
suo conto alla rovescia sia di cinque secondi.
Progetti
1. Usate Google per trovare la pendenza sopra la quale la neve è probabile che
diventi una valanga. Realizzare un prototipo di strumento di misura che vi
avverta se una pendenza è troppo ripida. Questo dispositivo potrebbe essere
utilizzato per sostituirne uno meccanico usato comunemente nelle stazioni
sciistiche.
2. Progettare un prototipo di podometro (contapassi).
Soluzioni
Q1. (1) L’altezza da cui si prende la misura, (2) la distanza dalla base dell’edificio, e
(3) l’angolo dalla orizzontale dal quale si è osservata la cima dell’edificio.
Q2. L’istruzione DATA (100) mette da parte 100 byte in EEPROM; mentre invece,
DATA 20 (100) memorizza il valore 20 in ciascuno dei 100 byte.
Q3. Il commando WRITE memorizza valori di byte. Per correggere il comando,
dovreste inserire il modificatore Word prima del valore 1000. Tenete a mente che
dovrete incrementare eeIndice di 2 prima di memorizzare il valore successivo.
Q4. Vi occorreranno le istruzioni: Reset DATA 0; valore VAR Word; READ
Reset, valore; valore = valore + 1; WRITE Reset, valore
Q5. Far conoscere all’utente il modo in cui il dispositivo sta funzionando, con
l’emissione di pigolìi (toni di durata e frequenza determinate). Il conto alla
rovescia prima della registrazione dati comporta undici toni da 3,75 kHz di 50
ms di durata, seguiti da due toni più acuti e più pronunciati (toni da 4 kHz per 75
ms). Dopo la registrazione dei dati, l’altoparlante piezo emette un pigolio più
lungo (4 kHz per 200 ms) per far sapere all’utente che la registrazione dati è
completa.
Q6. Aumentate il valore tra parentesi che segue la parola chiave DATA.
Q7. Se state viaggiando in avanti e decelerate, è la stessa cosa di accelerare in
retromarcia, che vuol dire accelerare nella direzione opposta ad avanti.
Q8. Verso il centro di un cerchio.
Q9. Questo è un confronto di due programmi esempio, RegDatiDiAccelerazione.bs2
confrontato con RegDatiAsseYNonScalato.bs2. RegDatiDiAccelerazione.bs2
memorizza i valori di x ed y che sono ridotti in scala all’intervallo tra 0 e 200
con 100 come 0 g. RegDatiAsseYNonScalato.bs2 non soltanto memorizza la
versione non scalata, ma inoltre non applica alcun offset. Effettua soltanto la
misura grezza del valore sull’asse y, che sta nell’intervallo da 1875 a 3125. In
entrambi i programmi, occorre un valore word per memorizzare ciascuna misura
in RegDatiAccelerazione.bs2, è invece una word (2 byte) che memorizza le
misure lungo gli assi x ed y, scalate e con offset.
In
RegDatiAsseYNonScalato.bs2, ciascun valore per l’asse y prende un’intera
word. Anche se il tempo impiegato per memorizzare i byte è lo stesso in
entrambi i programmi, RegDatiAsseYNonScalato.bs2 risparmia un pò di tempo
tra le misure perché non prende alcun tempo per un comando PULSIN che
altrimenti leggerebbe l’asse x.
E1. altezza oggetto = opposto + altezza accelerometro
= (adiacente × tan (75˚)) m + 1 m
= (15 × 3,73) m + 1 m
= 56,98 m
E2.
StartSymbol DATA (1500)
EndSymbol DATA
E3.
' Assumere che StartData ed EndData siano stati definiti correttamente
FOR contatore = StartData TO EndData
READ contatore, ElemDato
DEBUG ElemDato ' Non è stato specificato il formato, quindi non è
' stato utilizzato alcun DEC. Se fosse stato usato
' DEC ElemDato, sarebbe ancora corretto, poiché
' questo è quanto l’esempio del testo aveva usato.
NEXT
E4.
FOR car = 4 TO 0
DEBUG CLS, "Registrazione dati inizia ", CR,
CR, CR,
"per il menu..."
FREQOUT 4, 50, 3750
PAUSE 950
NEXT
P1. Parole chiave utilizzate: valanga -- predizione -- pendenza
Articolo di aiuto risultante utilizzato: http://en.wikipedia.org/wiki/Avalanche
Informazione chiave: La sezione del terreno stabilisce che una ripidità al disotto
di 25˚ o al di sopra di 60˚ presenta basso rischio e che il rischio massimo è nelle
pendenze comprese tra 35 e 45˚.
L’hardware potrebbe comprendere un accelerometro, un LCD, pulsanti per
scegliere la modalità, ed un altoparlante piezo per allarme. La caratteristica
chiave del prototipo potrebbe essere il dimostrare che il dispositivo può rilevare
alcuni livelli di rischio da, per dire, la base della pendenza. Se il prototipo viene
approvato si potranno aggiungere altre caratteristiche.
Notare: Le località sciistiche mantengono regolarmente le loro pendenze
prendendo queste misure e poi lanciando cariche esplosive sul pendio per creare
piccole valanghe, prevenendo così che più tardi si verifichi una valanga più
grande. Così anche se potrebbe sembrare rischioso misurare dalla base della
pendenza, stiamo parlando di una pendenza che viene mantenuta regolarmente
per prevenire le valanghe.
Il prototipo comporta l’uso della vostra scheda per osservare la cima di una
pendenza dalla base, che si riduce ad essere una semplice modifica
dell’applicazione discussa nell’Attività #1 di questo Capitolo. Si può aggiungere
alla versione modificata di RotazioneVerticaleRuota.bs2 una istruzione
SELECT…CASE che visualizza sul LCD messaggi diversi a seconda dell’angolo
che è stato misurato. L’istruzione SELECT…CASE, quando l’avrete scritta,
potrebbe apparire come questa:
SELECT angol
CASE 0 to 25
GOSUB Visualizza_molto_sicuro
CASE 25 to 35, 45 to 60
GOSUB Visualizza_poco_pericolo
CASE 35 to 45
GOSUB Visualizza_massimo_pericolo
ENDSELECT
Ciascuna subroutine visualizzerebbe un messaggio di indicazione di rischio dopo
l’angolo misurato.
P2. Caricate ed eseguite RegDatiAsseYNonScalato.bs2. Agganciate la scheda alla
vostra cintura alla vita in modo che l’asse y sia verticale. Premete e rilasciate il
pulsante reset della vostra scheda e camminate durante il periodo di registrazione
dei dati. Seguite le istruzioni nell’Attività #5 per mettere in grafico i punti dato
che avete registrati. Vorrete probabilmente mettere in grafico 200 delle 1001
misure. Cercate uno schema, il grafico dovrebbe superare alcuni valori e andare
sotto altri in ciascun passo. Eccovi un esempio. Notate che l’accelerazione di
ciascun passo scende sotto 2900 poi supera 3300.
Esempio di Diagramma di camminata:
asse x-------3900
3700
3500
3300
asse x -----3100
2900
2700
2500
1
16 31 46 61 76 91 106 121 136 151 166 181 196 211 226 241
Usate quei valori per definire le costanti StepLow e StepHigh nel programma
che segue:
' Sensori intelligenti e loro applicazioni - Cap6_Progetto2.bs2
'
'
'
'
IMPORTANTE, seguite le istruzioni per offrire i vostri
valori. Trovate la sezione Soluztioni del Capitolo 6.
Esaminate la soluzione al Progetto 2 per avere informazioni su
come determinare le vosre particolari costanti StepLow e StepHigh.
' {$STAMP BS2}
' {$PBASIC 2.5}
StepLow CON 2900
StepHigh CON 3300
y
VAR Word
yVec
VAR Word
Cntpassi VAR Word
yVec = 3300
PAUSE 250
SEROUT 14, 84, [22, 12]
PAUSE 5
' Scollega alimentazione
' Avvia LCD & cancella display
' Pausa di 5 ms per cancellare display
DO
PULSIN 7, 1, y
IF (y <= 2900 AND yVec >= 3300) OR (y >= 3300 AND yVec <= 2900) THEN
yVec = y
Cntpassi = Cntpassi + 1
ENDIF
SEROUT 14, 84, [128, DEC5 Cntpassi / 2]
LOOP
Capitolo 7: Grafici a barre LCD per Distanza e Inclinazione · Pagina 285
Capitolo 7: Grafici a barre LCD per distanza e
inclinazione
La definizione e la visualizzazione di caratteri personalizzati con il LCD seriale Parallax
è stata introdotta nel Capitolo 1, Attività #4. Questo capitolo introduce alcune ulteriori
tecniche per caratteri personalizzati, e poi le applica a visualizzazioni di grafici a barre.
Queste visualizzazioni indicheranno la distanza di un oggetto dal sensore ultrasonico
Ping))) e l’inclinazione dell’accelerometro Memsic 2125 a due assi.
ATTIVITÀ #1: SCAMBIO DI CARATTERI PERSONALIZZATI
Il LCD seriale Parallax può visualizzare fino ad otto caratteri personalizzati in un
qualsiasi istante assegnato di tempo. Però, possono esserci molti caratteri personalizzati,
più di otto nella vostra applicazione, poiché i caratteri personalizzati possono essere
definiti e ridefiniti a volontà, in base alla necessità. L’unica limitazione è che soltanto
otto caratteri possono essere visualizzati simultaneamente, e otto è abbastanza per la
maggior parte dei progetti.
Il posto dove potete definire e memorizzare una libreria di più di otto definizioni di
caratteri personalizzati è nella parte della memoria EEPROM del BASIC Stamp non
utilizzata per memorizzare il programma. Poiché i programmi PBASIC riempiono
raramente l’intera memoria EEPROM, c’è tipicamente spazio per tutte le definizioni di
carattere personalizzato che un’applicazione potrebbe richiedere.
Una poderosa tecnica è utilizzare soltanto uno degli otto spazi riservati nel LCD ai
caratteri personalizzati per visualizzare una sequenza di definizioni di carattere
personalizzato memorizzate nella EEPROM del BASIC Stamp. Ciò è particolarmente
utile per l’animazione, ma sarà anche importante per le visualizzazioni di grafici a barre.
Questa attività vi fornisce un esempio di animazione.
Da memoria EEPROM a memoria di carattere in LCD
Il programma esempio che segue mostrerà un modo conveniente per memorizzare le
definizioni di carattere personalizzato nella EEPROM del BASIC Stamp. Qui sotto sono
mostrate due delle quindici definizioni di carattere personalizzato. Ciascuna definizione
ottiene un nome Symbol unico, come Car0, Car1, Car2, e così via, fino a Car14.
Ciascuno di questi nomi Symbol rappresenta l’indirizzo EEPROM del primo byte della
direttiva DATA. La subroutine che trasferisce le definizioni dalla EEPROM alle zone
memoria di carattere personalizzato del LCD usa questi nomi Symbol come punto di
riferimento per leggere i byte dalla EEPROM. Dopo aver letto ciascun byte dalla
EEPROM, la subroutine lo invia al LCD seriale.
Car4
DATA
Car9
DATA
.
.
.
%11111,
%00011,
%11011,
%11011,
%11111,
%11111,
%11111,
%11111
.
.
.
%11111,
%11111,
%11111,
%11111,
%11011,
%11011,
%11000,
%11111
.
.
.
'
'
'
'
'
'
'
'
*
0
*
*
*
*
*
*
*
0
*
*
*
*
*
*
*
0
0
0
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
'
'
'
'
'
'
'
'
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
0
0
0
*
*
*
*
*
*
*
0
*
*
*
*
*
*
*
0
*
Il prossimo programma esempio va a prendere le definizioni di carattere personalizzato
dalla EEPROM e li invia al LCD seriale usando una subroutine detta Def_Car_Pers.
Tutto ciò che dovete fare prima di richiamare la subroutine è impostare il valore di due
variabili: CarPers e carBase. La variabile CarPers serve a scegliere quale zona di
carattere personalizzato definire (0, 1, 2...7). La variabile carBase è usata per dire alla
subroutine Def_Car_Pers dove guardare nella EEPROM per l’inizio della definizione
del carattere. Ad esempio, per trasferire la definizione Car9 nella EEPROM del BASIC
Stamp al Carattere personalizzato 5 nella memoria di carattere del LCD seriale Parallax,
usate questi tre comandi:
CarPers = 5
carBase = Car9
GOSUB Def_Car_Pers
Se il vostro programma deve scegliere tra molte definizioni di carattere personalizzato
differenti, potete sostituire carBase = Car9 con un comando LOOKUP. Qui sotto è
riportato un esempio che sceglie una di tre diverse definizioni di carattere personalizzato
nel successivo programma esempio con un comando LOOKUP. A seconda del valore di
contatore, sarà copiato nella variabile carBase o Car0, o Car1 o Car2.
DO
contatore = contatore // 3
' Definisce caratteri personalizzati.
CarPers = 5
LOOKUP contatore,
[Car0, Car1, Car2],
carBase
GOSUB Def_Car_Pers
.
.
.
LOOP
Come fare in modo che contatore conti 0, 1, 2, 0, 1, 2, ... senza ciclo FOR...NEXT
Il blocco di codice qui sopra è in un ciclo DO...LOOP, quindi viene ripetuto indefinitamente.
La variabile contatore aumenta di 1 ogni volta tramite un ciclo. Il comando contatore =
contatore // 3 usa l’operatore PBASIC modulo // per calcolare il resto del contatore ÷
3. Impostando contatore uguale al resto di contatore ÷ 3, ciò fa sì che contatore conti
soltanto fino a 2 prima di ritornare a 0. La sequenza di valori risultanti memorizzati da
contatore è 0, 1, 2, 0, 1, 2, 0, 1, 2, ...
Per visualizzare il carattere personalizzato ad una certa posizione di carattere, il
programma esempio che segue ha una subroutine Vis_Car_Pers. Questa subroutine
dipende da tre variabili, riga, carPers, e cursore. La variabile riga dovrebbe essere
impostata o al valore Riga0 o al valore Riga1, definiti nella sezione Costanti del
programma esempio. Di nuovo, la variabile carPers ha un valore tra 0 e 7, che sceglie
un carattere personalizzato nella memoria carattere del LCD. La variabile cursore può
avere un valore tra 0 e 15 a seconda di quanto lontano dal bordo sinistro del LCD
vogliate sia stampato il carattere. Ad esempio, per stampare il Carattere Personalizzato 5
sulla Riga 0 del LCD al carattere 8, usate questi comandi:
carPers = 5
riga = Riga0
cursore = 8
GOSUB Vis_Car_Pers
Poiché il programma esempio successivo fa soltanto l’animazione di un carattere, per
accedere a ciascuna delle direttive DATA di carattere personalizzato si può utilizzare un
semplice ciclo FOR...NEXT. L’indirizzo di partenza di ciascuna direttiva DATA srà otto
byte dopo la successiva. Si può aggiornare il LCD con la definizione di ciascun carattere
nella sequenza delle direttive DATA tramite un ciclo FOR...NEXT che procede con passo 8,
ed inizia al Car0 e termina al Car14.
DO
FOR carBase = Car0 TO Car14 STEP 8
GOSUB Def_Car_Pers
cursore = 7
GOSUB Vis_Car_Pers
PAUSE 200 '- carBase
NEXT
PAUSE 1000
LOOP
Programma Esempio: VermeDiPixelEeprom.bs2
Scarico gratuito! Questo programma è disponibile come file gratuito .bs2 scaricabile dalla
VermeDiPixelEeprom.bs2 crea un verme-di-pixel, che striscia attraverso un carattere.
√
√
√
Esaminate le definizioni di carattere in EEPROM e provate a predire come
apparirà l’animazione quando eseguite il programma.
Aprite ed eseguite VermeDiPixelEeprom.bs2.
Confrontate i risultati da voi attesi con il display LCD.
' -----[ Titolo ]------------------------------------------------------------' Sensori intelligenti e loro applicazioni - VermeDiPixelEeprom.bs2
' Visualizza un verme animato di pixel entro un singolo carattere LCD
' {$STAMP BS2}
' {$PBASIC 2.5}
' Dispositivo bersaglio = BASIC Stamp 2
' Linguaggio
= PBASIC 2.5
' -----[ Dati in EEPROM ]----------------------------------------------------Car0
DATA
%11111,
%01111,
%11111,
%11111,
%11111,
%11111,
%11111,
%11111
'
'
'
'
'
'
'
'
*
0
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
Car1
DATA
%11111,
%00111,
%11111,
' * * * * *
' 0 0 * * *
' * * * * *
%11111,
%11111,
%11111,
%11111,
%11111
'
'
'
'
'
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
Car2
DATA
%11111,
%00011,
%11111,
%11111,
%11111,
%11111,
%11111,
%11111
'
'
'
'
'
'
'
'
*
0
*
*
*
*
*
*
*
0
*
*
*
*
*
*
*
0
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
Car3
DATA
%11111,
%00011,
%11011,
%11111,
%11111,
%11111,
%11111,
%11111
'
'
'
'
'
'
'
'
*
0
*
*
*
*
*
*
*
0
*
*
*
*
*
*
*
0
0
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
Car4
DATA
%11111,
%00011,
%11011,
%11011,
%11111,
%11111,
%11111,
%11111
'
'
'
'
'
'
'
'
*
0
*
*
*
*
*
*
*
0
*
*
*
*
*
*
*
0
0
0
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
Car5
DATA
%11111,
%10011,
%11011,
%11011,
%11011,
%11111,
%11111,
%11111
'
'
'
'
'
'
'
'
*
*
*
*
*
*
*
*
*
0
*
*
*
*
*
*
*
0
0
0
0
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
Car6
DATA
%11111,
%11011,
%11011,
%11011,
%11011,
%11011,
%11111,
%11111
'
'
'
'
'
'
'
'
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
0
0
0
0
0
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
Car7
DATA
%11111,
%11111,
%11011,
%11011,
%11011,
%11011,
%11011,
%11111
'
'
'
'
'
'
'
'
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
0
0
0
0
0
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
Car8
DATA
%11111,
%11111,
%11111,
%11011,
%11011,
%11011,
%11001,
%11111
'
'
'
'
'
'
'
'
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
0
0
0
0
*
*
*
*
*
*
*
0
*
*
*
*
*
*
*
*
*
Car9
DATA
%11111,
%11111,
%11111,
%11111,
%11011,
%11011,
%11000,
%11111
'
'
'
'
'
'
'
'
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
0
0
0
*
*
*
*
*
*
*
0
*
*
*
*
*
*
*
0
*
Car10
DATA
%11111,
%11111,
%11111,
%11111,
%11111,
%11011,
%11000,
%11111
'
'
'
'
'
'
'
'
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
0
0
*
*
*
*
*
*
*
0
*
*
*
*
*
*
*
0
*
Car11
DATA
%11111,
%11111,
%11111,
%11111,
%11111,
%11111,
%11000,
%11111
'
'
'
'
'
'
'
'
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
0
*
*
*
*
*
*
*
0
*
*
*
*
*
*
*
0
*
Car12
DATA
%11111,
%11111,
%11111,
%11111,
%11111,
%11111,
'
'
'
'
'
'
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
%11100,
%11111
' * * * 0 0
' * * * * *
Car13
DATA
%11111,
%11111,
%11111,
%11111,
%11111,
%11111,
%11110,
%11111
'
'
'
'
'
'
'
'
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
0
*
Car14
DATA
%11111,
%11111,
%11111,
%11111,
%11111,
%11111,
%11111,
%11111
'
'
'
'
'
'
'
'
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
' -----[ Pin I/O ]----------------------------------------------------------PinLcd
PIN
14
' pin I/O connesso al RX del LCD
' -----[ Costanti ]---------------------------------------------------------T9600
CON
84
' Vero, 8-bit, senza parità, 9600
ClsLcd
CrLcd
OffLcd
OnLcd
Riga0
Riga1
Definisce
CON
CON
CON
CON
CON
CON
CON
12
13
21
22
128
148
248
' Nuova pagina -> cancella schermo
' Ritorno carrello
' Spegne il display (off)
' Accende il display (on)
' Riga 0, carattere 0
' Indirizzo che definisce car pers 0
' -----[ Variabili ]---------------------------------------------------------CarPers
indice
carBase
RigaPunt
cursore
contatore
riga
VAR
VAR
VAR
VAR
VAR
VAR
VAR
Nib
Nib
Byte
Byte
Nib
Nib
Byte
'
'
'
'
'
'
'
Selettore del carattere personal.
variabile indice Eeprom
Carattere base per la READ
linea puntinata da 5-pixel
posizionamento cursore
variabile che conta nel ciclo princ.
Riga0 o Riga1
SEROUT PinLcd, T9600, [OnLcd, ClsLcd]
' scollega alimentazione
' Inizializza LCD
PAUSE 5
CarPers = 2
riga = Riga0
' ritardo di 5 ms per cancellare il
' display
' Sceglie Carattere Personalizzato 2
' Grafico a barre su Riga 0.
' Ciclo principale
FOR carBase = Car0 TO Car14 STEP 8
GOSUB Def_Car_Pers
cursore = 7
GOSUB Vis_Car_Pers
PAUSE 200 '- carBase
NEXT
'
'
'
'
'
'
PAUSE 1000
' Pausa di 1 secondo
LOOP
Attraversa i 10 caratteri personal.
Definisce il carattere
Posiziona il cursore
Visualizza carattere
maggiore carBase – minore pausa
Ripete la FOR carBase...
' -----[ Subroutine - Def_Car_Pers ]----------------------------------------'
'
'
'
Questa subroutine definisce uno degli otto caratteri personalizzati del LCD.
Impostare la variabile carBase = ad uno dei nomi Symbol che precede la diret
tiva DATA del carattere personalizzato. Impostare la variabile CarPers a un
valore tra 0 e 7 per scegliere uno dei otto caratteri personalizzati di LCD.
Def_Car_Pers:
SEROUT PinLcd, T9600,
[Definisce + CarPers]
FOR indice = 0 TO 7
READ carBase + indice, RigaPunt
SEROUT PinLcd, T9600, [RigaPunt]
NEXT
' Definisce carattere personalizz.
' 7 byte, definisce 7 righe di punti
' Ottiene il byte per riga di punti
' Lo invia al LCD
RETURN
' -----[ Subroutines - Vis_Car_Pers ]--------------------------------------'
'
'
'
'
Questa subroutine visualizza un carattere personalizzato. La variabile riga
può essere impostata o a Riga0 o a Riga1, e la variabile cursore può essere
impostata a un valore tra 0 e 15. La variabile CarPers sceglie uno dei
caratteri personalizzati del LCD e dovrebbe essere impostata a un valore
tra 0 e 7.
Visp_Car_Pers:
[riga + cursora, Car_Pers]
RETURN
' Visualizza carattere personalizzato
Dentro le Subroutine - Def_Car_Pers e Vis_Car_Pers
Diamo un’occhiata alla subroutine Def_Car_Pers (qui sotto). Il primo comando,
SEROUT PinLcd, T9600, [Definisce + CarPers] invia un valore tra 248 e 255 al
LCD. Queso è perché Definisce è impostata a 248 nella sezione Costanti. 248 è il
valore che dice al LCD di definire il carattere personalizzato 0. Se volete definire il
carattere personalizzato 1, il valore è 249, e così via fino al carattere personalizzato 7, che
è 255. Quindi il termine Definisce + CarPers può essere 248 se CarPers memorizza
0, o 249 se CarPers memorizza 1, e così via fino a 255 se CarPers memorizza 7.
Def_Car_Pers:
' Definisce Carattere Personalizzato 2
FOR indice = 0 TO 7
READ carBase + indice, RigaPunt ' Ottiene byte per riga di punti
SEROUT PinLcd, T9600, [RigaPunti] ' Lo invia al LCD
NEXT
RETURN
Dopo che il LCD riceve un valore tra 248 e 255, aspetta di ricevere otto byte ulteriori,
ciascuno contenente una delle otto righe orizzontali di punti che formano la definizione di
un carattere personalizzato. Il ciclo FOR...NEXT nella Def_Car_Pers legge ciascun byte
nella EEPROM, iniziando all’indirizzo carBase. Tenete a mente che la Routine
principale del programma imposta carBase al nome Symbol di una direttiva DATA, che è
una costante uguale all’indirizzo iniziale dei dati. Il comando READ carBase +
indice, RigaPunt legge un byte della definizione del carattere e lo memorizza nella
variabile RigaPunt. La prima esecuzione del ciclo FOR...NEXT, indice è 0, quindi il
primo byte nella definizione del carattere è reperito dalla EEPROM e memorizzato nella
variabile RigaPunt. Poi, il valore memorizzato dalla variabile RigaPunt è inviato al
LCD con il comando SEROUT PinLcd, T9600, [RigaPunt]. Nella seconda iterazione
del ciclo FOR...NEXT, indice vale 1, e quindi il secondo byte è letto dalla EEPROM ed
inviato al LCD. Nella terza iterazione del ciclo, è reperito ed inviato il terzo byte nella
definizione del carattere, e così via fino all’ottavo byte, quando indice diventa 7.
La subroutine Vis_Car_Pers ha soltanto una istruzione, SEROUT PinLcd, T9600,
[riga + cursore, CarPers]. Essa invia due valori al LCD. Il primo è riga +
cursore, che posiziona il cursore dove deve essere visualizzato il carattere
personalizzato. La variabile riga contiene o Riga0 o Riga1. Riga0 è una costante di
valore 128, che punta al carattere 0 sulla Riga 0. Riga1 è la costante di valore 148, che
punta al carattere 0 sulla Riga 1. Aggiungendo cursore (un valore tra 0 e 15) questo vi
permette di controllare su quale riga e carattere viene posto il cursore. La variabile
CarPers, che contiene un valore tra 0 e 7 farà sì che il carattere peronalizzato sia
stampato dove è stato posizionato il cursore. Il secondo valore che il comando SEROUT
invia è CarPers, che contiene un valore tra 0 e 7. Questo valore fa sì che il LCD stampi
un carattere personalizzato dove era stato posizionato il cursore.
Vis_Car_Pers:
[riga + cursore, CarPers]
RETURN
Il vostro turno – Copie multiple dei caratteri personalizzati?
Se avete gran quantità di caratteri personalizzati diversi, ma volete visualizzarne soltanto
uno in un dato istante, vi occorrerà soltanto una delle definizioni di carattere
personalizzato del LCD. Però, se volete che più di un carattere personalizzato diverso
venga visualizzato dal LCD contemporaneamente, userete più di una definizione dei
diversi caratteri personalizzati nella memoria di carattere del LCD.
√
√
Memorizzate
il
programma
CaratteriPersEeprom.bs2
col
nome
CaratteriPersEepromVostroTurno.bs2.
Aggiungete questo blocco di codice alla sezione Inizializzazione del
programma.
CarPers = 5
riga = Riga0
cursore = 9
GOSUB Vis_Car_Pers
riga = Riga1
GOSUB Vis_Car_Pers
cursore = 8
GOSUB Vis_Car_Pers
√
Eseguite il programma, ed osservate il risultato visualizzato sul LCD.
Il ciclo DO...LOOP principale sta soltanto aggiornando il carattere 8 di Riga 0, mentre
anche le altre tre occorrenze del Carattere personalizzato 5 stanno cambiando! Perché?
Quando cambia la definizione del Carattere Personalizzato 5, tutti i caratteri
personalizzati 5 sul display sono automaticamente aggiornati.
In alcuni casi, si desidera questo fatto. Ad esempio, potete ottenere alcuni effetti visivi
interessanti facendo 32 copie di un carattere personalizzato e poi aggiornando
ripetutamente la definizione di quel carattere. Per situazioni in cui volete visualizzare
contemporaneamente più di un carattere personalizzato, usate semplicemente più di un
carattere personalizzato. In altri casi, quando volete che il LCD visualizzi più caratteri
personalizzati differenti contemporaneamente, usate definizioni di carattere
personalizzato differenti.
Sommario della visualizzazione di carattere personalizzzato:
•
•
Se avete svariati caratteri personalizzati diversi, ma ne volete visualizzare
soltanto uno ad un dato momento, usate un singolo carattere personalizzato e
aggiornate la sua definizione per cambiare il carattere.
Se invece volete visualizzare contemporaneamente su LCD più caratteri
personalizzati diversi, usate più di una definizione dei diversi caratteri
personalizzati nella memoria di carattere del LCD.
Per la seconda delle regole elencate, che riguarda l’avere sul display
contemporaneamente più di un carattere personalizzato, la successiva attività fornisce un
esempo funzionante.
ATTIVITÀ #2: GRAFICI A BARRE ORIZZONTALI PER MISURE DI
DISTANZA COL SENSORE PING)))
Questo primo esempio di grafico a barre dimostra come visualizzare graficamente una
misura con il sensore Ping))) della distanza in centimetri di un dato oggetto.
Parti e apparecchiatura
Vedi Capitolo #2, Attività #4.
Un grafico a barre orizzontale
Per provare il grafico a barre orizzontale del programma esempio che segue, inserirete i
valori nella finestrella di trasmissione del terminale di Debug, e il LCD visualizzerà il
risultato in formato di grafico a barre come indicato in Figura 7-1. Ciascuna riga sul
LCD ha ottanta colonne di linee verticali puntinate. Se digitate 1, la colonna più a
sinistra nel carattere più a sinistra diventerà nera. Se digitate 2, diventeranno nere due
colonne. Se digitate 29, 29 colonne diventeranno nere. Poiché ciascun carattere è largo 5
colonne, il valore 29 è visualizzato in realtà come cinque caratteri anneriti e il sesto
carattere con quattro colonne nere.
Figura 7-1: Grafico a barre orizzontale di caratteri personalizzati
Finestrella
di trasmissione
Finestrella
di ricezione
Digitate valori (da 0 a 80)
>1
>2
>29
>30
>31
Grafico a barre
visualizzato
dal LCD
Il progamma esempio che segue usa entrambe le regole di visualizzazione dei caratteri
personalizzati discusse nella sezione “Il vostro turno” dell’attività precedente. A seconda
del valore visualizzato, il programma memorizza una di cinque definizioni di carattere
differenti nel Carattere Personalizzato 2. Però, a differenza di CaratterePersEeprom.bs2,
il programma che segue non memorizza le definizioni di carattere personalizzato nella
EEPROM del BASIC Stamp. Invece, le definizioni sono derivate durante l’esecuzione
del programma, basandosi sul valore della variabile espressa nel grafico a barre.
La Figura 7-2 mostra come le definizioni vadano da uno spazio (Car0) a quattro colonne
verticali nere (Car4). Queste definizioni saranno memorizzate nella EEPROM, ed usate
una alla volta per ridefinire il carattere 2, poiché soltanto una di esse è necessaria in
qualsiasi dato istante. Ma al programma può servire di visualizzare copie multiple di un
carattere tutti-neri per numeri superiori a 10; per questo scopo, esso usa il Carattere
Personalizzato 3.
Car0
Car1
Car2
Car3
Car4
Figura 7-2
Libreria delle definizioni
per il Carattere
Personalizzato 2
Caratteri Personalizzati
Programma esempio: GrafBarreOrizzzontale.bs2
√
√
√
√
√
√
√
√
'
'
'
'
Digitate, memorizzate ed eseguite GrafBarreOrizzontale.bs2.
Cliccate sulla finestrella di trasmissione del terminale di Debug.
Digitate la cifra 8, quindi premete il tasto Invio.
Controllate il grafico a barre e accertatevi che il carattere più a sinistra sia nero, e
il successivo visualizzi il Car3.
Provate i valori indicati nella Figura 7-1.
Provate ora con 45, 46, 47, 48, 49, 50, 51, 52.
Esperimentate con limiti come 0, 80.
Provate con valori fuori dai limiti. Che cosa accade?
-----[ Titolo ]------------------------------------------------------------Sensori intelligenti e loro applicazioni - GrafBarreOrizzontale.bs2
Visualizza i valori digitati nella finestrella di Ricezione del Terminale di
Debug come grafico a barre orizzontale di dati nel LCD.
' {$STAMP BS2}
' {$PBASIC 2.5}
' Dispositivo di destinazione = BASIC Stamp 2
' Linguaggio
= PBASIC 2.5
' -----[ Pin I/O ]----------------------------------------------------------PinLcd
PIN
14
' pin I/O connesso a RX del LCD
' -----[ Costanti ]---------------------------------------------------------T9600
CON
84
ClsLcd
CrLcd
OffLcd
OnLcd
Riga0
Riga1
Definisce
CON
CON
CON
CON
CON
CON
CON
12
13
21
22
128
148
248
' Pagina nuova -> cancella schermo
' Ritorno Carrello
' Spegne (off) il display
' Accende (on) il display
indice
RigaPunt
cursore
valore
CntCar
riga
VAR
VAR
VAR
VAR
VAR
VAR
VAR
Nib
Nib
Byte
Nib
Byte
Byte
Byte
'
'
'
'
'
'
'
Selettore caattere personalizzato
Variabile indice Eeprom
linea puntinata a 5-pixel
Posizionamento Cursore
Valore da riportare in grafico.
Variabile conta Carattere
Riga0 o Riga1
' Distacca alimentazione
SEROUT PinLcd, T9600, [OnLcd, ClsLcd] ' Inizializza LCD
PAUSE 5
' ritardo di 5 ms per cancellare display
CarPers = 3
' Sceglie Carattere Personalizz. 3
RigaPunt = %11111
' Annerisce tutti i pixel in ogni riga
GOSUB Def_Car_Ist_Orizz
' subroutine che definisce carattere
riga = Riga0
' Grafico a barre in Riga 0.
DEBUG "Digita valori (da 0 a 80)", CR
DEBUG ">"
DEBUGIN DEC valore
GOSUB Grafico_a_barre
LOOP
' Ciclo principale
' Valore dalla finestrella di Trasmiss
' Visualizza come grafico a barre
' -----[ Subroutine – Grafico_a_barre ]---------------------------------------
Grafico_a_barre:
' Riempie da sinistra con barre nere
valore = valore MAX 80
CntCar = valore / 5
CarPers = 3
IF CntCar > 0 THEN
FOR cursore = 0 TO CntCar - 1
GOSUB Vis_Car_Pers
NEXT
ENDIF
'
'
'
'
'
'
valore limite – da 0 a 80
Numero di barre nere
Sceglie carettere person. nero
Se da vis. barre nere, allora
Visual. CntCar - 1 barre nere
Visualizza barra nera
' Visualizza Carattere Personalizzato 2 con un certo numero di colonne nere.
cursore = CntCar
' Posiziona cursore
CarPers = valore // 5
' Quanti quinti di barra?
' Sceglie cobinazione di bit per la definizione del carattere personalizzato
LOOKUP CarPers,
[%00000, %10000, %11000, %11100, %11110],
RigaPunt
CarPers = 2
' Imposta carattere personal. a 2
GOSUB Def_Car_Ist_Orizz
GOSUB Vis_Car_Pers
' Visualizza carattere personal.
' Sovrastampa tutto a destra con spazi.
IF (CntCar + 1) < 15 THEN
' Car parziale a sin. di car 15?
FOR cursore = (CntCar + 1) TO 15
' Riempie a destra con " "
[riga + cursore, " "]
NEXT
ELSEIF valore = 80 THEN
' Caso particolare: valore = 80
[riga + cursore, 3]
ELSEIF CntCar = 14 THEN
' Caso particolare: 75 <= valore <= 80
SEROUT PinLcd, T9600, [riga + 15, " "]
ENDIF
RETURN
' -----[ Subroutine - Def_Car_Bar_Orizz ]-----------------------------------Def_Car_Bar_Orizz:
FOR indice = 0 TO 7
SEROUT PinLcd, T9600, [RigaPunt]
NEXT
' Definisce carattere personalizzato
' Le invia al LCD
RETURN
' -----[ Subroutine - Vis_Car_Pers ]--------------------------------------'
'
'
'
Questa subroutine visualizza un carattere personalizzato. La variabile
riga può essere ipostata o a Riga0 o a Riga1, e la variabile cursore può
essere impostata ad un valore tra 0 e 15. La variabile CarPers sceglie uno
dei caratteri pers. del LCD e deve essere impostata ad un valore tra 0 e 7.
Vis_Car_Pers:
RETURN
' Visualizza carattere personalizzato
Come lavora GrafBarreOrizzontale.bs2
Il Carattere Personalizzato 2 del LCD è riservato per visualizzare una di cinque differenti
definizioni di carattere personalizzato, ma il Carattere Personalizzato 3 userà sempre la
stessa definizione, poiché ha tutti i suoi pixel neri. Con questo fatto in mente, alla
sezione Inizializzazione è stato aggiunto un blocco di codice che definisce il Carattere
Personalizzato 3 del LCD utilizzando la subroutine Def_Car_Bar_Orizz. Questa
subroutine fa 8 copie identiche della riga di 5-pixel memorizzata dalla variabile
RigaPunt per costruire il carattere personalizzato. Dopo questo, la variabile riga è
impostata per posizionare il cursore sulla riga superiore, e il programma visualizza una
domanda per l’utente "Digita valori (da 0 a 80)", seguita da un ritorno carrello.
CarPers = 3
RigaPunt = %11111
GOSUB Def_Car_Bar_Orizz
' Sceglie Carattere Personalizzato 3
' Annerisce tutti i pixel in ogni riga
' subroutine definisci carattere
riga = Riga0
' Grafico a barre su Riga 0.
DEBUG "Digita valori (0-80)", CR
La Routine principale è un ciclo DO...LOOP che visualizza ripetutamente la richiesta ">", e
che ottiene valori decimali digitati nella finestrella di trasmissione del terminale di
Debug. Poi richiama la subroutine Grafico_a_barre.
DEBUG ">"
DEBUGIN DEC valore
' Ciclo principale
' Valore dalla finestrella di Trasmissione
LOOP
La subroutine Grafico_a_barre prende qualsiasi cosa sia memorizzata nella variabile
valore e la rappresenta sul LCD come grafico a barre. Questa subroutine fa uso delle
due subroutine Def_Car_Pers e Vis_Car_Pers, introdotte nell’attività precedente. La
subroutine Grafico_a_barre ha tre funzioni principali:
1. Riempie tutti i caratteri neri da sinistra a destra. Per esempio, se la variabile
valore è impostata a 28, saranno anneriti cinque caratteri LCD (con 5 linee nere
verticali ciascuno).
2. Continuando con l’esempio, il sesto carattere LCD avrà tre linee verticali.
Ricordate, il Carattere Personalizzato 2 è usato per visualizzare una delle cinque
definizioni di carattere mostrate in Figura 7-2. Il numero di colonne nere nel
carattere è il resto dell’operazione valore // 5. Questo risultato sceglie una
configurazione di bit da una tabella LOOKUP e la copia nella variabile RigaPunt.
Poi CarPers è impostata a 2 e la subroutine Def_Car_Bar_Orizz copia questa
configurazione di bit in tutte le 8 righe del carattere. Dopo che il carattere è stato
ridefinito, può allora essere visualizzato.
3. Tutti i caratteri non necessari per rappresentare il valore sul grafico a barre
saranno cancellati con il carattere spazio " ". Nell’esempio valore = 28, ciò
significa cancellare ogni cosa tra la destra del sesto carattere e il 15.mo carattere.
Con l’unica necessità assoluta che se il contenuto precedente di valore è più
piccolo del valore attuale, il programma fa questo ad ogni occorrenza del ciclo.
Il primo compito della subroutine Grafico_a_barre è riempire di caratteri neri. La
variabile valore è prima di tutto fissata a 80 o meno. Quindi la variabile CntCar
memorizza il numero di caratteri neri da visualizzare, che è 1/5 del valore della variabile
valore. La variabile CarPers deve essere impostata uguale a tre, perché il Carattere
Personalizzato 3 memorizza il carattere nero. Se CntCar è maggiore di 0, ciò significa
che ci saranno da visualizzare alcuni caratteri tutto-nero, e un ciclo FOR...NEXT chiama
ripetutamente la subroutine Vis_Car_Pers. Ricordate, questa subroutine dipende da
due variabili: cursore e CarPers. Il valore di CntCar è stato impostato prima del ciclo
FOR...NEXT, e la variabile cursore è la variabile indice del ciclo FOR...NEXT. Ad ogni
iterazione del ciclo FOR...NEXT, la variabile cursore aumenta di 1, e questo fatto fa sì che
la subroutine Vis_Car_Pers posizioni il cursore un gradino a destra ogni volta che viene
richiamata, riempiendo così di caratteri neri da sinistra a destra.
' -----[ Subroutine – Grafico_a_barre ]-------------------------------Grafico_a_barre:
' Riempie con barre nere da sinistra
valore = valore MAX 80
CntCar = valore / 5
CarPers = 3
' Valore Limite – da 0 a 80
' Numero di barre nere
' Sceglie carattere person. nero
IF CntCar > 0 THEN
' Se da visualizz. barre nere allora
FOR cursore = 0 TO CntCar - 1 ' Visual. qui CntCar - 1 barre nere
GOSUB Vis_Car_Pers
' Visualizza la barra nera
NEXT
ENDIF
Il secondo passaggio è visualizzare quel carattere che è parzialmente nero. Il comando
cursore = CntCar vi assicura che il cursore è adesso proprio a destra dei caratteri neri
che sono stati stampati con un ciclo FOR...NEXT nel passaggio precedente. Quindi, il
comando CarPers = valore // 5 imposta la variabile CarPers al resto di (valore ÷
5). Ad esempio, se valore è 28, il resto di 28 ÷ 5 è 3. Se CarPers = 3, una tabella di
La subroutine
ricerca (lookup) memorizza %11100 nella variabile RigaPunt.
Def_Car_Bar_Orizz deve conoscere due cose per fare il suo lavoro: le variabili
RigaPunt e CarPers. Stiamo utilizzando e riutilizzando il Carattere Personalizzato 2
per definire e ridefinire il carattere parzialmente annerito. Quindi, prima di chiamare la
subroutine Def_Car_Bar_Orizz, CarPers deve essere modificata da 3 a 2 con il
comando CarPers = 2. Poi può essere richiamata la subroutine Def_Car_Bar_Orizz
per definire il carattere personalizzato, seguita dalla subroutine Vis_Car_Pers per
visualizzarlo.
' Visualizza il Carattere Personalizzato 2 con un certo numero di
' colonne nere.
cursore = CntCar
' Posiziona il cursore
CarPers = valore // 5
' Quanti quinti di una barra?
' Sceglie combinazione di bit per definizione carattere person.
LOOKUP CarPers,
[%00000, %10000, %11000, %11100, %11110],
RigaPunt
CarPers = 2
' Imposta carattere person. a 2
GOSUB Def_Car_Bar_Orizz
GOSUB Vis_Car_Pers
' Visualizza carattere personal.
La subroutine Def_Car_Bar_Orizz, richiamata dopo aver impostato il valore delle
variabili RigaPunt e CarPers è ciò che rende non necessaria la memorizzazione dei
caratteri personalizzati in EEPROM. C’è un motivo, se volete creare un carattere
personalizzato con parecchie colonne di pixel neri, tutto ciò che dovrete fare è inviare al
LCD lo stesso valore binario, otto volte in una riga. La variabile RigaPunt è una
variabile che memorizza la definizione binaria per le righe nel carattere personalizzato
riempito parzialmente. Se RigaPunt è %11000, le due colonne di pixel più a sinistra
diventano nere. Se RigaPunt è %11100, le tre colonne di pixel più a sinistra dventano
nere, e così via.
Def_Car_Bar_Orizz:
FOR indice = 0 TO 7
SEROUT PinLcd, T9600, [RigaPunt] ' Le invia al LCD
NEXT
RETURN
Sovrascrivere qualsiasi carattere nero a destra del carattere visualizzato al passaggio 2
non interessa qualsiasi carattere personalizzato poiché il carattere spazio " " fa un buon
lavoro di cancellazione. Per la maggior parte dei casi, un ciclo FOR...NEXT che scriva dal
(CntCar + 1) a (TO) 15 cancella ogni cosa che si trovi a destra. Però esistono alcuni
casi particolari che si verificano quando il 15-mo carattere ha una o più colonne nere. Se
valore = 80, una precedente parte di questo programma scriverà un carattere spazio in
posizione-0. Posizione-0 dovrebbe essere nero, quindi il blocco di codice ELSEIF
valore = 80 sostituirà quel carattere spazio con uno nero. Inoltre, se CntCar è 14, in
posizione 15 deve essere scritto un solo carattere vuoto.
' Sovrascrive tutto ciò che è a destra con spazi.
IF CntCar + 1 < 15 THEN
' Carattere parziale a sinistra del car 15?
FOR cursore = (CntCar + 1) TO 15 ' Riempie a destra con " "
[Riga0 + cursore, " "]
NEXT
ELSEIF valore = 80 THEN
[Riga0 + cursore, 3]
ELSEIF CntCar = 14 THEN
' Caso particolare: 75 <= valore <= 80
SEROUT PinLcd, T9600, [Riga0 + 15, " "]
ENDIF
RETURN
Il vostro turno – Visualizzare graficamente la distanza col sensore Ping)))
Visuallizzare un grafico a barre orizzontale che indichi distanze fino a 80 cm è facile se si
dispone di un sensore Ping))) e del LCD seriale Parallax. Il trucco è prendere le
componenti dal programma MisuraCmPing.bs2, e incorporarle entro una copia del
programma GrafBarreOrizzontale.bs2 di questa attività.
√
√
√
√
√
√
√
Seguite le istruzioni per collegare il sensore Ping))) e il LCD seriale alla vostra
scheda. Sono nel Capitolo 2, Attività #4, pagina 54.
Aprite MisuraCmPing.bs2 dal Capitolo 2, Attività #2 (pagina 50) nel vostro
Editor BASIC Stamp.
Aprite GrafBarreOrizzontale.bs2 (in questa attività), e memorizzatelo con il
nome GrafBarrePing.bs2.
Ombreggiate e coprite le direttive CON e VAR dal MisuraCmPing.bs2, e
incollatele nelle sezioni CON e VAR del GrafBarrePing.bs2.
Sostituite i comandi DEBUG e DEBUGIN nel ciclo DO...LOOP della Routine
principale del GrafBarrePing.bs2 con i comandi nel ciclo DO...LOOP di
MisuraCmPing.bs2.
Aggiungere un comando proprio prima di GOSUB Grafico_a_barre che imposta
la variabile valore uguale a DistanzaCm.
Quindi spostate il commando PAUSE 100 in modo che sia proprio prima di LOOP.
Ora, la Routine principale di GrafBarrePing.bs2 dovrebbe somigliare a questa:
' -----[ Routine principale]------------------------------------------DO
' Ciclo principale
PULSOUT 15, 5
PULSIN 15, 1, tempo
valore = DistanzaCm
PAUSE 100
LOOP
√
Memorizzate il programma modificato, provatelo, e verificate che funziona.
Potete anche sostituire il comando DEBUG con un comando SEROUT che visualizza le
misure sulla riga inferiore. Ricordate che dovrete inviare al LCD un codice di controllo
per posizionare il cursore sulla Riga 1 carattere-0, invece di utilizzare HOME.
√
Provatelo!
ATTIVITÀ #3: GRAFICO A BARRE A DUE ASSI PER L’INCLINAZIONE
DELL’ACCELEROMETRO
Questa attività sviluppa un grafico a barre a due assi, utile per la visualizzazione grafica
delle misure di inclinazione dell’accelerometro.
Parti e apparecchiatura
Usate il circuito tratto dal Capitolo 3, Attività #2, pagina 76.
Caratteri personalizzati per grafico a barre verticale
La subroutine Def_Car_Bar_Vert nel programma esempio che segue definisce uno
qualsiasi dei 16 differenti caratteri barra verticale personalizzati. La Figura 7-3 mostra
come ciascun carattere barra corrisponda a un valore.
Figura 7-3
Valori di carattere
per grafico a barre
verticali
Le definizioni di carattere personalizzato in Figura 7-3 seguono una sequenza che si
riferisce direttamente ai valori che rappresentano, in modo che le definizioni possono
essere calcolate in base alle necessità piuttosto che essere memorizzate nella EEPROM.
Poiché ciascun carattere personalizzato prende otto byte, eliminare 16 definizioni farà
risparmiare 128 byte di memoria di programma.
La subroutine Def_Car_Bar_Vert definisce i caratteri mostrati nella Figura 7-3. La
variabile valore definisce quale dei caratteri da 0 a 15 sarà visualizzato. Cascun bit
nella variabile MapRiga determina se una delle righe nel carattere personalizzato è nera o
bianca.
Def_Car_Bar_Vert:
MapRiga = %1111111100000000 >> (valore & %1111)
FOR indice = 0 TO 7
IF MapRiga.LOWBIT(indice) = 1 THEN
SEROUT PinLcd, T9600, [%11111]
ELSE
ENDIF
NEXT
RETURN
Il comando MapRiga = %1111111100000000 >> (valore & %1111) sposta gli otto
bit 1 in %1111111100000000 a destra del valore nella variabile valore. Il termine
(valore & %1111) è chiamato maschera di bit, e rende possible l’uso di valori da 16 a
31 per darvi gli stessi risultati dei valori tra 0 e 15. Se valore è 3, il comando MapRiga
= %1111111100000000 >> (valore & %1111) memorizza %0001111111100000
nella variabile MapRiga. Dal momento che MapRiga è una variabile a un solo byte, essa
memorizza soltanto gli otto bit meno significativi del termine, cioè %11100000.
Confrontate questo col carattere personalizzato indicato con 3 in Figura 7-3. Se valore è
4, il byte basso (meno significativo) che risulta nella variabile MapRiga è %11110000.
Ora, date un’occhiata al carattere 4 in Figura 7-3. Provate la stessa cosa per ciascun
valore (da 0 a 15) e vedrete lo schema dei bit nel byte MapRiga corrisponde allo schema
delle righe con pixel neri nella Figura 7-3.
Definire un carattere personalizzato comporta l’invio di otto byte. I valori binari in
ciascuno dei byte successivi definiscono ciascuna delle otto righe nel carattere, dalla testa
al fondo. Il ciclo FOR...NEXT nella subroutine Def_Car_Bar_Vert ha un blocco di
codice IF...THEN che usa l’operatore .LOWBIT per controllare ciascun bit nella variabile
MapRiga e lo usa per definire una riga di 5 pixel sia neri che bianchi nel carattere
personalizzato. Diciamo che quel valore sia 3, e quindi MapRiga è %11100000. La
prima iterazione del ciclo FOR...NEXT, indice è 0, in modo che l’istruzione IF...THEN
esamina MapRiga.LOWBIT(0), il bit più a destra. Poiché questo è 0, l’istruzione
IF...THEN invia un byte contenente %00000 al LCD, che rende tutti i pixel bianchi. Nella
sesta iterazione del ciclo FOR...NEXT, MapRiga.LOWBIT(5) = 1, quindi l’istruzione
IF...THEN invia un comando SEROUT con un byte contenente %11111. Pertanto, la sesta,
la settima e l’ottava riga in basso saranno nere, e questo produce come risultato il
carattere mostrato nella Figura 7-3 alla posizione 3.
SEROUT 14, 84, [%11111] invia in realtà il byte %00011111, e i cinque bit più in
basso sono quelli che il LCD utilizza per definire le sue righe larghe cinque pixel.
Programma Esempio: ProvaBarreVerticali.bs2
Questo programma esempio visualizza i 16 differenti caratteri personalizzati barra
verticale sulla Riga 0, carattere-8 del LCD seriale Parallax. Fa questo in una successione
rapida, ripetendo la visualizzazione sempre daccapo. Visualizza anche il numero che la
variabile valore memorizza nel terminale di Debug.
√
√
√
√
'
'
'
'
Aprite ProvaBarreVerticali.bs2 nell’Editor del BASIC Stamp.
Eseguitelo e verificate che siano visualizzati tutti i caratteri personalizzati della
Figura 7-3.
Aumentate l’argomento Duration (Durata) del comando PAUSE.
Rieseguite il programma e verificate che le barre nel LCD rappresentino
correttamente i numeri visualizzati nel terminale di Debug.
-----[ Titolo ]------------------------------------------------------------Sensori intelligenti e loro applicazioni – ProvaBarreVerticali.bs2
Visualizza sedici carateri barra verticale differenti sulla Riga 0,
carattere-8 del LCD seriale Parallax.
' {$STAMP BS2}
' {$PBASIC 2.5}
' Dispositivo di arrivo = BASIC Stamp 2
' Linguaggio
= PBASIC 2.5
' -----[ Pin I/O ]----------------------------------------------------------PinLcd
PIN
14
' pin I/O connesso ad RX del LCD
' -----[ Costanti ]---------------------------------------------------------T9600
CON
84
ClsLcd
CON
12
' Nuova pagina -> cancella schermo
LcdOn
Riga0
Riga1
Definisce
CON
CON
CON
CON
22
128
148
248
' Accende (on) il display
indice
MapRiga
cursore
valore
riga
VAR
VAR
VAR
VAR
VAR
VAR
Byte
Nib
Byte
Byte
Byte
Byte
'
'
'
'
'
'
selettore del carattere personal.
variabili indice della Eeprom
riga di punti di 5-pixel
posizionamento cursore
Valore da riporare in grafico
Riga0 o Riga1
' -----[ Inizializzazione ]--------------------------------------------------' inizializzazione del LCD.
PAUSE 100
' Disabilita alimentazione elettr.
SEROUT PinLcd, T9600, [LcdOn, ClsLcd]
PAUSE 5
' subroutine valori carattere personalizzato.
CarPers = 3
' Usa il carattere personal. 3
riga = Riga0
' Cursore in Riga0
cursore = 7
' Cursore all’8.vo carattere
FOR valore = 0 TO 16
DEBUG ? valore
GOSUB Def_Car_Bar_Vert
GOSUB Vis_Car_Pers
PAUSE 50
NEXT
DEBUG CR, CR
PAUSE 500
LOOP
' Ciclo principale
' valore conta da 0 a 16
' Visualizza valore in terminale Debug
' Definisce carattere grafico barra
' Visualizza carattere su LCD
' Rallenta il ciclo
' Spazi prima di sequenza successiva
' Ritardo prima di sequenza successiva
' -----[ Subroutine - Def_Car_Bar_Vert]------------------------------------' Definisce un carattere grafico barra verticale basato sulla variabile valore
' (da 0 a 15) e sulla variabile CarPers, che sceglie i caratteri personalizz.
' tra 0 e 7 del LCD seriale Parallax.
Def_Car_Bar_Vert:
' Inizia a definire il carattere personalizzato
' Sceglie la mappa di una riga per il carattere personalizzato basandosi
' sul valore.
MapRiga = %1111111100000000 >> (valore & %1111)
' Invia 8 byte, ciascuno che definisce una riga di punti nel carattere pers.
' Ciascna riga è determinata dall’esame di un bit nella variabile MapRiga,
' e quindi inviando %11111 se il bit è 1, o %00000 se il bit è 0.
FOR indice = 0 TO 7
' Ripete 7 volte, indice conta
' Esamina bit seguente in MapRiga
' Se 1, invia %11111
ELSE
' Altrimenti, invia %00000
ENDIF
NEXT
' Ritorno dalla subroutine.
RETURN
' -----[ Subroutine - Vis_Car_Pers ]--------------------------------------'
'
'
'
può essere posta sia a Riga0 che a Riga1, e la variabile cursore può essere
posta ad un valore tra 0 e 15. La variabile CarPers sceglie uno dei caratteri personalizzati del LCD e dovreà essere posta ad un valore tra 0 e 7.
Vis_Car_Pers:
RETURN
' Scrive carattere personalizzato
Il vostro turno - 31 Livelli che coprono due righe e aggiunta di un asse
orizzontale
Il comando che imposta lo schema di bit nella variabile MapRiga era il seguente:
MapRiga = %1111111100000000
>>
(valore
&
%1111).
Il calcolo
valore & %1111 darà come risultato 0 se valore è 16, 1 se valore è 17, e così via fino
a 15 se valore è 31. Continuerà su questo schema indipendentemente da quanto grande
diventi valore. Dal momento che il grafico a barre si comporterà nello stesso modo, per
valori tra 16 e 31, di come fa per i valori tra 0 e 15, il grafico a barre può essere
posizionato sia nella riga superiore, sia in quella inferiore per indicare tra quali intervalli
cade la variabile valore. L’intervallo reale di visualizzazione è tra 1 e 31, con il valore
16 che non mostra alcuna barra.
Modificare il programma per visualizzare caratteri in questo modo comporta soltanto
pochi cambiamenti alla Routine principale. Prima di tutto, gli argomenti StartValue ed
EndValue del ciclo FOR...NEXT dovranno essere cambiati da (0 - 15) a (1 - 31). Inoltre, si
dovrà aggiungere un comando SEROUT per sovrascrivere con spazi i caratteri
personalizzati precedenti.
Quindi, si può aggiungere un blocco di codice
IF...THEN...ELSE che posizionerà il cursore o sulla Riga 0 o sulla Riga 1. Deve
posizionare il cursore sulla Riga 0 quando il valore è maggiore di 16, oppure sulla riga
inferiore quando il valore è minore o uguale a 16.
√
√
√
Memorizzate
il
programma
ProvaBarreVerticali.bs2
col
nome
ProvaBarreVerticaliVostroTurno.bs2.
Modificate il ciclo DO...LOOP nella Routine principale come mostrato sotto.
Eseguite il programma e verificate che il grafico a barre ora visualizzerà 31
livelli differenti, da 1 a 31.
DO
SEROUT 14, 84, [Riga0 + cursore, " ",
Riga1 + cursore, " "]
IF valore <= 16 THEN
riga = Riga1
ELSE
riga = Riga0
ENDIF
DEBUG ? valore
GOSUB Vis_Car_Pers
PAUSE 50
NEXT
DEBUG CR, CR
PAUSE 500
LOOP
Potete anche annidare il ciclo FOR valore = 1 TO 31...NEXT entro un ciclo FOR
cursore = 0 TO 15...NEXT, e far muovere il grafico a barre attraverso il display ogni
volta che viene ripetuto. Controllando in questo modo l’offset del cursore, il grafico a
barre può visualizzare due assi con valori verticali da 1 a 31 e valori orizzontali da 0 a 15.
√
Provatelo!
Una visualizzazione a due assi
Dopo che la precedente sezione “Il vostro turno” vi ha mostrato come visualizzare
caratteri su due assi, un display completamente vuoto non comunica in realtà che il valore
è a metà del suo intervallo. Un modo migliore di ottenere questo messaggio è fare in
modo che due caratteri personalizzati appaiano l’uno di seguito all’altro. La Figura 7-4 vi
mostra come funziona. I primi due esempi di visualizzazione non sono a metà
dell’intervallo sia orizzontale che verticale, quindi vengono visualizzati singoli caratteri.
Il terzo esempio è a metà dell’intervallo orizzontale (8), quindi la misura verticale è
visualizzata su due caratteri adiacenti. Il quarto esempio mostra che la misura è a metà
del suo intervallo verticale, quindi le righe sia nel carattere superiore che in quello
inferiore hanno pixel neri. Quando la misura è centrata sia in orizzontale che in verticale
il quinto esempio mostra in che modo dovrebbe apparire. Queste caratteristiche sono
particolarmente importanti per l’indicazione grafica di quando uno o entrambi gli assi
dell’accelerometro sono a livello.
Orizzontle Verticale
Figura 7-4
Punti disegnati
in un diagramma
a barre a due assi
Mentre le caratteristiche mostrate in Figura 7-4 rendono il display un pò meno criptico, il
programma deve assumere molte più decisioni. Nel programma esempio che segue, le
subroutine Graf_Barre_O_V e Posizionamento_Orizzontale si assumono tutte le
decisioni che comportano queste caratteristiche extra.
Programma esempio: VisualBarDueAssi.bs2
Scarico gratuito! Questo programma è disponibbile come file .bs2 scaricabile
gratuitamente dalla pagina di prodotto “Smart Sensors and Applications” al sito
www.parallax.com.
Potete provare questo programma esempio inserendo le coordinate orizzontali e verticali
nella finestrella di trasmissione del terminale di Debug.
√
√
√
√
√
Aprite ed eseguite VisualBarDueAssi.bs2 col vostro Editor BASIC Stamp.
Digitate valori nell’intervallo da 0 a 16 per l’asse orizzontale e valori
nell’intervallo da 1 a 31 per l’asse verticale, ed osservate i risultati visualizzati
dal LCD.
Provate i valori indicati in Figura 7-4 e verificate che essi si accordano con le
visualizzazioni.
Assicuratevi di provare i valori orizzontali 0, 8, e 16 con vari valori verticali.
Provate anche i valori verticali 1, 16, e 31 con vari valori orizzontali.
Un altro modo di provare la visualizzazione è con la routine principale alternativa
mostrata qui sotto. Questa routine ha cicli FOR...NEXT annidati che provano qualsiasi
variabile valore con tutti i possibili valori della variabile cursore.
√
√
Memorizzate
una
copia
di
VisualBarDueAssi.bs2
col
nome
ProvaVisBarDueAssi.bs2.
Eseguite il programma modificato e osservatene il funzionamento per assicurarvi
che tutti i valori siano visualizzati correttamente.
' -----[ Routine principale]------------------------------------------DO
FOR cursore = 0 TO 16
GOSUB Graf_Barre_O_V
PAUSE 200
NEXT
SEROUT 14, 84, [ClsLcd]
PAUSE 500
NEXT
LOOP
' -----[ Titolo ]------------------------------------------------------------' Sensori intelligenti e loro applicazioni - VisualBarreDueAssi.bs2
' Visualizza un carattere che si sposta sia verticalmente che orizzontalmente.
' {$STAMP BS2}
' {$PBASIC 2.5}
' Linguaggio
= PBASIC 2.5
' -----[ Pin I/O ]----------------------------------------------------------PinLcd
PIN
14
' -----[ Costanti ]---------------------------------------------------------T9600
ClsLcd
CrLcd
LcdOff
LcdOn
Riga0
Riga1
Definisce
CON
CON
CON
CON
CON
CON
CON
CON
84
12
13
21
22
128
148
248
'
'
'
'
'
'
'
Nuova pagina -> cancella schermo
Ritorno carrello (a capo)
Spegne (off) display
Accende (on) display
Riga 0, carattere 0
Riga 1, carattere 0
Indirizzo di defin. car. pers. 0
indice
MapRiga
cursore
valore
riga
VAR
VAR
VAR
VAR
VAR
VAR
Byte
Nib
Byte
Byte
Byte
Byte
' Selettore carattere personalizzato
' variabile indice Eeprom
' riga puntinata a 5-pixel
' posizionamento cursore
' Valore da riportare in grafico
' Riga0 o Riga1
PAUSE 5
' Scollega alimentazione elettr.
' Inizializza LCD
' ritardo 5 ms per cancellaz. display
DEBUG "Digita valore oriz-",
CR, "zontale (0 a 16)"
DEBUGIN DEC cursore
DEBUG "Digita valore ver-",
CR, "ticale (1 a 31)"
DEBUGIN DEC valore
' Ciclo principale
' Richiesta offset carattere
' Ottiene offset carattere
' Chiede valore a utente
' Ottiene valore
' Richiama Graf_Barre_O_V
LOOP
' -----[ Subroutine - Graf_Barre_O_V ]--------------------------------------' Definisce e visualizza caratteri per grafico a barre a due assi basati sul
' valore del cursore (da 0 a 16) e sul valore (da 1 a 31). Richiama
' Def_Car_Bar_Vert, e Posizionamento_Orizzontale.
Graf_Barre_O_V:
PAUSE 5
' Cancella precedente grafico
' ritardo 5 ms per cancellaz. display
' Decide wse visualizzare su Riga 0 o Riga 1.
IF valore >= 16 THEN riga = Riga0 ELSE riga = Riga1
GOSUB Posizionamento_Orizzontale
IF valore = 16 THEN
' caso particolare: valore = 16
valore = 1
CarPers = 2
riga = Rigae0
' display su Riga 0
valore = 15
CarPers = 3
riga = Riga1
valore = 16
' Display su Riga 1
' Ripristina valore
ENDIF
RETURN
' -----[ Subroutine - Def_Car_Bar_Vert ]------------------------------------' Definisce un carattere grafico barra verticale basato sulla variabile valore
' (da 0 a 15) e sulla variabile CarPers, che sceglie i caratteri personaliz' zati del LCD seriale Parallax tra 0 e 7.
Def_Car_Bar_Vert:
' Sceglie una mappa di riga per carattere personalizzato basata su valore.
MapRiga = %1111111100000000 >> (valore & %1111)
' Invia 8 byte, ciascuno che definisce una riga di punti nel carattere pers.
' Ogni riga è determinata esaminando un bit nella variabile MapRiga, e poi
' inviando %11111 se il bit è 1, o %00000 se il bit è 0.
FOR indice = 0 TO 7
' Esamina success. bit in MapRiga
SEROUT 14, 84, [%11111]
' If 1, invia %11111
ELSE
SEROUT 14, 84, [%00000]
ENDIF
NEXT
RETURN
' Ritorno dalla subroutine
' -----[ Subroutine – Posizionamento_Orizzontale ]---------------------------' Posiziona il grafico a barre verticale ad una delle sedici colonne verticali
' del LCD 2X16 Parallax. La variabile cursore può porre la posizione orizzon' tale a valori tra 0 e 16, con 8 al centro. Richiama Vis_Car_Pers.
Posizionamento_Orizzontale:
SELECT cursore
CASE 0 TO 7
GOSUB Vis_Car_Pers
CASE 8
cursore = 7
GOSUB Vis_Car_Pers
cursore = 8
GOSUB Vis_Car_Pers
CASE 9 TO 16
cursore = cursore - 1
GOSUB Vis_Car_Pers
cursore = cursore + 1
ENDSELECT
' Cursore da 0 a 7, nessun cambio
' Cursore 8, visualizza a 7 & 8
' Cursore da 9 a 16, visual. 1 a sin.
RETURN
' -----[ Subroutines - Visp_Car_Pers ]--------------------------------------'
'
'
'
Questa subroutine visualizza un carattere personalizzaro. La variabile riga
può essere posta sia a Riga0, sia a Riga1, e la variabile cursore può essere
impostata a un valore tra 0 e 15. La variabile CarPers sceglie uno dei caratteri personalizzai del LCD e deve essere posta a un valore tra 0 e 7.
Vis_Car_Pers:
RETURN
Il vostro turno – Visualizzazione grafica a due assi dell’inclinazione
Indicare l’inclinazione col programma VisualBarreDueAssi.bs2 comporta l’uso di
comandi PULSIN per acquisire le misure sugli assi x ed y dell’accelerometro. Richiede
anche la riduzone in scala (scalatura) e l’offset per adattare le misure dell’acceleromatro
in una scala verticale di 31 e una scala orizzontale di 17.
La scala orizzontale deve essere inoltre rovesciata. La Figura 7-5 mostra come gli assi x
ed y dell’accelerometro vengano rapportati agli assi orizzontale e verticale del LCD.
Notate che la direzione dell’asse y positivo punta fuori dalla direzione in cui i valori
sull’asse orizzontale del LCD crescono. Ogni volta che il valore dell’asse y scalato è 16,
il display dovrà mostrare 0, e ogni volta che il valore dell’asse y scalato è 0, il display
dovrà mostrare 16. Il modo per correggere questo fatto è utilizzare una istruzione che
sottrae da 16 il valore dell’asse y scalato. Essenzialmente, questo conduce alla istruzione
cursore = 16 − (valore di y scalato).
Figura 7-5: Assi X ed Y dell’Accelerometro
Asse x
Asse
y
Questo semplicissimo modo per convertire VisualBarreDueAssi.bs2 in uno strumento per
livellare un accelerometro a due assi consiste nel prendere a prestito blocchi di codice dal
Capitolo 3 e modificarli secondo necessità. Le variabili degli assi x ed y, i comandi
PULSIN, e i comandi di scalatura ed offset contenuti in InclinOrizzontale.bs2 nel Capitolo
3, Attività #6 forniscono un punto di partenza. I comandi PULSIN e di scalatura possono
sostituire i comandi DEBUG e DEBUGIN nella routine principale del programma
VisualBarreDueAssi.bs2. La subroutine Graf_Barre_O_V usa le variabili valore e
cursore per tracciare un grafico sul LCD. Prima di poterla richiamare, occorre che
valore sia impostata uguale al valore dell’asse x scalato, e cursore sia impostata uguale
al valore dell’asse y scalato, sottratto da 16.
La derivazione delle costanti ** di scalatura è lasciata come esercizio alla fine di questo
capitolo.
√
√
Memorizzate VisualBarreDueAssi.bs2 come VisInclinBarreDueAssi.bs2.
Aggiungete queste due dichiarazioni alla sezione Variabili del programma.
X
y
√
VAR
VAR
Word
Word
' asse x dell’Accelerometro
' asse y dell’Accelerometro
Sostituite il ciclo DO...LOOP più esterno nella routine principale con:
DO
' Ciclo principale
PULSIN 6, 1, x
PULSIN 7, 1, y
valore = (x MIN 1875 MAX 3125) - 1875 ** 1625 + 1
cursore = 16 - ((y MIN 1875 MAX 3125) - 1875 ** 891)
LOOP
√
' Richiama Graf_Barre_O_V
Memorizzate ed eseguite il programma, e provatelo per una varietà di situazioni
di inclinazione.
SOMMARIO
Entrambe le misure di distanza ed inclinazione conducono a visualizzazioni con grafici a
barre. La maggior parte dei grafici a barre si può fare utilizzando soltanto uno o due
degli otto slot di memoria per carattere personalizzato del LCD seriale Parallax. Le
definizioni di carattere personalizzato per i grafici a barre possono essere sia memorizzate
nella EEPROM del BASIC Stamp, sia definite da codice che rapporta il valore da
riportare in grafico al numero di righe o colonne di pixel che occorre visualizzare.
La memorizzazione di caratteri personalizzati in EEPROM comporta l’uso di direttive
DATA che contengono otto byte ciascuna. I cinque bit meno significativi di ciascun byte
memorizzano lo schema di bit per ciascuna delle otto righe (larghe cinque pixel) che
formano un carattere. I nomi Symbol che precedono le direttive DATA rendono possibile
copiare l’indirizzo di partenza dei byte di una direttiva DATA in una variabile. Una
subroutine può utilizzare la variabile che memorizza l’indirizzo di partenza per
operazioni READ che copiino in sequenza byte in una variabile, e qindi inviare i contenuti
di quella variabile al LCD.
Visualizzare grafici a barre è tipicamente più efficiente in termini di memoria se i
caratteri si possono generare basandosi sul valore. Quando il grafico a barre è orizzontale,
un comando LOOKUP è utile per memorizzare valori binari corrispondenti al numero di
colonne di un dato carattere personalizzato che avranno pixel neri. Per grafici verticali, i
bit possono essere spostati entro una variabile. In entrambi i casi, alcune subroutine
possomo esaminare i bit in una variabile, quindi annerire pixel in un certo numero di
righe o colonne in un carattere.
Domande
1. Quale parte delle direttive DATA rende possibile trovare l’indirizzo iniziale di una
definizione di carattere?
2. Come fanno i programmi di questo capitolo a dire alla subroutine
Def_Car_Pers quale carattere definire e dove trovare la definizione del
carattere? Come si specifica la posizione di un carattere per la subroutine
Vis_Car_Pers? Se volete visualizzare due caratteri personalizzati differenti
contemporaneamente, potete usare la stessa definizione di carattere
personalizzato? Perché?
3. Come fa il programma GrafBarreOrizz.bs2 a memorizzare informazioni su quale
colonna di un carattere personalizzato dovrà avere pixel neri o bianchi?
4. Potete usare soltanto un byte invece di otto per definire un carattere
personalizzato con alcune colonne nere?
5. Che cosa fa l’istruzione IF MapRiga.LOWBIT(indice) = 1 THEN... nel
programma ProvaBarreVerticali.bs2?
6. Perché potete usare soltanto un byte invece di otto per definire un carattere
personalizzato con alcune colonne nere?
7. Come opera l’istruzione IF MapRiga.LOWBIT(indice) = 1 THEN... nel
programma ProvaBarreVerticali.bs2?
Esercizi
1. Scrivete una direttiva DATA di carattere personalizzato per un carattere con tutte
strisce orizzontali.
2. Derivate il valore 1625 nel comando valore = (x MIN 1875 MAX 3125) 1875 ** 1625 + 1.
Progetti
1. Modificate il programma GrafBarrePing.bs2 in modo che visualizzi la misura
della distanza in centimetri sulla riga inferiore.
2. Modificate il programma VisualInclinBarreDueAssi.bs2 in modo che visualizzi
barre che corrispondano all’angolo di inclinazione. Ricordate che l’angolo di
inclinazione è una funzione della gravità sentita da ciascuno dei due assi
dell’accelerometro. Suggerimento: usate il codice esempio del Capitolo 3,
Attività #6 per i calcoli dell’angolo di inclinazione.
Soluzioni
Q1. Il nome Symbol.
Q2. I programmi debbono impostare due variabili prima di richiamare la
subroutine Def_Car_Pers: CarPers e carBase. La variabile CarPers
deve memorizzare il valore che il programma userà per dire al LCD di
visualizzare il carattere personalizzato. Le definizioni di carattere
personalizzato del LCD possono essere un valore tra 0 e 7, per cui CarPers
deve cadere in questo intervallo. Il nome Symbol nella direttiva DATA deve
essere memorizzato nella variabile carBase. Poiché variabile =
NomeSymbol memorizza l’indirizzo di EEPROM del primo byte in una
direttiva DATA definita da NomeSymbol entro la variabile, questo rende
possibile passare l’indirizzo di partenza di una direttiva DATA di carattere
personalizzato alla subroutine Def_Car_Pers.
Q3. Impostare i valori delle variabili cursore e riga prima di richiamare la
subroutine. La routine Vis_Car_Pers posizionerà il cursore usando queste
due variabili prima di dire al LCD di visualizzare il carattere personalizzato
in quella posizione.
Q4. No, perché tutte le occorrenze dello stesso carattere personalizzato
visualizzato correntemente dal LCD saranno aggiornate non appena venga
aggiornata la definizione del carattere.
Q5. La variabile RigaPunt termina memorizzando uno di cinque valori:
%00000, %10000, %11000, %11100, o %11110. Ciascuna cifra
corrisponde ad una delle cinque colonne verticali di pixel in un carattere
personalizzato. Se il valore è 1, i pixel in quella colonna saranno posti a
nero. Se è 0, saranno lasciati bianchi.
Q6. Ciascuna delle otto righe nella definizione del carattere personalizzato avrà
lo stesso schema (di bit), quindi il programma dovrà soltanto inviare lo
stesso byte di riga otto volte per definire ciascuna riga del carattere
personalizzato.
Q7. Quando la condizione IF…THEN vale 1, i pixel per la riga sono impostati a
nero con il comando SEROUT 14, 84, [%11111]; altrimenti, sono
impostati a bianco con il comando SEROUT 14, 84, [%00000].
Strisce
DATA
%11111,
%00000,
%11111,
%00000,
%11111,
%00000,
%11111,
%00000
'
'
'
'
'
'
'
'
* * * * *
* * * * *
* * * * *
* * * * *
E2. La meta della espressione valore = (x MIN 1875 MAX 3125) - 1875 **
1625 + 1 nella Attività #3 è di scalare il valore dell’asse x dell’accelerometro,
che potrebbe essere un numero qualsiasi tra 1875 e 3125, ad un valore da 1 a 31.
Questo preleverà una delle 31 possibilità di grafico a barre verticali per la
subroutine Graf_Barre_O_V. Non appena viene raggiunto l’operatore **, 1875
è già stato sottratto, quindi l’intervallo è da 0 a 1250 (1251 elementi della scala
di ingresso), e vogliamo scalare questi ad un intervallo tra 1 e 31 (31 elementi
della scala di uscita). Dal Capitolo 3, Attività #3, sappiamo che **
CostanteScala = Int[65536 × (elementi scala uscita ÷ (elementi scala ingresso –
1))]. Quindi, si ottiene Int[65536 × (31 ÷ (1251 – 1))] = Int[65536 × (31 ÷
1250)] = Int[65536 × 0.0248] = Int[1625.2928] = 1625.
P1. Soluzione esempio – routine principale da GrafBarrePing.bs2 modificata.
' Ciclo principale
PULSOUT 15, 5
PULSIN 15, 1, tempo
valore = DistanzaCm
GOSUB Graf_Barre
SEROUT 14, 84, [Riga1, DEC4 valore, ' Visualizza misura in cm
" cm"]
' sulla Riga 1
PAUSE 100
LOOP
P2. Soluzione esempio – Vedete i commenti nella sezione titolo per come è stato
costruito questo programma da precedenti programmi esempio e calcoli illustrati
nel testo:
'
'
'
'
'
'
'
'
'
'
'
-----[ Titolo ]------------------------------------------------------------Sensori intelligenti e loro applicazioni - Cap7Progetto2.bs2
Visualizza un carattere che sposta sia verticalmente che orizzontalmente
basato sull’angolo di inclinazione in gradi del MX2125. Questo programma è
una combinazione di InclinOrizzontale.bs2 dal Capitolo 3, Attività #6 e
VisualInclinBarreDueAssi.bs2 dal Capitolo 7, Attività #3. La misura sull’asse x è stata cambiata da -90 a +90 gradi a un valore da 1 a 31 usando l’equa
zione ** costante scala. Analogamente, la misura sull’asse y tra -90 e +90
gradi è stata cambiata ad un valore tra 0 e 16. I calcoli sono commentati e
mostrati nella routine principale proprio prima del loro utilizzo con
gli operatori **.
' {$STAMP BS2}
' {$PBASIC 2.5}
' Disppositivo scelto = BASIC Stamp 2
' Linguaggio
= PBASIC 2.5
' -----[ Pin I/O ]----------------------------------------------------------PinLcd
PIN
14
' -----[ Costanti ]---------------------------------------------------------T9600
ClsLcd
CrLcd
LcdOff
LcdOn
Riga0
Riga1
Definisce
Negativo
Positivo
CON
CON
CON
CON
CON
CON
CON
CON
CON
CON
84
12
13
21
22
128
148
248
1
0
'
'
'
'
'
'
'
'
'
Vero, 8-bit, senza parità, 9600
Nuova pagina -> cancella schermo
Ritorno carrello (a capo)
Spegne (off) il display
Accende (on) il display
Riga 0, carattere 0
Riga 1, carattere 0
Indirizzo che definisce car pers. 0
Segno - .bit15 delle variabili Word
indice
MapRiga
cursore
valore
riga
x
y
seno
lato
angolo
segno
VAR
VAR
VAR
VAR
VAR
VAR
VAR
VAR
VAR
VAR
VAR
VAR
Byte
Nib
Byte
Byte
Byte
Byte
Word
Word
Word
Word
Word
Bit
'
'
'
'
'
'
Selettore carattere personalizzato
variabile indice Eeprom
riga di punti di 5-pixel
Posizionamento cursore
Valore da riportare in grafico
Riga0 o Riga1
'
'
'
'
seno in un cerchio con r = 127
angolo risultante - gradi
bit del segno
' Disattiva alimentazione elettrica
' Inizializza LCD
PAUSE 5
' Ciclo principale
PULSIN 6, 1, x
PULSIN 7, 1, y
x = (x MIN 1875 MAX 3125) - 1875 ** 13369 - 127
y = (y MIN 1875 MAX 3125) - 1875 ** 13369 - 127
lato = x
GOSUB Arcoseno
' Int[65536 * (31 / (181 - 1))] = 11286
valore = angolo + 90 ** 11286 + 1
lato = y
GOSUB Arcoseno
' Int[65536 * (17 / (181 - 1))] = 6189
cursore = 16 - (angolo + 90 ** 6189)
LOOP
'
'
'
'
' Eichiama Graf_Barre_O_V
-----[ Subroutines - Graf_Barre_O_V ]--------------------------------------Definisce e visualizza caratteri in un grafico a barre a due assi basati sul
valore del cursore (da 0 a 16) e sul valore (da 1 a 31). Richiama le subroutine Def_Car_Barre_Vert, e Posizionamento_Orizzontale.
Graf_Barre_O_V:
PAUSE 5
' Cancella grafico precedente
' Decide se visualizzare su Riga 0 o Riga 1.
IF valore >= 16 THEN riga = Riga0 ELSE riga = Riga1
GOSUB Def_Car_Barra_Vert
IF valore = 16 THEN
valore = 1
CarPers = 2
riga = Riga0
' Display Riga 0
valore = 15
CarPers = 3
riga = Riga1
' Display Riga 1
valore = 16
' Ripristina valore
ENDIF
RETURN
' -----[ Subroutine - Def_Car_Barra_Vert ]-----------------------------------' Definisce un carattere per grafico a barre verticale basato sulla variabile
' valore (da 0 a 15) e sulla variabile CarPers, che sceglie i caratteri
' personalizzati del LCD seriale Parallax tra 0 e 7.
Def_Car_Barra_Vert:
' Sceglie mappa di riga per il carattere personalizzato basata su valore.
MapRiga = %1111111100000000 >> (valore & %1111)
' Invia 8 byte, ciascuno che definisce una riga di punti nel carattere
' personalizzato. Ciascuna riga è determinata esaminando un bit nella
' variabile MapRiga, e poi inviando %11111 se il bit è 1, oppure
' %00000 se il bit è 0.
FOR indice = 0 TO 7
IF MapRiga.LOWBIT(indice) = 1 THEN ' Esamina il bit successivo in MapRiga
SEROUT 14, 84, [%11111]
' Se 1, invia %11111
ELSE
SEROUT 14, 84, [%00000]
ENDIF
NEXT
' Ritorno dalla subroutine.
RETURN
' -----[ Subroutines – Posizionamento_Orizzontale]---------------------------' Posiziona il grafico a barre verticale ad una delle sedici colonne verticali
' del LCD 2X16 Parallax. La variabile cursore può impostare la posizione
' orizzontale a valori tra 0 e 16, con centro in 8. Richiama Vis_Car_Pers.
Posizionamento_Orizzontale:
SELECT cursore
CASE 0 TO 7
GOSUB Vis_Car_Pers
CASE 8
cursore = 7
GOSUB Vis_Car_Pers
cursore = 8
GOSUB Vis_Car_Pers
CASE 9 TO 16
cursore = cursore - 1
GOSUB Vis_Car_Pers
cursore = cursore + 1
ENDSELECT
' Cursore da 0 a 7, nessun cambiamento
' Cursore a 8, visualizza a 7 & 8
' Cursore da 9 a 16, visualizza 1 a sinistra
RETURN
' -----[ Subroutines - Vis_Car_Pers ]--------------------------------------'
'
'
'
può essere impostata o a Riga0 o a Riga1, e la variabile cursore può essere
impostata a un valore tra 0 e 15. La variabile CarPers sceglie uno dei caratteri personalizzati del LCD e deve essere posta a un valore tra 0 e 7.
Vis_Car_Pers:
RETURN
' -----[ Subroutine - Arcoseno ]---------------------------------------------' Questa subroutine calcola l’arcoseno basato sulla coordinata y in un cerchio
' di raggio 127. Porre la variabile lato uguale alla vostra coordinata y
' prima di richiamare questa subroutine.
Arcoseno:
GOSUB Arcocoseno
RETURN
' subroutine inversa del seno
' Ottiene inversa del coseno
' -----[ Subroutine - Arcocoseno ]-------------------------------------------' Questa subroutine calcola l’arcocoseno basato sulla coordinata x in un cer' chio di raggio 127. Impostare la variabile lato uguale alla vostra coor' dinata x prima di richiamare questa subroutine.
Arcocoseno:
' subroutine inversa del coseno
segno = lato.BIT15
' Memorizza segno del lato
lato = ABS(lato)
' Valuta positivo del lato
' Approssimazione iniziale angolo
DO
' Ciclo approssimazioni successive
' Fine quando COS angolo <= lato
angolo = angolo + 1
' Incrementa l’angolo
LOOP
IF segno = Negativo THEN angolo = 180 – angolo ' Corregge se segno negativo.
RETURN
Appendice A: Tavola del codice ASCII · Pagina 329
Appendice A: Tavola del codice ASCII
Tavola del codice ASCII (primi 128 caratteri)
Dec
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
Hex
00
01
02
03
04
05
06
07
08
09
0A
0B
0C
0D
0E
0F
10
11
12
13
14
15
16
17
18
19
1A
1B
1C
1D
1E
1F
Car
NUL
SOH
STX
ETX
EOT
ENQ
ACK
BEL
BS
HT
LF
VT
FF
CR
SO
SI
DLE
DC1
DC2
DC3
DC4
NAK
SYN
ETB
CAN
EM
SUB
ESC
FS
GS
RS
US
Nome / Funzione
Null
Start Of Heading
Start Of Text
End Of Text
End Of Transmit
Enquiry
Acknowledge
Bell
Backspace
Horizontal Tab
Line Feed
Vertical Tab
Form Feed
Carriage Return
Shift Out
Shift In
Data Line Escape
Device Control 1
Device Control 2
Device Control 3
Device Control 4
Non Acknowledge
Synchronous Idle
End Transmit Block
Cancel
End Of Medium
Substitute
Escape
File Separator
Group Separator
Record Separator
Unit Separator
Dec
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
Hex
20
21
22
23
24
25
26
27
28
29
2A
2B
2C
2D
2E
2F
30
31
32
33
34
35
36
37
38
39
3A
3B
3C
3D
3E
3F
Car
space
!
"
#
$
%
&
'
(
)
*
+
,
.
/
0
1
2
3
4
5
6
7
8
9
:
;
<
=
>
?
Dec
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
Hex
40
41
42
43
44
45
46
47
48
49
4A
4B
4C
4D
4E
4F
50
51
52
53
54
55
56
57
58
59
5A
5B
5C
5D
5E
5F
Car
@
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
[
\
]
^
_
Dec
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
Hex
60
61
62
63
64
65
66
67
68
69
6A
6B
6C
6D
6E
6F
70
71
72
73
74
75
76
77
78
79
7A
7B
7C
7D
7E
7F
Car
`
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
y
z
{
|
}
~
delete
Notate che i codici di controllo (i primi 32 caratteri ASCII) non hanno simboli di
schermo standard. I caratteri elencati per questi codici sono soltanto nomi utilizzati per
fare riferimento a questi codici. Per esempio, per muovere il cursore all’inizio della riga
successiva di una stampante o di un terminale spesso è richiesto di inviare i codici
interlinea e ritorno carrello. Questa coppia di uso comune viene richiamata con "LF/CR."
Appendice B: Documentazione del LCD seriale Parallax · Pagina 331
Appendice B: Documentazione del LCD seriale
Parallax
599 Menlo Drive, Suite 100
Rocklin, California 95765, USA
Ufficio: (916) 624-8333
Fax: (916) 624-8003
Supp. Generale: [email protected]
Supp. Tecnico: [email protected]
Sito Web: www.parallax.com
Didattica: www.stampsinclass.com
Version 2.0
LCD seriale Parallax
2 righe x 16 caratteri Non-retroilluminato (#27976)
2 righe x 16 caratteri Retroilluminato (#27977)
4 righe x 20 caratteri Retroilluminato (#27979)
Introduzione
I dispositivi LCD seriali Parallax sono LCD molto funzionali, di basso costo facilmente
controllabili tramite un microcontrollore BASIC Stamp®. I display LCD sono sia da due
righe per 16 caratteri sia da quattro righe per 20 caratteri, e forniscono di base una
sovrapposizione (o andata a capo) del testo tale che il vostro testo appaia correttamente
nel display. In aggiunta, gli LCD seriali vi forniscono anche il controllo completo su tutte
le loro caratteristiche avanzate di LCD, consentendovi di muovere il cursore dovunque
sul display con una semplice istruzione e accendere e spegnere il display in qualsiasi
configurazione. Essi supportano gli stessi caratteri visibili che sono nel terminale di
Debug degli Editor del BASIC Stamp (codici ASCII Dec 32-127). In aggiunta, potete
definire fino ad otto dei vostri propri caratteri personalizzati da visualizzare dovunque sul
LCD.
Idee applicative
Cosa potete fare con un LCD seriale Parallax? Mentre ci sono molte possibilità, eccovi
un piccolo elenco di idee che si possono realizzare con un LCD seriale e il BASIC Stamp
Parallax:
• Una interfaccia utente testuale di taglio professionale su qualsiasi applicazione di
microcontrollore
• Messa a punto seriale di facile implementazione senza alcun PC
• Uscita dati di sensori in tempo reale per applicazioni autonome di robotica (BoeBot®, Toddler®, SumoBot®)
Cavi di estensione del LCD
Gli LCD seriali Parallax sono compatibili con il nostro cavo di estensione da 14 pollici
per LCD, parte #805-00012, venduto come parte separata da www.parallax.com. Questo
cavo femmina-femmina da 3 pin viene fornito con un attacco (header) da 3 pin con cui
potrete connettere convenientemente il vostro LCD ai vostri progetti su breadboard.
Codice campione
File dimostrativi di software BASIC Stamp possono essere scaricati da:
http://www.parallax.com/detail.asp?product_id=27976
Caratteristiche
• Visualizza insiemi di caratteri ASCII direttamente sul display
• Va a capo automaticamente sulla riga successiva per una facile visualizzazione
di stringhe di testo
• Lavora a velocità di 2400, 9600, e 19.200 baud
• Muove il cursore dovunque sul display con un solo comando
• Cancella l’intero display con un solo comando
• Vi consente di definire fino a otto caratteri personalizzati
Connessioni
Connettere il LCD seriale ad un BASIC Stamp è operazione semplice, che richiede
soltanto tre pin IU. Si vedano le Figure B-1 e B-2 per i dettagli di collegamento elettrico.
Si vedano le Figure B-3 e B-4 sulle pagine seguenti per i dettagli sulle dimensioni e sul
montaggio meccanico.
Figura B-1
Connessioni di
LCD seriale per la
Rev D e i display
precedenti.
LCD Parallax
Figura B-2
Connessioni di
LCD seriale per la
Rev E e i display
successivi.
LCD Parallax
La tabella che segue elenca i requisiti di tensione e corrente elettrica del LCD seriale, con
la retroilluminazione accesa e spenta. Poiché la domanda di corrente in entrambi i casi
supera le capacità di tutti i moduli BASIC Stamp, dovrete alimentare il LCD seriale da un
alimentatore esterno a 5 V. Assicuratevi che l’alimentatore ha un’adeguata capacità di
fornire corrente al LCD seriale ed al BASIC Stamp.
Stato LCD seriale
Tutti i modelli e retroilluminazione off
27977/27979 e retroilluminazione on
Voltaggio
5 VDC
5 VDC
Corrente
20 mA
80 mA
Figura B-3 Dimensioni e specifiche di montaggio per i Modelli 27976, 27977
Figura B-4 Dimensioni e specifiche di montaggio per il Modello 27979
Note Tecniche
Caratteristica
Tipo di display LCD
Direzione di osservazione
Retroilluminazione
Temperatura di funzionamento
Temperatura di conservazione
Descrizione
STN, YG, positivo, trasparente alla riflessione
6H
LED YG
-4°F~158°F (-20°C~70°C)
-22°F~176°F (-30°C~80°C)
Tolleranza dimensionale
±.02” (.5mm)
Impostazione della velocità in Baud (“Baud rate”)
Dopo aver connesso il LCD seriale, vi occorrerà scegliere la velocità in baud alla quale
volete inviargli i dati. Avete tre scelte: 2400, 9600, e 19.200 baud. Per impostare la
velocità in baud, muovete gli interruttori dip nella parte posteriore del LCD nelle
posizioni corrette secondo la tabella vicina agli interruttori stessi, ripetuta anche qui sotto:
MODO
Test (Prova)
2,400
9,600
19.200
SW1
OFF
ON
OFF
ON
SW2
OFF
OFF
ON
ON
Come potete vedere dalla tabella, c’è anche una quarta scelta chiamata Test (Prova).
Appena avete connesso l’alimentazione, usate questo modo Test per confermare che
l’alimentazione e la terra al LCD sono state agganciate correttamente prima di inviare
qualsiasi dato. Muovete gli interruttori dip alla impostazione Test e accendete
l’alimentazione. Il display LCD dovrebbe accendersi con la retroilluminazione inserita
(modelli 27977, 27979) e visualizzare il testo che segue:
Parallax, Inc.
www.parallax.com
Se all’inizio non vedete il testo, provate a regolare il contrasto del LCD ruotando con un
cacciavite il pot etichettato “Increase Contrast” (Aumenta contrasto). Ruotatelo in
direzione della freccia per far vedere i caratteri con maggior chiarezza. Se ancora non
vedete i caratteri, tornate a controllare i vostri collegamenti elettrici e poi provate di
nuovo. Una volta completato con successo il modo test, muovete gli interruttori dip alle
posizioni corrette per scegliere la velocità in baud che volete utilizzare per la vostra
applicazione.
Visualizzazione di testo
Ora che il LCD è stato impostato, è il momento di iniziare ad inviare testo al display. Per
visualizzare un carattere di testo sul LCD seriale, inviate semplicemente il codice ASCII
di quel carattere al LCD seriale tramite la porta seriale alla corretta velocità in baud.
Quando viene ricevuto un carattere, il LCD seriale visualizza quel carattere nella
posizione corrente del cursore e poi muove il cursore a destra di una posizione. Quando
accendete il LCD per la prima volta, il cursore è nella posizione più a sinistra sulla riga
superiore, come potreste aspettarvi. La barra corta nella parte inferiore del carattere
mostra dove è posizionato correntemente il cursore.
Non appena avrete inviato una intera riga di caratteri al LCD, noterete che il cursore si
sovrappone automaticamente alla posizione più a sinistra della seconda riga, proprio
come il testo di un libro. Il testo si sovrappone (va a capo) proprio come questo testo alla
fine di ciascuna riga, con la fine della riga inferiore che si sovrappone di nuovo sulla riga
superiore del LCD. Il testo non “scorrerà” mai “fuori” dal display; vedrete sempre tutti i
caratteri che inviate.
Provate il codice che segue nel vostro BASIC Stamp 2 per inviare una stringa di testo al
display LCD. Dapprima, impostate la velocità in baud sul vostro LCD seriale a 19.200.
Poi, caricate il codice qui sotto nel vostro BASIC Stamp 2 ed eseguitelo. Vedrete la
stringa di testo comparire e sovrapporsi alla seconda riga del display.
In tutto il codice del vostro LCD seriale, dovrete fare una pausa di 100 ms all’avvio per
dare tempo al LCD seriale di inizializzarsi. Dovreste anche impostare il pin della porta
seriale sul BASIC Stamp ad HIGH (ALTO) prima del ritardo di avvio di 100 ms, poiché
questo è lo stato normale di una porta seriale quando non sta inviando alcun dato.
' {$STAMP BS2}
PinTx
Baud19200
CON
CON
0
32
HIGH PinTx
' Imposta ad alto il pin per essere porta seriale
PAUSE 100
' Pausa per inizializzare il LCD seriale
SEROUT PinTx, Baud19200, ["Ciao, questo testo andrà a capo."]
Muovere il Cursore
Quando inviate un carattere al LCD seriale, esso verrà sempre visualizzato alla posizione
corrente del cursore. Sul display seriale LCD ci sono pochi modi diversi per muovere il
cursore. Dopo ciascun carattere che inviate, il cursore si muove automaticamente in su di
una posizione. Assieme a questo movimento, ci sono un insieme di comandi per
muovere il cursore compresi Backspace, Carriage Return (Ritorno Carrello – A capo) , e
Line Feed (Interlinea).
Il comando Backspace/Left (Sinistra) (Dec 8) muove il cursore di una posizione a sinistra
e il comando Right (Destra) (Dec 9) muove il cursore di una posizione a destra. Questi
comandi possono essere utili per muovere il cursore intorno e sovrascrivere testo
esistente. Questi comandi mandano a capo il testo sulla riga successiva del display, se
necessario. Il comando Line Feed (Interlinea) (Dec 10) muove il cursore alla riga
successiva del display senza cambiare la posizione orizzontale del cursore. Il comando
Carriage Return (Ritorno carrello – A capo) (Dec 13) muove anche lui il cursore alla riga
successiva, ma contemporaneamente lo sposta alla posizione più a sinistra di quella riga.
Il comando Form Feed (Nuova pagina) (Dec 12) cancella l’intero display e muove il
cursore nella posizione più a sinistra sulla Riga 0, proprio come quando accendete il
display per la prima volta. Dopo l’invio di un comando Form Feed vi occorrerà fare una
pausa di 5 mS all’interno del vostro codice, per dare al LCD seriale il tempo per
cancellare il display. Tranne per il Form Feed, nessuno di questi comandi di movimento
del cursore interessa i caratteri presenti sul display.
Ci sono anche comandi di movimento diretto che potete usare per muovere il cursore su
qualsiasi posizione del display con un solo comando. I comandi da Dec 128 a 143 e da
Dec 148 a 163 muovono il cursore nelle 16 posizioni diverse su ciascuna delle due righe
degli LCD modello 27976 e 27977. I comandi da Dec 128 a 207 muovono il cursore alle
20 posizioni diverse su ciascuna delle quattro righe del LCD modello 27979.
Controllare il Display
Avete anche il controllo sui vari modi di display del LCD seriale. Il comando display-off
(spegne display) (Dec 21) spegne (off) il display, così tutti i caratteri scompaiono. Questi
caratteri non sono, però, cancellati dal display e potete persino riuscire a scrivere nuovi
caratteri sul display quando è stato spento. Un trucco per far comparire immediatamente
una gran quantità di testo tutta assieme, persino a una velocità in baud lenta, è di spegnere
il display e poi inviare tutto il vostro testo. Allora, quando riaccendete il display, tutto il
testo appare istantaneamente.
I comandi display-on (accende display) (da DEC 22 a 25) riaccendono il display e
controllano anche se volete visualizzare il cursore e/o far lampeggiare il carattere cursore.
Il cursore è la barretta che viene mostrata sotto il carattere alla posizione corrente di
cursore. L’opzione di lampeggio fa lampeggiare quel carattere accendendolo (on) e
spegnendolo (off) ripetutamente. Potete accendere (on) e spegnere (off) il cursore e le
opzioni di lampeggio, in qualsiasi combinazione, come elencato nella tabella di
impostazione dei comandi. Potete cambiare il cursore e il modo lampeggio persino se il
display è già acceso; non vi occorre spegnerlo e poi riaccenderlo di nuovo.
Con i modelli 27977 e 27979, potete anche controllare la retroilluminazione del display.
La retroilluminazione illumina il display così che sia più facile vederlo al buio. Ci sono
comandi che accendono (on, Dec 17) e spengono (off , Dec 18) la retroilluminazione.
Il LCD seriale ha la possibilità di memorizzare fino ad otto caratteri personalizzati
definiti dall’utente. I caratteri personalizzati sono memorizzati nella sua RAM e pertanto
necessitano di essere ridefiniti se togliete (off) l’alimentazione. Potete visualizzare i
caratteri personalizzati inviando i comandi da Dec 0 a 7, come mostrato nella tabella di
impostazione dei comandi. Il carattere personalizzato sarà visualizzato alla posizione
corrente del cursore.
I caratteri personalizzati sono larghi cinque pixel ed alti otto pixel. Ciascuno dei caratteri
è memorizzato come una serie di otto byte di dati, dove i cinque bit meno significativi di
ciascun byte rappresentano una riga di pixel nel carattere. I tre bit più alti di ciascun byte
sono ignorati. Un valore di bit uno accende (on) quel pixel (cioè lo rende nero). La riga
inferiore dei pixel spesso è lasciata vuota (tutti zero) per rendere più facile vedere il
cursore.
Per definire un carattere personalizzato, dovrete inviare un totale di 9 byte al LCD seriale.
Il primo byte deve essere un comando definisci-carattere-personalizzato valido (da Dec
248 a 255) e deve essere seguito da otto byte dati che definiscono i pixel del carattere. Il
LCD seriale userà sempre i successivi otto byte che riceve per impostare i pixel del
carattere. I byte dato definiscono il carattere che inizia alla fila di pixel più in alto, come
mostra il codice esempio.
Definite un carattere personalizzato usando il codice esempio indicato sotto. Prima di
tutto, impostate la velocità in baud sul vostro LCD seriale a 19.200. Poi caricate il codice
qui sotto nel vostro BASIC Stamp 2 ed eseguitelo. Vedrete apparire sullo schermo un
carattere diamante.
' {$STAMP BS2}
PinTx
Baud19200
CON
CON
0
32
HIGH PinTx
PAUSE 100
' Imposta il pin alto per essere porta seriale
' Pausa per inizializzare LCD seriale
SEROUT PinTx, Baud19200, [250]
SEROUT
SEROUT
SEROUT
SEROUT
SEROUT
SEROUT
SEROUT
SEROUT
SEROUT
PinTx,
PinTx,
PinTx,
PinTx,
PinTx,
PinTx,
PinTx,
PinTx,
PinTx,
Baud19200,
Baud19200,
Baud19200,
Baud19200,
Baud19200,
Baud19200,
Baud19200,
Baud19200,
Baud19200,
[0]
[4]
[14]
[31]
[14]
[4]
[0]
[0]
[2]
'
'
'
'
'
'
'
'
'
'
'
Definisce Carattere personalizzato 2
Ora invia gli otto byte dati
0 = %00000
4 = %00100
*
14 = %01110
* * *
31 = %11111 * * * * *
14 = %01110
* * *
4 = %00100
*
0 = %00000
0 = %00000
Visualizza il nuovo Carattere personal. 2
Insieme dei comandi
Le tabelle qui sotto elencano tutti i comandi validi per un LCD seriale. I comandi
contrassegnati da N/A (Non Disponibile) non sono validi e sono quindi ignorati. Le righe
del display LCD sono numerate a partire dallo 0, con la Riga 0 che è la riga più in alto.
Le posizioni di carattere su ciascuna riga sono numerate a partire dallo 0, con la posizione
0 che è la posizione più a sinistra sulla riga.
Dec
Hex
Azione
0
1
2
3
4
5
6
7
00
01
02
03
04
05
06
07
8
08
9
09
10
0A
11
0B
12
0C
13
0D
14 - 16
17
18
19 - 20
21
22
23
24
25
26 - 31
32 - 127
128
129
130
131
132
133
134
0E - 10
11
12
13 - 14
15
16
17
18
19
1A - 1F
20 - 7F
80
81
82
83
84
85
86
Backspace / Left (sinistra) – Il cursore è mosso a sinistra di una posizione. Il
comando non cancella il carattere.
Right (destra) - Il cursore è mosso a destra di una posizione. Il comando non
cancella il carattere.
Line Feed (Interlinea) – Il cursore è mosso verso il basso di una riga. Per i modelli
di LCD a due righe, se è sulla riga 0 va sulla riga 1. Se sulla riga 1, ritorna a capo
in ciclo sulla riga 0. La posizione orizzontale rimane la stessa.
N/A (Not Avalilable = Non Disponibile)
Form Feed (Nuova pagina) – Il cursore è mosso nella posizione 0 sulla riga 0 e
l’intero display è cancellato. Dopo questo comando occorre una pausa di 5 mS.
Carriage Return (Ritorno carrello – A capo) – Per i modelli di LCD a due righe, se è
sulla riga 0 il cursore è mosso alla posizione 0 sulla riga 1. Se è sulla riga 1, va a
capo (in ciclo) sulla posizione 0 della riga 0.
N/A
Accende (on) retroilluminazione (solo sui modelli 27977, 27979)
Spegne (off) retroilluminazione (Default – opzione implicita)
N/A
Spegne (off) il display
Accende (on) il display, con cursore spento e nessun lampeggio
Accende (on) il display, con cursore spento e lampeggio del carattere
Accende (on) il display, con cursore acceso e senza lampeggio (Default – implicita)
Accende (on) il display, con cursore acceso e lampeggio del carattere
N/A
Visualizza caratteri ASCII. Si veda la tabella dell’insieme dei caratteri ASCII.
Muove il cursore alla riga 0, posizione 0
Dec
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
Hex
87
88
89
8A
8B
8C
8D
8E
8F
90
91
92
93
94
95
96
97
98
99
9A
9B
9C
9D
9E
9F
A0
A1
A2
A3
A4
A5
A6
A7
A8
A9
AA
AB
AC
AD
AE
AF
B0
B1
B2
B3
B4
Azione
Muove il cursore alla riga 0, posizione 16 (solo sul modello 27979)
Dec
Hex
Azione
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208 - 247
248
249
250
251
252
253
254
255
B5
B6
B7
B8
B9
BA
BB
BC
BD
BE
BF
C0
C1
C2
C3
C4
C5
C6
C7
C8
C9
CA
CB
CC
CD
CE
CF
D0 – F7
F8
F9
FA
FB
FC
FD
FE
FF
N/A
Definisce Carattere Pers. 0. Il comando dev’essere seguito da otto byte dati.
Insieme dei caratteri ASCII
La tabella qui sotto mostra tutti i caratteri ASCII così come vengono visualizzati sul LCD
seriale. Tutti i caratteri ASCII (codici da Dec 32 a 127) sono caratteri ASCII standard,
tranne i caratteri ‘\’ back-slash (barra rovesciata, Dec 92) e ‘~’ tilde (Dec 126). Per
vostra convenienza, il LCD seriale è stato pre-programmato con questi caratteri nella
posizione dei primi due caratteri personalizzati. Così, per visualizzare una back-slash
(barra rovesciata), usate il com. Dec 0 e per visualizzare una tilde, usate il com. Dec 1.
Naturalmente, potrete sempre sovrascrivere questi caratteri con vostri caratteri personali.
Appendice C: Definizioni dei caratteri esadecimali · Pagina 345
Appendice C: Definizioni dei caratteri
esadecimali
Gran parte delle note e della documentazione di applicazioni di LCD usano numeri
esadecimali invece di numeri binari per definire comandi e caratteri. In PBASIC,
scrivere un punto esclamativo è solo questione di un comando SEROUT con un punto
esclamativo tra virgolette.
SEROUT 14, 84, ["!"]
Non tutti i linguaggi di programmazione per (micro)controllori supportano l’uso nativo di
caratteri stampabili come quello illustrato qui sopra. In alcuni casi, principalmente nei
linguaggi assembler, si deve invece usare il codice ASCII del punto esclamativo. Il
codice ASCII del punto esclamativo è 33, e anche in PBASIC, il comando SEROUT 14,
84, [33] realizza lo stesso compito. Nel linguaggio assembler, i valori esadecimali
sono a volte la base numerica preferita perché rendono più facili alcuni compiti. A causa
di questo fatto, gran parte della documentazione dei LCD elenca i propri comandi per il
LCD con valori esadecimali.
L’equivalente esadecimale del valore decimale 33 è 21 esadecimale. Cioè (2 × 16) + 1.
Potete usare l’operatore $ per specificare che il valore è esadecimale, e con questo
artificio il comando per visualizzare un punto esclamativo apparirà come:
SEROUT 14, 84, [$21].
Eccovi un esempio di comando SEROUT che definisce una barra in un grafico a barre.
Esso riempie la metà inferiore del carattere con pixel neri e lascia la metà superiore
bianca:
SEROUT 14, 84, [250,
%00000,
%00000,
%00000,
%00000,
%11111,
%11111,
%11111,
%11111]
'
'
'
'
'
'
'
'
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
Eccovi adesso un comando equivalente che usa invece valori esadecimali. Mentre questo
risparmia una gran quantità di spazio, non è ancora così facile comprendere come si
definisce un carattere personalizzato con numeri binari. Fate come se ciò sia possibile,
vedrete programmi applicativi PBASIC scritti in questo modo di volta in volta,
principalmente per la prevalenza di valori esadecimali nella documentazione LCD.
SEROUT 14, 84, [250, $00, $00, $00, $00, $1F, $1F, $1F, $1F]
La Tabella 7-1 conta fino a 15 in decimale, esadecimale, e binario. Per fare conversioni
da esadecimale a binario e viceversa, questa tabella è tutto quanto vi serve. Si può
dimostrare che ciascuna cifra esadecimale corrisponde ad un gruppo di quattro cifre
binarie (per valori binari in PBASIC, al posto del “$” si usa il carattere “%”).
Tabella 7-1: Valori decimali (10), esadecimali (16) e binari (2)
Base
10
Base
16
Base
2
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F
00
00
00
01
00
10
00
11
01
00
01
01
01
10
01
11
10
00
10
01
10
10
10
11
11
00
11
01
11
10
11
11
Esempio: Convertire $8FE6 in binario.
Soluzione: Ciascuna cifra esadecimale si converte in un gruppo di quattro cifre binarie,
quindi si può scrivere il valore binario con l’aiuto della Tabella 7-1 in questo modo:
Eaadecimale
Binario
8
F
1000 1111
E
6
1110 0110
$8FE6 = %1000111111100110
Esempio: Convertire %1100011000001001 in esadecimale.
Soluzione: Scrivete il numero binario in gruppi di quattro cifre, poi usate la Tabella 7-1:
Binario
Esadecimale
1100 0110
C
6
%1100011000001001 = $C609
0000 1001
0
9
Appendice C: Definizioni dei caratteri esadecimali · Pagina 347
Programma Esempio: ConverteBinarioEsadecimale.bs2
Naturalmente, potete anche fare in modo che il BASIC Stamp faccia la conversione al
posto vostro. Utilizzate semplicemente l’operatore % per definire il numero binario, e
poi usate il formattatore HEX in un comando SEROUT per visualizzare il valore.
√
Provatelo e controllate se il LCD va d’accordo con i nostri calcoli
' Sensori intelligenti e loro applicazioni - ConverteBinarioEsadecimale.bs2
' {$STAMP BS2}
' {$PBASIC 2.5}
PAUSE 250
SEROUT 14, 84, [22, 12]
PAUSE 5
' Distacca alimentazione
' Accende display e lo cancella
' ritardo 5 ms per cancellare display
SEROUT 14, 84, ["Valore = ", HEX %1100011000001001]
END
Il vostro turno - Conversione da esadecimale a binario
Convertire da esadecimale a binario comporta l’utilizzo del formattatore BIN al posto del
HEX, e l’utilizzo dell’operatore $ per dire all’Editor del BASIC Stamp che gli state dando
il valore come esadecimale (invece del % per il valore binario). Se state convertendo
quattro cifre esadecimali in binario, il risultato sarà un numero a 16 cifre. Quindi, si dovrà
modificare anche il comando SEROUT perché visualizzi il risultato a partire dall’inizio
della seconda riga.
√
Commentate la riga di codice esistente che esegue la conversione da binario ad
esadecimale.
SEROUT 14, 84, ["Valore = ", 148, BIN $8FE6]
Appendice D: Elenco dei componenti · Pagina 349
Appendice D: Elenco dei componenti
Requisiti del sistema di elaborazione :
• PC che esegue Windows 2000/XP
• Una porta seriale oppure una porta USB disponibile. Se vi occorre un
adattatore da USB a seriale, vi raccomandiamo il componente Parallax #80000030.
• Accesso ad Internet
Requisiti Software:
• Editor BASIC Stamp per Windows v2.0 o superiore (Scaricabile gratuitamente
dal sito www.parallax.com)
• Programmi esempio scelti (scarico gratuito da www.parallax.com)
• Microsoft Notepad e Microsoft Excel 2002 o superiore (per gli studi di
accelerazione del Capitolo 6)
Requisiti Hardware
• Uno dei kit seguenti che include una piattaforma di programmazione BASIC
Stamp 2, oltre ad un appropriato alimentatore o batterie:
o Kit “Board of Education” completo seriale (#28102) o USB (#28802)
o Kit “Robot Boe-Bot” seriale (#28132) o USB (#28832)
o Kit* di attività BASIC Stamp ( include scheda HomeWork) (#90005)
• Componenti e testo “Smart Sensors and Applications” (#28029) oppure Kit
soli componenti (#130-28029)
Elementi domestici :
• Piccola barretta magnetica
• Bussola meccanica (per la taratura del Modulo Bussola, Capitolo 4)
• Automobile RC e controller, con batterie (per il Capitolo 6, Attività #5)
• Ruota di bicicletta (per il Capitolo 6, Attività #6)
*Tutte le attività in questo testo sono compatibili con la scheda HomeWork BASIC
Stamp se voi state usando anche il LCD non retroilluminato incluso nel kit Smart
Sensors. Se invece state usando un LCD retroilluminato, utilizzate anche una scheda
Board of Education per proteggere il vostro LCD.
Componenti & Testo “Sensori intelligenti e loro applicazioni” #28029
(Senza il libro, #130-28029)
Componenti e quantità soggette a variare senza avviso
Componente Parallax #
Descrizione
Quantità
122-28029
Testo “Smart Sensors and Applications”
1
150-01020
Resistenze 220 Ω, ¼ watt 5%
2
27976
LCD seriale 2 x 16 non retroilluminato Parallax
1
28015
Sensore ultrasonico di distanza Ping)))
1
28017
Accelerometro Memsic a due assi
1
29123
Modulo bussola Hitachi
1
451-00303
Basetta a 3 pin maschio/maschio
3
700-00003
Dadi 4-40 zincati
6
700-00028
Viti da 1/4” 4-40 a testa piana
4
710-00006
Viti da 1/2“ 4-40 a testa piana
2
713-00005
Distanziale da 1/4” rotondo di nylon #4
2
720-00011
Mensole di montaggio universali a 90 gradi
4
800-00016
Cavallotti di filo da 3 pollici, sacchetto da 10
2
805-00002
Cavo di estensione per Servo/LCD
2
900-00001
Altoparlante Piezo (-elettrico)
1
Potete scoprire di avere alcuni componenti elettronici extra nel vostro kit che non sono
utilizzati nel libro Smart Sensors and Applications. Se volete usare questi componenti per
costruire i vostri propri circuiti, vi preghiamo di imparare qualcosa sui condensatori elettrolitici
e i loro requisiti di sicurezza, qui sotto, prima di andare avanti. ATTENZIONE: L’uso non
corretto dei condensatori elettrolitici può farli esplodere. Seguite le linee guida di
sicurezza esposte qui sotto per evitare possibili ferite.
I condensatori elettrolitici hanno un terminale positivo (+) ed uno negativo
(-). La tensione al terminale (+) del condensatore deve essere sempre più alta
della tensione al suo terminale (-). Usate la figura (a destra) per identificare i
terminali (+) e (-). Assicuratevi sempre di collegare questi terminali esattamente
come mostrato in diagrammi circuitali affidabili. Connettere uno di questi
terminali in modo non corrretto li può danneggiare. In alcuni circuiti, connettere
questo tipo di condensatori in modo non corretto e poi connettere
l’alilmentazione può portarlo a rompersi o persino ad esplodere. Vss è la
tensione più bassa (0 V) sulla Board of Education e sulla schda BASIC Stamp
HomeWork. Connettendo il terminale negative del condensatore a Vss, vi
assicurate che la polarità ai capi dei terminali del condensatore sarà sempre
corretta.
NORMA DI SICUREZZA
Scollegate sempre l’alimentazione prima di costruire o modificare i
Simbolo di
Condensatore
Appendice D: Elenco dei componenti · Pagina 351
circuiti. Osservate sempre la polarità quando connettete condensatori
elettrolitici. Non rovesciate mai la polarità dell’alimentazione su qualsiasi
condensatore polarizzao. Indossate occhiali di sicurezza o lenti di
sicurezza quando iutilizzate questi condensatori.
Tenete le vostre mani e il vostro viso lontani da questi condensatori
quando sono alimentati elettricamente.
10 µF
-
+
Indice · Pagina 353
Indice
-A-
accelerazione, 69
dinamica, 71
-B-
banda morta, 269
barre, grafico a
statica, 71
a due assi, 306
studio automobile RC, 248
orizzontale, 298
studio trucco di uno skateboard , 259
verticale, 308
su percorso circolare, 251
accelerometro
a tre assi, 70
e grafico a bolle su LCD
dell'inclinazione 202
misure di altezza con l'-, 229
barretta magnetica, 133
baud, velocità di trasmissione in-, 7
interrutt. veloc. baud del LCD, 6
bicicletta, misura distanza in, 267
binarie (radianti, brad), 92, 107
bussola (disegno della-), 129
bussola, modulo Hitachi HM55B, 127
progetto MX2125 (figura), 71
assi di sensibilità della-, 128
schema e diagramma cablaggio, 72
interpretazione delle misure di -, 127
usi, 69
animazione
- meccanica, 136
precauzioni con i magneti, 133
testo lampeggiante, 12
prova della -, 128
caratteri personalizzati clessidra, 26
schema e diagramma di cabl., 129
caratteri personal. verme di pixel, 289
taratura della -, 136
testo scorrevole, 27
-C-
finestra scorrevole, 28
arcocoseno, 109
arcoseno, 109
arcotangente, 91, 94
ASCII, tavola codice, 329
ATN, 91, 128
calibri, 52
campo magnetico, 127
campo magnetico, intensità del -, 127
campo magnetico terrestre, 127
caratteri personalizzati
definizone di- , 21
animazione clessidra, 25
animazione verme di pixel, 291
- predef. in LCD seriale Parallax, 21
scambio di-, 285
Cartesiane, coordinate -, 187
cerchio unitario, 106
CLREOL, 102
collisione, 69
computer, requisiti sistema -, 349
complemento a due, 85, 187, 210
condensatore, sicurezza, 352
conteggio giri ruota, 268
contrasto del LCD, regolazione, 7
controllo, gioco a- di inclinazione,
210
conversione
da numeri esadecimali a binari, 346
da radianti binari a gradi, 92
da temperatura Fahrenheit a Celsius, 63
da temperatura Celsius a Fahrenheit, 63
conversione in gradi, 92
coordinate (sistemi di-), 187
coordinate visualizzate, 187
COS, 108
coseno, 106
CR, 9
CRSRXY, 8, 180
-D-
DATA, 194, 232
dati, registrazione -, 240, 243
declinazione, 132
digitale, termometro, 1
dinamica, accelerazione, 71
display a cristalli liquidi (LCD), 1
due equazioni con due incognite, 189
due, complemento a-, 85, 187, 210
-E-
EEPROM, 233, 289
elementi domestici richiesti, 349
esadecimale, 22, 317
esadecimale a binaria, conversione,
319
-F-
Fahrenheit a Celsius, conversione, 63
fissare intervallo valori ingresso, 82
-G-
Gelfand, Alan (Ollie), 260
gioco, a controllo di- inclinazione,
210
grafici, visualizzazione di caratteri,
180
grafico a barre, orizzontale, 298
verticale, 308, 310
gravità, 69, 88
-H-
hardware, requisiti, 349
HIDs (Human Interface Devices), 179
-I-
inclinazione, 69, 98, 132
inclinazione, angolo di-, 69
ingresso, fissare intervallo valori -, 82
isteresi, 267
-L-
LCD
animazione caratteri personalizzati in, 285
caratteri personalizzati predefiniti in-, 21
codici (caratteri) di controllo, 9
definizione caratteri personalizzati in-, 21
documentazione - seriale Parallax,
331
misura altezza con accelerometro, 229
momento, 260
-N-
negativi, numeri- in PBASIC, 85, 187
e operatore MIN, 209
divisione, 154
inclinare grafico a bolle accelerometro
su -, 202
numeri negativi in PBASIC, 85, 187
finestra scorrevole, 28
offset dei valori di ingresso, 80 - 81
ollie, 260
orizzontale, grafico a barre, 298
oscillazioni, 262
osservazione delle coordinate di un
carattere, 196
grafico a barre a due assi, 306
grafico a barre orizzontale, 298
grafico a barre verticale, 308
in prodotti commerciali, 2
interruttori velocità in baud, 6
precauzioni per i modelli più vecchi, 4
regolazione del contrasto, 7
schema e diagramma circuitale, 5
staffe di montaggio per-, 163-164
testo scorrevole, 28
testo scorrevole in finestra, 32
liquidi, display a cristalli- (LCD), 1
-M-
magnetico, campo- , 127
magnetico, intensità del campo-, 127
magnetico, campo- terrestre, 127
MAX, 208
meccanica, bussola-, 136
media delle misure della bussola, 152
MEMS, tecnologia-, 69
MIN, 208
-O-
-P-
Parts Kit, elenco componenti, 349
percentuale, misura errore -, 64
piezo altoparlante, circuito -, 241
Ping))), sensore, 43
e visual. LCD grafico a barre, 296
misure di distanza, centimetri, 48
misure di distanza, pollici, 51
connessione cavo estensione, 57
schema e diagramma circuitale, 45
limiti utili, 47
predefiniti, caratt. personalizzati -, 21
Programmi
AccelerazioneRuotaBici.bs2, 272
BradAGradi.bs2, 96
CaratteriPersonaliPredfiniti.bs2, 21
Clessidra.bs2, 25
ProvaPing.bs2, 46
CmEPolPingLcd.bs2, 61
RegDatiDiAccelerazione.bs2, 244
ConverteBinarioEsadecimale.bs2,
347
RegDatiAsseYNonScalato.bs2, 264
DisplaySfondoEeprom.bs2, 195
GrafBarreOrizzontale.bs2, 298
GraficoBolla.bs2, 205
GiocoInclinaOstacoli.bs2, 213
InclinaOrizzontale.bs2, 115
InclinaSemplice.bs2, 74
InclinaSempliceLcd.bs2, 78
MemoriaDatiEEPROM.bs2, 234
MemoriaDatiEEPROMConReset.bs2,
238
MisuraCmPing.bs2, 50
MisuraCmEPolPing.bs2, 53
NumeriConSegno.bs2, 86
PosizioniCursore.bs2, 16
ProvaArcoseno.bs2, 110
ProvaAtn.bs2, 96
ProvaBarreVerticali.bs2, 308
ProvaBussola.bs2, 131
ProvaBussolaLcd.bs2, 167
ProvaBussolaMediata.bs2, 155
ProvaBussolaTarata.bs2, 148
ProvaContatoreRuota.bs2, 269
ProvaMessaggiLcd.bs2, 11
ProvaNumeriLcd.bs2, 13
ProvaOffsetScala.bs2, 83
RinfrescaSfondoEeprom.bs2, 199
RotazioneRuotaVert.bs2, 101
RoutineScorriTesto.bs2, 30
SenoCoseno.bs2, 108
TaraBussola.bs2, 140
TimerLcd.bs2, 19
TracciaCrsrxy.bs2, 182
TracciaGraficiXY.bs2, 185
VermeDiPixelEeprom.bs2, 289
VisualBarreDueAssi.bs2, 314
pulsante Reset come interruttore
programma, 236
PULSIN, 73
-R-
registrazione dati, 240
RC, acceleraz. di un'automobile-, 248
READ, 232
registrazione e riproduzione, 230
refresh, velocità di-, 193
Reset, pulsante- come interr. di
programma, 236
rotazione, 69, 90, 100, 247
-S-
scalatura, costante di-, 82
scalatura valori di ingresso, 80
scorrevole, finestra, 28
scorrevole, testo, 28
segno, numeri con - e PBASIC, 187
e operatore MIN, 209
divisione con -, 154
segnati, numeri - in PBASIC, 84-86
seno, 100
sensore Ping))), 43
SEROUT, 9, 347
servo, cavallotto porte-, 159
simbolo di grado in ASCII, 152
skateboard,
studio trucco accelerazione - , 259
SIN, 100
software, requisiti -, 349
statica, accelerazione -, 71
suono, velocità del - e temperatura, 62
-T-
tesla (T), 133
temperatura, conversione unità di-, 63
-U-
unitario, cerchio, 106
-V-
verme, carattere person. per LCD, 289
verticale, grafico a barre, 308
vibrazione, 69
-W-
Wainwright, Danny, 260
WRITE, 232

Sensori Intelligenti e loro Applicazioni

Transcript

Documenti analoghi

NEC MultiSync® LCD3210

Uso di Eclipse per i progetti per ARM7TDMI

Scarica la documentazione

Scarica il documento PDF

Diapositiva 1 - Istituto Tecnico Industriale

Numero CCD 3 Dimensione CCD (pollici) 1/6 Numero di

Navigatore 2-Din con LCD da 7”, TV, USB e Bluetooth

attrezzature e tecnologie

Inchiesta consumi tv.indd

Stampante Panasonic