Sensori Intelligenti e loro Applicazioni · della Parallax, Inc. HomeWork Board, Propeller, Ping))) Parallax, e il logo Parallax sono marchi di fabbrica della Parallax, Inc. Se decidete

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.

3RD

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 retro-illuminato):

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 ' Dispositivo scelto = BASIC Stamp 2 ' $PBASIC 2.5 ' Linguaggio = PBASIC 2.5 SEROUT 14, 84, [22, 12] ' Inizializza il LCD PAUSE 5 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

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 ' Inizia un blocco DO...LOOP PAUSE 600 ' ritardo di 6/10 di secondo SEROUT 14, 84, [22] ' Accende il display PAUSE 400 ' ritardo di 4/10 di secondo SEROUT 14, 84, [21] ' Spegne il display LOOP ' 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:

Vedi il testo ? Il LCD lavora!


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 ' Dispositivo scelto = BASIC Stamp 2 ' $PBASIC 2.5 ' Linguaggio = PBASIC 2.5 contatore VAR Byte ' Indice del ciclo FOR...NEXT SEROUT 14, 84, [22, 12] ' Inizializza il LCD 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 Cursore a sinistra • 9 Cursore a destra • 10 Cursore giù (la riga inferiore scorre alla riga superiore) • 128 a 143 Posizione del cursore sulla Riga 0, carattere da 0 a 15 • 148 a 163 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, "R", 131, "I", 134, "G", 137, "A", 140, "-", 143, "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 ' Dispositivo scelto = BASIC Stamp 2 ' $PBASIC 2.5 ' Linguaggio = PBASIC 2.5 indice VAR Nib ' Indice del ciclo FOR...NEXT carattere VAR Byte ' Memoria deposito del carattere offset VAR Byte ' Valore dello spostamento SEROUT 14, 84, [22, 12] ' Inizializza il LCD PAUSE 500 ' 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 ' Fa lampeggiare il display 5 volte SEROUT 14, 84, 500, [21, 22] NEXT END ' 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 ' Cancella il display SEROUT 14, 84, ["Questo è un", 13] ' Testo e CR FOR indice = 0 TO 3 ' 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] ' Avvia il LCD & cancella il ' display PAUSE 5 ' Pausa di 5 ms per cancellare il

' display SEROUT 14, 84, ["Tempo ...", 13] ' Testo + ritorno carrello SEROUT 14, 84, [" h m s"] ' 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 ' direttiva Stamp ' $PBASIC 2.5 ' direttiva PBASIC ore VAR Byte ' Memorizza le ore minuti VAR Byte ' Memorizza i minuti secondi VAR Byte ' Memorizza i secondi SEROUT 14, 84, [22, 12] ' Avvia il LCD & cancella il display PAUSE 5 ' Pausa di 5 ms per cancellare il ' display SEROUT 14, 84, ["Tempo trascorso...", 13] ' Testo + ritorno carrello SEROUT 14, 84, [" h m s"] ' 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 ' Pausa + ritardo di ~ 1 secondo secondi = secondi + 1 ' Incremento del contatore dei secondi LOOP ' 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 CON 12 ' Salto pagina -> cancella schermo CrLcd CON 13 ' Ritorno carrello OffLcd CON 21 ' Spegne il display OnLcd CON 22 ' Accende il display Riga0 CON 128 ' Riga 0, carattere 0 Riga1 CON 148 ' 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)

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] ' Inizializza il LCD 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]

Caratteri personalizzati


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

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ù.

Carattere personalizzato Comandi di definizione


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, ' Definisce il carattere personalizzato 7 %00000, ' %11111, ' * * * * * %10001, ' * * %01010, ' * * %00100, ' * %01110, ' * * * %11111, ' * * * * * %11111] ' * * * * *


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, [133] ' Cursore -> Riga 0, char SEROUT 14, 84, [0] ' Visualizza carattere personalizzato 0 PAUSE 1250 ' Ritardo di 1.25 secondi SEROUT 14, 84, [8] ' Backspace (cancella a sinistra) SEROUT 14, 84, [7] ' Visualizza carattere personalizzato 7 PAUSE 1500 ' Ritardo di 1.50 secondi 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 ' Dispositivo scelto = BASIC Stamp 2 ' $PBASIC 2.5 ' Linguaggio = PBASIC 2.5 ' -----[ Inizializzazione ]--------------------------------------------------- PAUSE 250 ' Toglie l’alimentazione elettrica SEROUT 14, 84, [248, ' Definisce il carattere personalizzato 0 %00000, ' %11111, ' * * * * * %11111, ' * * * * * %01110, ' * * * %00100, ' * %01010, ' * * %10001, ' * * %11111] ' * * * * * SEROUT 14, 84, [255, ' Definisce il carattere personalizzato 7 %00000, ' %11111, ' * * * * * %10001, ' * * %01010, ' * * %00100, ' * %01110, ' * * * %11111, ' * * * * * %11111] ' * * * * * SEROUT 14, 84, [22, 12] ' Accende il display e lo cancella PAUSE 5 ' Ritardo di 5 ms per cancellare il display ' -----[ Programma principale ]----------------------------------------------- DO SEROUT 14, 84, [133] ' Cursore -> riga 0, char SEROUT 14, 84, [0] ' Visualizza carattere personalizzato 0 PAUSE 1250 ' Ritardo di 1.25 secondi SEROUT 14, 84, [8] ' Backspace (cancella a sinistra) SEROUT 14, 84, [7] ' Visualizza carattere personalizzato 7 PAUSE 1500 ' Ritardo di 1.50 secondi LOOP


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 DATA @ 2, "Messaggio " Messaggio2 DATA "ulteriore " Messaggio3 DATA "Messaggio più lungo, che va più veloce " Messaggio4 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: FineMessaggio = Messaggio2 FinestraSinist = 134: FinestraDestra = 137 incremento = 1 GOSUB Scorri_Messaggio

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 GOSUB Scorri_Messaggio

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: FineMessaggio = Messaggio4 finestraSinist = 150: finestraDestra = 161 incremento = 2 GOSUB Scorri_Messaggio


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 ' Direttiva BASIC Stamp ' $PBASIC 2.5 ' 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 CON 84 ' Vera, 8-bit, senza parità, 9600 LcdCls CON 12 ' Salto pagina -> cancella schermo LcdCr CON 13 ' Ritorno Carrello LcdOff CON 21 ' Spegne il display LcdOn CON 22 ' Accende il display Riga0 CON 128 ' Riga 0, carattere 0 Riga1 CON 148 ' Riga 1, carattere 0 TimeOn CON 250 ' Carattere in tempo TimeOff CON 0 ' Carattere perde tempo ' -----[ Variabili ]---------------------------------------------------------- ' Variabili funzionali per il sottoprogramma Scorri_Messaggio. AvviaCursore VAR Byte ' Posizione del primo carattere testa VAR Byte ' Inizio testo visualizzato coda VAR Byte ' Fine testo visualizzato puntatore VAR Byte ' puntatore indirizzo EEPROM carattere VAR Byte ' memorizza un carattere


' Variabili di Configurazione per il sottoprogramma Scorri_Messaggio. incremento VAR Nib ' Caratteri da spostare finestraDestra VAR Byte ' indirizzo carattere più a destra finestraSinist VAR Byte ' indirizzo carattere più a sinistra InizMessaggio VAR Byte ' Indirizzo EEPROM iniziale FineMessaggio VAR Byte ' Indirizzo 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: FineMessaggio = messaggio2 finestraSinist = 134: finestraDestra= 137 incremento = 1 GOSUB Scorri_Messaggio ' Cambia i valori di alcune variabili di configurazione e ne mostra ' gli effetti sul display ad ogni cambiamento. finestraSinist = 131: finestraDestra = 140 GOSUB Scorri_Messaggio InizMessaggio = Messaggio1: FineMessaggio = messaggio3 GOSUB Scorri_Messaggio InizMessaggio = Messaggio3: FineMessaggio = messaggio4 finestraSinist = 150: finestraDestra = 161 incremento = 2 GOSUB Scorri_Messaggio END ' -----[ Subroutine - Scorri_Messaggio ]-------------------------------------- Scorri_Messaggio: Avviacursore = finestraDestra - incremento + 1 ' carattere più a destra ' nella finestra testa = 0 ' Inizializza testa e coda coda = incremento - 1 ' del messaggio ' Ciclo di scorrimento DO WHILE coda<(FineMessaggio-InizMessaggio)+(finestraDestra-finestraSinist +incremento)


SEROUT PinLcd, T9600, [AvvioCursore] ' carattere più a destra nella ' finestra FOR puntatore = testa TO coda ' Cancella i vecchi caratteri. SEROUT PinLcd, T9600, [" "] NEXT 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.

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.

avviacursore

testa coda

puntatore


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. Orologio da polso, calcolatore, telefono (le risposte possono variare). D2. Due righe di testo, ciascuna riga larga 16 caratteri. D3. Il comando SEROUT. D4. 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] ' Accende, cancella schermo ' 1234567890123456 SEROUT 14, 84, [" Ciao ", CR] ' 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] ' Accende, cancella schermo ' 1234567890123456 SEROUT 14, 84, [" Ciao ", CR] ' Centra testo su riga sup. DO SEROUT 14, 84, [21] ' Spenge schermo PAUSE 500 SEROUT 14, 84, [22] ' Accende schermo PAUSE 500 LOOP

E4. Soluzione esempio:

' Sensori Intelligenti e loro Applicazioni - Eser04_Cap1.bs2 ' Scrive Avvio a inizio riga1, Fine a fine riga2 ' $STAMP BS2 ' $PBASIC 2.5 SEROUT 14, 84, [22, 12] ' Accende, cancella schermo SEROUT 14, 84, ["Avvio"] ' Scrive su Riga 0 SEROUT 14, 84, [160] ' Riga2, 4° car da bordo dx SEROUT 14, 84, ["Fine"] ' Scrive a bordo dx Riga 1


' Sensori Intelligenti e loro Applicazioni - Eser05_Cap1.bs2 ' Scrive a 19200 baud ' $STAMP BS2 ' $PBASIC 2.5 SEROUT 14, 32, [22, 12] ' Accende, cancella schermo SEROUT 14, 32, ["Uso 19200 bps"] ' Scrive su Riga 0


' Sensori Intelligenti e loro Applicazioni - Eser06_Cap1.bs2 ' Scrive a 2400 baud ' $STAMP BS2 ' $PBASIC 2.5 SEROUT 14, 396, [22, 12] ' Accende, cancella schermo 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 PIN 14 T9600 CON 84 PAUSE 250 SEROUT 14, 84, [22, 12] ' Accende e cancella il display PAUSE 5 ' ritarda 5 ms per cancellare il display SEROUT PinLcd, T9600, ["Non ho mai fatto"] SEROUT PinLcd, T9600, ["interferire la "] PAUSE 1500 SEROUT PinLcd, T9600, ["mia istruzione "] SEROUT PinLcd, T9600, ["con l’educazione"] PAUSE 1500 SEROUT PinLcd, T9600, [" -Mark Twain"] SEROUT PinLcd, T9600, [" 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 CON 128 Riga1 CON 148 copie VAR Nib PAUSE 250 SEROUT 14, 84, [22, 12] ' Accende il display e lo cancella PAUSE 5 ' ritarda 5 ms per cancellare il display SEROUT 14, 84, [248, ' Definisce il Carattere personalizzato 0 %00110, ' * * %00101, ' * * %00100, ' * %11111, ' * * * * * %00100, ' * %01110, ' * * * %10101, ' * * * %00100] ' *


FOR copie = 1 TO 3 SEROUT 14, 84, [0] ' Visualizza Carattere personalizzato 0 NEXT 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, ' Ri-definisce Carattere personalizzato 0 %00100, ' * %10011, ' * * * %01001, ' * * %00101, ' * * %00001, ' * %00010, ' * %00100, ' * %11000] ' * * END

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.


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)))

pigolio

Eco Impulso di avvio

Impulso del tempo di eco


(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

: 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?

θ<45° (circa)

oggetti troppo piccoli


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.

tCS aria=

2tC

2SS ariaoggetto ==


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.

2

tC100S aria

cm-oggetto =

1.000.000

2

2

tC100S BS2-PULSINaria

cm-oggetto ×=

10,000

tCS BS2-PULSINaria

cm-oggetto =

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.

10,000

t344,8S BS2-PULSIN

cm-oggetto =

BS2-PULSINt0,03448=

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.

2260655360,03448teCmtanCos =×= 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.

DistanzaCm = CostanteCm ** tempo 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 VAR Word tempo VAR Word DO PULSOUT 15, 5 PULSIN 15, 1, tempo DistanzaCm = CostanteCm ** tempo DEBUG HOME, DEC3 DistanzaCm, " cm" 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.

BS2-PULSINcm-oggetto t0,03448S ×=

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ì:

2,54SS cmin ÷=

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.

890≈≈≈≈889,762,542260tantePolCos =÷=

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 VAR Word DistanzaIn VAR Word tempo VAR Word DO PULSOUT 15, 5 PULSIN 15, 1, tempo DistanzaCm = CostanteCm ** tempo DistanzaIn = CostanteIn ** tempo DEBUG HOME, DEC3 DistanzaCm, " cm" 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

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 2-

8. Il cavallotto deve stare tra i due pin più vicini a Vdd, e il terzo pin vicino a Vin dovrà essere visibile.

LCD Parallax


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 HOME, DEC3 DistanzaCm, " cm" 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 VAR Word tempo VAR Word DO PULSOUT 15, 5 PULSIN 15, 1, tempo DistanzaCm = CostanteCm ** tempo DistanzaIn = CostanteIn ** tempo DEBUG HOME, DEC3 DistanzaCm, " cm" 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.

( )m/sT0,6331,5C Caria ×+=

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.

1,8 32)-(T T FC ÷= 32T1,8 T CF +×=

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).

( ) ( ) m/s344,8m/s 22,2)0,6331,5C22,2Caria =×+=° Esempio 2: Calcolare la velocità del suono a 25 °C, che equivale a 77 gradi Fahrenheit (°F).

( ) ( ) m/s346,5m/s250,6331,525°CCaria =×+=

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.

100%prevista

prevista -effettivaerrore% ×=


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.

100%344,8

344,8 -346,5errore% ×=

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 PIN 13 ' LED rosso attivo alto LCD PIN 14 ' LCD Seriale Parallax Ping PIN 15 ' sensore Ping))) Parallax CostanteCm CON 2260 ' Calcola tempo viaggio del suono CostanteIn CON 890 DistanzaMax CON 361 ' Il massimo che si può misurare ' (empirico) DistanzaCm VAR Word ' Distanza in centimetri tempo VAR Word ' Tempo di eco del viaggio PAUSE 200 ' Inizializza LCD SEROUT LCD, 84, [22, 12] PAUSE 5 DO


LOW LED ' LED spento prima di ciascun misura PULSOUT 15, 5 ' Avvia sensore Ping))) PULSIN 15, 1, tempo ' Legge il tempo di eco DistanzaCm = CostanteCm ** tempo ' 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

P2. Soluzione esempio: ' Sensori intelligenti e loro applicazioni - Progetto2Cap2.bs2 ' Produce un suono quando qualcuno attraversa il vano della porta. ' $STAMP BS2 ' $PBASIC 2.5 ' -----[ Definizioni I/O]--------------------------------------------- Ping PIN 15 ' Sensore Ping))) Parallax Altoparlante PIN 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 ' Bing PAUSE 50 FREQOUT Altoparlante, 450, 2200 ' Bong RETURN Calcola_Distanza:

DistanzaIn = CostanteIn ** tempo ' Ecco tutte le misure RETURN


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

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.

inclinazione asse Y

Inclinazione asse X

Asse Y

Asse X


√ 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 VAR Word y VAR 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 del- l’accelerometro Memsic e del LCD seriale 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.

LCD Parallax


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.

DEBUG HOME, DEC4 ? X, DEC4 ? Y

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 VAR Word y VAR Word ' DEBUG CLS ' Inizializza il LCD PAUSE 200 SEROUT 14, 84, [22, 12] PAUSE 5 DO PULSIN 6, 1, x PULSIN 7, 1, y ' DEBUG HOME, DEC4 ? X, DEC4 ? 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

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 a 1200)

|

| (0 a 1200) → (0 a 254)

| |

| | (0 a 254) → (-127 a 127)

| | |

valore = valore - 1875 ** 13369 - 127

Figura 3-10: Riduzione in scala della variabile valore

Scala di ingresso

Scala di

uscita


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 ** .

−=

1ingresso scala elementi

uscita scala elementi65536IntteScalatanCos

−=

11251

25565536IntteScalatanCos

[ ]13.369,344IntteScalatanCos =

13369teScalatanCos =

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

√ 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

Finestrella

di Trasmissione

Finestrella

di Ricezione

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 >3120, scalato a 126 >3121, scalato a 127 >3124, scalato a 127 >3125, scalato a 127 >


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 con segno e

Numeri Binari Decimale

senza segno Binario a 16-Bit

Bit 15 Bit 0 Decimale con

segno

1 0000000000000001 1

32767 0111111111111111 32767

32768 1000000000000000 -32768

65535 1111111111111111 -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.

−=

1ingresso scala elementi

uscita scala elementi65536IntteScalatanCos

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 **.

−=

111

365536IntteScalatanCos

[ ]19.660,8IntteScalatanCos =

19660teScalatanCos = Il termine valore = valore ** 19660 moltiplica la variabile valore per:

0,29999valorevalore0,299996553619660 ×=→≈÷ 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 ** Costante Scala Valore calcolato Risultato Intero del BASIC Stamp

0 x 0.2999 = 0 0

1 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 =

√ 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.

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

Scala di ingresso

Scala di

uscita


Figura 3-14: Lettura campione per vari orientamenti (inizia in alto a sinistra, ruota in senso orario) a. 1000y100100x == b. 100010y1000x ==

d. 100100y1000x −== c. 1000y100100x =−=

√ 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.

=

=

−

x

ytanθ

x

yθtan

1

Figura 3-16 Tangente e Arcotangente

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.


yatnxangolox

ytanθ 1 =→

= −

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:


6402562,5teScalatanCos =×= 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 **.

−=

1ingresso in scala della elementi

uscita in scala della elementi256IntteScalatanCos/*

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.

−=

1256

360256IntteScalatanCos/*

[ ]361,412IntteScalatanCos/* =

361teScalatanCos/* = 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.

Figura 3-18 Tangente e Arcotangente

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


Per calcolare i valori x ed y da inserire nel Terminale di Debug, utilizzate queste equazioni:

cosθhx

θsinhy

====

====

Figura 3-19 Tangente ed Arcotangente

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.

90

89.9

45 cos127x

90

89.9

sin45127y

45θe127hPer

≈

=

°=

≈

=

°=

°==

71

315 cos100x

71

315 sin100y

315θe100hPer

=

°=

−=

°=

°==

127

180 cos127x

0

180 sin127y

180θe127hPer

−=

°=

=

°=

°==

√ 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 VAR Word x VAR Word y VAR 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 VAR Word brad VAR Word DEBUG CLS, "brad */ 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.

( ) bradgradi angolo256360angolo ×=

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.

==== −−−−

X

Y1

A

Atanθ

Figura 3-20 Rotazione verticale in senso orario

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°

°=

− 01

0tan 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

°=

− 30

2

32

1

tan 1

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

°=

−− 135

2

12

1

tan 1


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.

(((( ))))

====

====

====

========

−−−−

−−−−−−−−

X

Y

X

Y

X

Y

X

Y

A

Atanθ

A

Atanθtantan

A

Aθtan

θtanθcosg

θsing

A

A

1

11


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 VAR Word x VAR Word y VAR 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 angolo = angolo */ 361 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 " ° ".

' Inizializza il LCD 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, ' Definisce il Carattere Personalizzato 7 %01000, ' *


%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

°=

°=

11

11

30

2

3

2

1

tanAx

Aytan

330

2

3

2

1

tanA

Atan

X

Y

====

−−−−

====

−−−−

−−−−−−−−

−−−−−−−−

Questa modifica è facile da fare nel programma. Inserite semplicemente un segno negativo prima della y in angolo = x ATN y.

√ 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).

h

xθcos

h

yθ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 VAR Word brad VAR Word seno VAR Word coseno VAR Word DEBUG "Gradi Brad Coseno Seno", CR FOR gradi = 0 TO 359 STEP 15 brad = gradi ** 46733 seno = SIN brad coseno = COS brad


DEBUG " ", SDEC3 gradi, " ", SDEC3 brad, " ", SDEC3 coseno, " ", SDEC3 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.

h

xcosθ

h

xθcos

h

ysinθ

h

yθsin

1

1

−−−−

−−−−

========

========

Figura 3-30 Seno, Arcoseno, Coseno, e Arcocoseno

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:

' angolo = angolo */ 361 ' 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 ' Direttiva BASIC Stamp ' $PBASIC 2.5 ' Direttiva PBASIC ' -----[ Costanti ]----------------------------------------------------------- Negativo CON 1 ' Segno - .bit15 delle variabili Word Positivo CON 0 ' -----[ Variables ]---------------------------------------------------------- seno VAR Word ' seno nel cerchio di raggio r = 127


lato VAR Word ' variabile della subroutine trig angolo VAR Word ' angolo risultante - gradi segno VAR Bit ' bit del segno ' -----[ Initialization ]----------------------------------------------------- DEBUG CLS ' Cancella il Terminale di Debug seno = -128 ' Inizializza y a -128 ' -----[ Programma principale]------------------------------------------------ DO UNTIL seno = 127 ' Fa variare da y = -127 a y = 127 seno = seno + 1 ' Incrementa di 1 lato = seno ' Pone lato uguale a y DEBUG "seno = ", SDEC seno, " " ' Visualizza il valore di seno GOSUB Arcoseno ' Calcola l’arcoseno DEBUG SDEC ? angolo ' Visualizza l’angolo risultante LOOP ' Ripete DO...LOOP END ' 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: ' Subroutine inversa del seno GOSUB Arcocoseno ' Ottiene l’inversa del coseno angolo = 90 - angolo ' sin(angolo) = cos(90 - angolo) RETURN ' -----[ 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: ' Subroutine inversa del coseno segno = lato.BIT15 ' Memorizza il segno di lato lato = ABS(lato) ' Calcola il positivo di lato angolo = 63 - (lato / 2) ' Approssimazione iniziale di angolo DO ' loop di approssimazione successiva IF (COS angolo <= lato) THEN EXIT ' Fine quando COS angolo <= lato angolo = angolo + 1 ' Prosegue aumentando angolo LOOP angolo = angolo */ 361 ' Converte brad in gradi IF segno = Negativo THEN angolo = 180 – angolo ' Corregge se segno è RETURN ' 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

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 :

==== −−−−

g

Asinθ X1

X

Lo stesso principio si applica all’asse dell’accelerometro ym, e il risultato è il seguente:

Inclinazione

Inclinazione

Inclinazione

Inclinazione


==== −−−−

g

Asinθ Y1

X

Figura 3-32: Determinare l’angolo di inclinazione con la funzione Arcoseno

(((( ))))

====

====

====

====

====

−−−−

−−−−−−−−

g

Asinθ

g

Asinθsinsin

g

Aθsin

θsing

A

θsingA

X1

X11

X

X

X

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 ** 13369 - 127 y = (y MIN 1875 MAX 3125) - 1875 ** 13369 - 127 lato = x GOSUB Arcoseno DEBUG HOME, "angolo inclinazione su x = ", CLREOL, SDEC3 angolo, CR lato = y GOSUB Arcoseno DEBUG "angolo di inclinazione su y = ", CLREOL, SDEC3 angolo PAUSE 100 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 ' Direttiva BASIC Stamp ' $PBASIC 2.5 ' Direttiva PBASIC ' -----[ Costanti ]---------------------------------------------------------- Negativo CON 1 ' Segno - .bit15 delle variabili Word Positivo CON 0 ' -----[ Variabili ]---------------------------------------------------------- x VAR Word ' Misura sull’asse x di Memsic y VAR Word ' Misura sull’asse y di Memsic lato VAR Word ' variabile della subroutine trig angolo VAR Word ' angolo risultante - gradi segno VAR Bit ' bit del segno ' -----[ Inizializzazione ]--------------------------------------------------- DEBUG CLS ' Cancella Terminale di Debug ' -----[ Routine principale --------------------------------------------------


DO PULSIN 6, 1, x ' misura asse x PULSIN 7, 1, y ' 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: ' Subroutine inversa del seno GOSUB Arcocoseno ' Chiama l’inversa del coseno angolo = 90 - angolo ' sin(angolo) = cos(90 - angolo) RETURN ' -----[ 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 angolo = 63 - (lato / 2) ' Approssimazione iniziale di angolo DO ' Ciclo approssimazioni successive IF (COS angolo <= lato) THEN EXIT ' Fatto quando COS angolo <= lato angolo = angolo + 1 ' Aumenta angolo LOOP angolo = angolo */ 361 ' Converte brad in gradi 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.

' Inizializza il LCD PAUSE 200 SEROUT 14, 84, [22, 12] PAUSE 5 SEROUT 14, 84, [128, "inclinazione x =", 148, "inclinazione y ="] SEROUT 14, 84, [255, ' Definisce Carattere personal. 7 %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, " ", 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. Quali sono le sette quantità che si possono misurare con un accelerometro? 2. Cosa significa la sigla MEMS? 3. Cosa si muove all’interno del MX2125 quando lo inclinate? 4. Può la gravità essere considerata una forma di accelerazione? 5. Cosa dovete fare ad un programma che visualizza misure nel terminale di Debug

per far sì che visualizzi invece misure in un LCD seriale? 6. Come potete limitare una variabile in un intervallo di valori? 7. Come potrete orientare la vostra scheda per applicare 1 g all’asse x

dell’accelerometro? 8. Come potete orientare la vostra scheda per applicare 0 g ad entrambi gli assi? 9. Quale è la differenza tra un radiante binario e un grado? 10. Quali sono gli intervalli di valori accettati dagli operatori SIN e COS? Cosa

rappresentano questi valori? 11. Come potete convertire i brad in gradi? 12. Quale intervallo di valori accetta l’operatore ATN? Cosa rappresentano questi

valori? 13. Come potete utilizzare ATN per calcolare l’angolo di rotazione della vostra

scheda? 14. Quale intervallo di valori viene accettato per progetto dalla subroutine

Arcocoseno? Cosa rappresentano questi valori? 15. Quale intervallo di valori viene accettato per progetto dalla subroutine

Arcoseno? Cosa rappresentano questi valori? 16. 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 sul-

l’accelerometro è g sin θ, quindi per ottenere l’angolo dobbiamo prendere l’arcoseno.

E1. y VAR Word PULSIN 10, 1, y

E2. x VAR Word PULSIN 9, 1, x

E3. x = x * 2 E4. x = x * 2 / 1000

-OPPURE- x = x /500

E5. valore = (valore MIN 0 MAX 100) ** 8519 + 20


P1. Soluzione esempio: ' 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 VAR Word angoloVecchio VAR Word x VAR Word y VAR Word ContaVolte VAR Word PAUSE 250 ' Inizializza LCD SEROUT 14, 84, [22, 12] PAUSE 5 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 angolo = angolo */ 361 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

' -----[ Programma principale ]----------------------------------------------- DO PULSIN 6, 1, x ' misura asse x PULSIN 7, 1, y ' 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 ' Pausa 1/10 secondo LOOP ' 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.

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

Siete qui di fronte


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

( )

−=

−=

−=

−=

−

−−

x

ytanθ

x

ytanθtantan

x

y

θcosN

θsinNθtan

1

11

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

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.

asse x N(-S) = 27 asse y w(-E) = - 19 angolo = 35 gradi


√ 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 PIN 2 ' P2 trasmette/riceve a/da Din/Dout Clk PIN 0 ' P0 invia impulsi al clock del HM55B En PIN 1 ' P2 controlla il HM55B/EN(ABLE) ' -----[ Costanti ]----------------------------------------------------------- Reset CON %0000 ' Reimposta i comandi per il HM55B Misura CON %1000 ' Avvia il commando di misura Riporta CON %1100 ' Ottiene il commando stato/valore assi Pronto CON %1100 ' 11 -> Fatto, 00 -> nessun errore MaskNeg CON %1111100000000000 ' Per negativo di 11-bit a 16-bit ' -----[ Variabili ]---------------------------------------------------------- x VAR Word ' dato asse x y VAR Word ' dato asse y stato VAR Nib ' Flag di stato angolo VAR Word ' 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 angolo = angolo */ 361 ' 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 ' Ritarda per i PC più lenti LOOP ' Ripete ciclo principale


' -----[ Subroutine - Ottieni_assi_bussola ]---------------------------------- Ottieni_assi_bussola: ' Subroutine modulo bussola HIGH En: LOW En ' Invia comando reset a HM55B SHIFTOUT DinDout,clk,MSBFIRST,[Reset\4]

HIGH En: LOW En ' commando inizia misura HM55B SHIFTOUT DinDout,clk,MSBFIRST,[Measure\4]

stato = 0 ' Cancella flag stato precedente DO ' Status flag checking loop HIGH En: LOW En ' Measurement status command SHIFTOUT DinDout,clk,MSBFIRST,[Riporta\4] SHIFTIN DinDout,clk,MSBPOST,[Stato\4] ' Ottiene Stato LOOP UNTIL stato = Pronto ' Esce dal ciclo quando stato è Pronto SHIFTIN DinDout,clk,MSBPOST,[x\11,y\11] ' Ottiene valori assi x & y HIGH En ' Disabilita modulo IF (y.BIT10 = 1) THEN y = y | MaskNeg ' Memorizza 11-bit come parola ' con segno IF (x.BIT10 = 1) THEN x = x | MaskNeg ' 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.

xassel' lungo lettura

totale magnetico campo del intensità xassesull' unità =

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

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 DATA @ 0, (4) ' Memorizza gli offset degli assi x ed y ValBassoBussola DATA (1) ' Memorizza indice angolo più piccolo TarBussola DATA (16) ' angoli di bussola di riferimento a 16 bit

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… Punta la bussola su 90 gradi poi premi Invio… Punta la bussola su 180 gradi poii premi Invio


' -----[ Definizioni dei Pin ]------------------------------------------------ DinDout PIN 2 ' P2 trasmette/riceve a/da Din/Dout 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 CON 0 ' Indice per tabella array Precedente CON 1 ' 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", ' attende scelta utente CR, "continuare" DEBUGIN carattere DEBUG CR, CR LOOP ' Ripete ciclo principale ' -----[ Subroutine - Taratura_Bussola ]------------------------------------- Taratura_Bussola: GOSUB Ottieni_E_Memor_Offset_Assi GOSUB Ottieni_E_Memor_Interpolaz GOSUB Ottieni_E_Memor_Indiriz_Val_Min DEBUG 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. FOR contatore = 0 TO 3 ' 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 ' Ovest 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 ' -----[ 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: FOR contatore = 0 TO 15 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 Ottiene_Assi_Bussola ' Ottiene i valori x, ed y GOSUB Corregge_Offset_Bussola ' Corregge offset degli assi angolo = x ATN - y ' Converte x ed y a brad 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 Angolo in Gradi", CR, "Teorico Reale Teorico Reale", CR, "------- ----- ------- -----", CR FOR contatore = 0 TO 15 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 angolo = angolo */ 361 ' Converte brad in gradi DEBUG CRSRX, 28, DEC3 angolo, CR PAUSE 50 ' Ritardo Debug per PC lenti NEXT


DEBUG CR RETURN ' -----[ Subroutine - Ottiene_Assi_Bussola ]---------------------------------- Ottiene_Assi_Bussola: ' Subroutine modulo bussola HIGH En: LOW En ' Invia un comando reset al HM55B SHIFTOUT DinDout,clk,MSBFIRST,[Reset\4] HIGH En: LOW En ' comando inizia misura HM55B SHIFTOUT DinDout,clk,MSBFIRST,[Misura\4] stato = 0 ' Cancella flag stato precedente DO ' Ciclo controllo flag stato HIGH En: LOW En ' Comando stato misura SHIFTOUT DinDout,clk,MSBFIRST,[Riporta\4] SHIFTIN DinDout,clk,MSBPOST,[Stato\4] ' Ottiene stato LOOP UNTIL stato = Pronto ' Esce dal ciclo appena stato è ' Pronto SHIFTIN DinDout,clk,MSBPOST,[x\11,y\11] ' Ottiene valori assi x & y HIGH En ' Disabilita modulo IF (y.BIT10 = 1) THEN y = y | MaskNeg ' Memorizza 11-bit come parola ' con segno IF (x.BIT10 = 1) THEN x = x | MaskNeg ' Ripete per l’altro asse 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 ' Ottiene offset asse x x = x - OffsetAsse ' Corregge asse x READ OffsetBussola + 2, Word OffsetAsse ' Ottiene offset asse y y = y - OffsetAsse ' Corregge asse y RETURN


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 DATA @ 0, (4) ' Memorizza gli offset degli assi x ed y ValBassoBussola DATA (1) ' Memorizza indice angolo più piccolo TarBussola DATA (16) ' angoli di bussola di riferimento a 16 bit ' -----[ Definizioni dei Pin ]------------------------------------------------ DinDout PIN 6 ' P6 trasmette/riceve a/da Din/Dout Clk PIN 5 ' P5 invia impulsi al Clk del HM55B En PIN 4 ' P4 controlla l’EN(ABLE) del HM55B ' -----[ Costanti ]---------------------------------------------------------- Reset CON %0000 ' Riavvia comando per HM55B Misura CON %1000 ' Avvia comando misura Rapporto 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 CON 0 ' Indice per tabella array Precedente CON 1 ' 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 VAR stato ' Indice della EEPROM tabella VAR Byte(2) ' Memorizza valori tabella EEPROM passo VAR x ' Passo tra le entrate in tabella OffsetAngolo VAR y ' Offset tra val. misurati e ‘ entrate in tabella ' -----[ Inizializzazione ]--------------------------------------------------- DEBUG CLS ' -----[ Programma principale ]----------------------------------------------- DO ' Ciclo principale GOSUB Ottiene_Assi_Bussola ' Ottiene valori di x, ed y GOSUB Corregge_Offset_Bussola ' Corregge offset degli assi angolo = x ATN -y ' Converte x ed y in brad DEBUG HOME, "asse x N(-S) = ",SDEC x, ' Visualizza assi corretti CLREOL, CR, "asse y W(-E) = ", SDEC y, CLREOL GOSUB Interpola_Bussola ' Interpolazione lineare


DEBUG CR, CR, "angolo = ", ' Visual. angolo interpolato DEC angolo, " brad", CLREOL ' ... in brad angolo = angolo */ 361 ' Converte brad in gradi DEBUG CR,"angolo = ", ' Visual. angolo interpolato DEC angolo, " gradi", CLREOL ' ... in gradi PAUSE 150 ' Ritardo Debug per PC più lenti LOOP ' 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 SHIFTOUT DinDout,clk,MSBFIRST,[Reset\4] HIGH En: LOW En ' HM55B avvia un comando misura SHIFTOUT DinDout,clk,MSBFIRST,[Misura\4] stato = 0 ' Cancella flag stato precedente DO ' Ciclo controllo flag di stato HIGH En: LOW En ' Comando stato misura SHIFTOUT DinDout,clk,MSBFIRST,[Rapporto\4] SHIFTIN DinDout,clk,MSBPOST,[Stato\4] ' Ottiene stato LOOP UNTIL stato = Pronto ' Fine ciclo quando stato è pronto SHIFTIN DinDout,clk,MSBPOST,[x\11,y\11] ' Ottiene valori assi x & y HIGH En ' Disabilita modulo IF (y.BIT10 = 1) THEN y = y | MaskNeg ' Memorizza 11-bits come parola ‘ con segno IF (x.BIT10 = 1) THEN x = x | MaskNeg ' 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 ' Corregge asse x READ OffsetBussola + 2, Word OffsetAsse ' Ottiene offset asse y y = y - OffsetAsse ' 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, tabella(corrente) 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 READ TarBussola + indice, tabella(corrente)


DO tabella(precedente) = tabella(corrente) indice = indice + 1 READ TarBussola + indice, tabella(corrente) 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 CON 1 ' Word.bit15 = 1 -> negativo Positivo CON 0 ' Word.bit15 = 0 -> positivo

Quindi, aggiungere quattro variabili alla sezione Variabili del programma.

ContaMis VAR Nib ' Conteggio Misura SommaX VAR Word ' Accumulatore misura asse x SommaY VAR Word ' Accumulatore misura asse y segno VAR Bit ' 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 ' Accumulatori a zero SommaY = 0 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 ' Memorizza segno di SommaX SommaX = ABS(SommaX) ' Prende valore assoluto x = SommaX / 10 ' x = media delle misure IF SommaX // 10 >=5 THEN x = x + 1 ' Decimale > .5? Arrotonda in alto IF segno = Negativo THEN x = - x ' se SommaX negativo, nega x segno = SommaY.BIT15 ' Memorizza segno di SommaY SommaY = ABS(SommaY) ' Prende valore assoluto y = SommaY / 10 ' y = media delle misure IF SommaY // 10 >=5 THEN y = y + 1 ' Decimale > .5? Arrotonda in alto IF segno = Negativo THEN y = - y ' 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 VAR Word denominatore VAR Word Risultato VAR Word Segno VAR Bit Negativo CON 1 Positivo 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 PIN 2 ' P2 trasmette/riceve a/da Din/Dout Clk PIN 0 ' P0 invia impulsi al clock del HM55B En PIN 1 ' P2 controlla il HM55B/EN(ABLE) ' -----[ Costanti ]----------------------------------------------------------- Reset CON %0000 ' Reimposta i comandi per il HM55B Misura CON %1000 ' Avvia il commando di misura Riporta CON %1100 ' Ottiene il commando stato/valore assi Pronto CON %1100 ' 11 -> Fatto, 00 -> nessun errore MaskNeg CON %1111100000000000 ' Per negativo di 11-bit a 16-bit Negativo CON 1 ' Word.bit15 = 1 -> negativo Positivo CON 0 ' Word.bit15 = 0 -> positivo ' -----[ Variabili ]---------------------------------------------------------- x VAR Word ' dato asse x y VAR Word ' dato asse y stato VAR Nib ' Flag di stato angolo VAR Word ' Memorizza misura angolo


ContaMis VAR Nib ' Conteggio Misura SommaX VAR Word ' Accumulatore misura asse x SommaY VAR Word ' Accumulatore misura asse y segno VAR Bit ' Bit del Segno

' -----[ 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 angolo = angolo */ 361 ' 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 ' Ritarda per i PC più lenti LOOP ' Ripete ciclo principale ' -----[ Subroutine - Ottieni_assi_bussola]---------------------------------- Ottieni_assi_bussola: ' Subroutine modulo bussola SommaX = 0 ' Accumulatori a zero SommaY = 0 FOR ContaMis = 1 TO 10 ' Prende dieci misure HIGH En: LOW En ' Invia comando reset a HM55B SHIFTOUT DinDout,clk,MSBFIRST,[Reset\4] HIGH En: LOW En ' commando inizia misura HM55B SHIFTOUT DinDout,clk,MSBFIRST,[Misura\4] stato = 0 ' Cancella flag stato precedente DO ' Status flag checking loop HIGH En: LOW En ' Measurement status command SHIFTOUT DinDout,clk,MSBFIRST,[Riporta\4] SHIFTIN DinDout,clk,MSBPOST,[Stato\4] ' Ottiene Stato LOOP UNTIL stato = Pronto ' Esce dal ciclo quando stato è Pronto SHIFTIN DinDout,clk,MSBPOST,[x\11,y\11] ' Ottiene valori assi x & y HIGH En ' Disabilita modulo


IF (y.BIT10 = 1) THEN y = y | MaskNeg ' Memorizza 11-bit come parola ' con segno IF (x.BIT10 = 1) THEN x = x | MaskNeg ' Ripete per l’altro asse SommaX = SommaX + x ' Prende somma in esecuzione di x SommaY = SommaY + y ' Prende somma in esecuzione di y NEXT segno = SommaX.BIT15 ' Memorizza segno di SommaX SommaX = ABS(SommaX) ' Prende valore assoluto x = SommaX / 10 ' x = media delle misure IF SommaX // 10 >=5 THEN x = x + 1 ' Decimale > .5? Arrotonda in alto IF segno = Negativo THEN x = - x ' se SommaX negativo, nega x segno = SommaY.BIT15 ' Memorizza segno di SommaY SommaY = ABS(SommaY) ' Prende valore assoluto y = SommaY / 10 ' y = media delle misure IF SommaY // 10 >=5 THEN y = y + 1 ' Decimale > .5? Arrotonda in alto IF segno = Negativo THEN y = - y ' 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 (6) Cavallotti di filo 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.

Figura 4-12 Schemi del LCD seriale Parallax e del modulo bussola

LCD Parallax


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.

√ Collegate l’altra estremità del cavo in modo che il filo nero sia connesso al pin 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.

√ Collegate l’altra estremità del cavo in modo che il filo nero sia connesso al pin 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. ...", ' Caratteri statici 149, "x=", 158, "y="]

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, " ", 139, DEC angolo, 7, 151, " ", 151, SDEC X, 160, " ", 160, SDEC y]

Programma esempio: ProvaBussolaLcd.bs2

Scarico gratuito! Questo programma è disponibile come file scaricabile gratuitamente dalla Pagina di Prodotto “Smart Sensors and Applications” al sito www.parallax.com.


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 PIN 2 ' P2 trasmette/riceve a/da Din/Dout Clk PIN 0 ' P0 invia impulsi al clock del HM55B En PIN 1 ' P2 controlla il HM55B/EN(ABLE) ' -----[ Constants ]---------------------------------------------------------- Reset CON %0000 ' Reimposta i comandi per il HM55B Misura CON %1000 ' Avvia il commando di misura Riporta CON %1100 ' Ottiene il commando stato/valore assi Pronto CON %1100 ' 11 -> Fatto, 00 -> nessun errore MaskNeg CON %1111100000000000 ' Per negativo di 11-bit a 16-bit ' -----[ Variabili ]---------------------------------------------------------- x VAR Word ' dato asse x y VAR Word ' dato asse y stato VAR Nib ' Flag di stato angolo VAR Word ' Memorizza misura angolo ' -----[ Inizializzazione ]--------------------------------------------------- ' Inizializzazione 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, "Orientaz. ...", ' Caratteri statici 149, "x=", 158, "y="] ' -----[ 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 angolo = angolo */ 361 ' Converte brad a gradi ' Orientazione del Display LCD in gradi sulla riga superiore e ' misure x ed y sulla riga inferiore. SEROUT 14, 84, [139, " ", 139, DEC angolo, 7, 151, " ", 151, SDEC X, 160, " ", 160, SDEC y] PAUSE 150 ' Ritardo del Debug per i PC più lenti LOOP ' Ripete ciclo principale ' -----[ Subroutine - Ottieni_assi_bussola]---------------------------------- Ottieni_assi_bussola: ' Subroutine modulo bussola HIGH En: LOW En ' Invia comando reset a HM55B SHIFTOUT DinDout,clk,MSBFIRST,[Reset\4]

HIGH En: LOW En ' commando inizia misura HM55B SHIFTOUT DinDout,clk,MSBFIRST,[Misura\4]

stato = 0 ' Cancella flag stato precedente DO ' Status flag checking loop HIGH En: LOW En ' Measurement status command SHIFTOUT DinDout,clk,MSBFIRST,[Riporta\4] SHIFTIN DinDout,clk,MSBPOST,[Stato\4] ' Ottiene Stato LOOP UNTIL stato = Pronto ' Esce dal ciclo quando stato è Pronto SHIFTIN DinDout,clk,MSBPOST,[x\11,y\11] ' Ottiene valori assi x & y HIGH En ' Disabilita modulo IF (y.BIT10 = 1) THEN y = y | MaskNeg ' Memorizza 11-bit come parola ' con segno


IF (x.BIT10 = 1) THEN x = x | MaskNeg ' Ripete per l’altro asse 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. Calcolare l’angolo dal nord se la lettura sull’asse x è 34 e quella sull’asse y è 0. 2. Calcolare l’angolo dal nord se la lettura sull’asse x è 16 e quella sull’asse y è 31. 3. Calcolare il numero di nanotesla (tesla x 10-9) presenti in 1,6 microtesla. 4. Scrivere una routine che converta da microtesla a nanotesla. 5. 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


P1. Soluzione esempio: Assumendo che un pulsante attivo-basso sia connesso a P10 e che un piezo-altoparlante 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 PIN 10 altoparlante PIN 11

Aggiungere alla sezione Variabili queste variabili:

MemAngolo VAR Word differenza VAR Word AllarmeArm VAR Bit

Modificare l’ultimo comando SEROUT nella routine di inizializzazione:

SEROUT 14, 84, [128, "All. Ang. posto a ", ' Caratteri statici 148, "OFF "]

Modificare la routine principale come mostrato qui di seguito:

' -----[ Routine principale ]------------------------------------------ DO ' ciclo principale GOSUB Ottieni_Assi_Bussola ' Ottiene i valori di x ed y angolo = x ATN -y ' Converte x ed y in brad angolo = angolo */ 361 ' Converte brad in gradi ' 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 ' Ripete ciclo principale

P2. Soluzione esempio: Cap4_Progetto2.bs2 Questo programma è una combinaztione di InclinOrizzontale.bs2 e ProvaBussola.bs2.

' -----[ Titolo ]------------------------------------------------------------- ' Sensori intelligenti e loro applicazioni - Cap4Progetto2.bs2 ' Visualizza misure bussola digitale e inclinazione in un solo programma. ' $STAMP BS2 ' Direttiva BASIC Stamp ' $PBASIC 2.5 ' Direttiva PBASIC ' -----[ Costanti ]----------------------------------------------------------- Negativo CON 1 ' Segno - .bit15 di variabili Word Positivo CON 0 ' -----[ Definizioni I/O ]-------------------------------------------------- DinDout PIN 6 ' P6 trasmette/riceve a/da Din/Dout Clk PIN 5 ' P5 invia impulsi al Clk del HM55B En PIN 4 ' P4 controlla l’EN(ABLE) del HM55B Reset CON %0000 ' Riavvia comando per HM55B Misura CON %1000 ' Avvia comando misura Rapporto CON %1100 ' Ottiene stato/valori assi Pronto CON %1100 ' 11 -> Fatto, 00 -> senza errori MaskNeg CON %1111100000000000 ' Per negativo 11-bit a 16-bits ' -----[ Variabili ]---------------------------------------------------------- Inclx VAR Word ' misura di Memsic su asse x Incly VAR Word ' misura di Memsic su asse y lato VAR Word ' variabile della subroutine trig angoloIncl VAR Word ' angolo risultante – gradi segno VAR Bit ' bit del segno xBussola VAR Word ' dato asse x yBussola VAR Word ' dato asse y stato VAR Nib ' Flag di stato angoloBussola VAR Word ' Memorizza misura angolo ' -----[ Inizializzazione ]---------------------------------------------------


DEBUG CLS ' Cancella Terminale Debug ' -----[ Routine principale ]------------------------------------------------- DO 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 ' Converte x ed y in brad angoloBussola = angoloBussola */ 361 ' Converte brad in gradi DEBUG CR, "angolo Bussola = ", DEC angoloBussola, " gradi", CLREOL PAUSE 150 ' Ritardo Debug per PC più lenti LOOP ' 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: ' subroutine Inversa di coseno segno = lato.BIT15 ' Memorizza segno del lato lato = ABS(lato) ' Calcola positivo di lato angoloIncl = 63 - (lato / 2) ' approssimazione Iniziale angolo DO ' loop approssimazioni successive IF (COS angoloIncl <= lato) THEN EXIT ' Fatto quando COS angolo <= lato angoloIncl = angoloIncl + 1 ' Incrementa angolo LOOP angoloIncl = angoloIncl */ 361 ' Converte brad in gradi IF segno = Negativo THEN ' Corregge se segno è negativo. angoloIncl = 180 - angoloIncl ENDIF RETURN ' -----[ Subroutine - Ottieni_Assi_Bussola ]-------------------------------- Ottieni_Assi_Bussola: ' Subroutine modulo bussola HIGH En: LOW En ' Invia comando reset a HM55B SHIFTOUT DinDout,clk,MSBFIRST,[Reset\4] HIGH En: LOW En ' commando avvia misura su HM55B SHIFTOUT DinDout,clk,MSBFIRST,[Misura\4] stato = 0 ' Cancella flag stato precedente DO ' Loop controllo flag stato HIGH En: LOW En ' Camando stato misura SHIFTOUT DinDout,clk,MSBFIRST,[Riporta\4] SHIFTIN DinDout,clk,MSBPOST,[stato\4] ' Ottiene stato LOOP UNTIL 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

√ 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.

finestrella di

trasmissione

Digita coordinata X: 9 Digita coordinata Y: 1 Premi un tasto … …

finestrella di ricezione


' 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 VAR Word y VAR Word temp VAR Byte DEBUG CLS, "0123456789X", CR, "1 ", CR, "2 ", CR, "3 ", CR, "4 ", CR, "5 ", CR, "Y ", 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

DEBUG CR, "Digita coordinata Y: " DEBUGIN DEC1 y Y = y MAX 5 MIN 1 ' <--- Aggiungete X = x MIN 1 ' <--- Aggiungete

DEBUG CRSRXY, x, y, "*"

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

Digita coordinata X: 3 Digita coordinata Y: 1 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 VAR Word y VAR Word temp VAR Byte DEBUG CLS,


" 3| ", CR, " 2| ", CR, " 1| ", CR, "------+------", CR, "-3-2-1| 1 2 3", CR, " -2| ", CR, " -3| ", CR, CR DO DEBUG "Digita coordinata X: " DEBUGIN SDEC1 x DEBUG CR, "Digita coordinata Y: " DEBUGIN SDEC1 y x = (x * 2) + 6 y = 3 - y DEBUG CRSRXY, x, y, "*" DEBUG CRSRXY, 0, 10, "Premi un tasto..." DEBUGIN temp DEBUG CRSRXY, 0, 8, CLRDN 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 ' <--- Aggiungere codice da

DEBUG CRSRXY, 0, 8, CLRDN, ' qui... "Digita valori tra -3 e 3.", CR, '

"Prova di nuovo " ' '


ELSE '

' DEBUG CRSRXY, x, y, "*"

' ENDIF ' <--- fino a qui

DEBUG CRSRXY, 0, 10, "Premi un tasto..." 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.

DEBUG "Digita coordinata X: " DEBUGIN SDEC1 x DEBUG CR, "Digita coordinata Y: " 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

DEBUG CRSRXY, x, y, "*"

√ 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 Dopo

(3, 1) 3

(-2, -2) -2

Figura 5-5 Prova Coordinate

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.



( ) CXKX prima dopo +×=

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.

( ) C3K12 +×=

( ) C2K2 +−×= (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.

1. è equazioni le entrambe inC di tecoefficien il poiché ,necessario Non

(3) Sottrarre un’equazione dall’altra per rendere zero una delle incognite.

[ ]5K10

C-2)(K 2

C3)(K12

×=

+×=−

+×=

(4) Risolvere nell’incognita che non si annulla nella sottrazione.

2 K 5

10K

5K10

=

=

×=

(5) Sostituire il valore ricavato al punto 4 in una delle due equazioni originali.

( ) C3212 +×= (6) Risolvere nella seconda incognita.


( )

6C

612C

C612

C3212

=

=

+=

+×=

-

(7) Incorporare i valori ricavati per le incognite nella vostra equazione.

( )

( ) 6X2X

6Ce2K

CXKX

primadopo

primadopo

+×=

==

+×=

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 Dopo

(3, 1) 1

(-2, -2) -2


Figura 5-6 Coordinate di prova

√ Ripetete i passi da 1 a 7 per l’equazione sull’asse Y. La risposta corretta è:

( ) 3y1y primadopo +×−=

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, ' 0 " 3| ", CR, ' 14 " 2| ", CR, ' 28 " 1| ", CR, ' 42 "------+------", CR, ' 56 "-3-2-1| 1 2 3", CR, ' 70 " -2| ", CR, ' 84 " -3| ", CR, CR ' 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 ' Direttive Stamp & PBASIC '$PBASIC 2.5 indice VAR Byte ' Variabili carattere VAR Byte DATA CLS, ' 0 ' Memorizza sfondo in EEPROM " 3| ", CR, ' 14 " 2| ", CR, ' 28 " 1| ", CR, ' 42 "------+------", CR, ' 56 "-3-2-1| 1 2 3", CR, ' 70 " -2| ", CR, ' 84 " -3| ", CR, CR ' 98 + 1 = 99 FOR indice = 0 TO 99 ' Trova e visualizza sfondo READ indice, carattere DEBUG carattere NEXT 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 VAR Word y VAR Word xVec VAR Nib ' <--- Aggiungi yVec VAR Nib ' <--- Aggiungi

temp VAR Byte

(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 ' <--- Aggiungi yVec = y ' <--- Aggiungi


DEBUG "Digita coordinata X: "

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, x, y, "*" DEBUG CRSRXY, 0, 10, ' <--- Aggiungere "Entrata attuale: (",

DEC x, ",", DEC y, ")"

DEBUG CRSRXY, 0, 11, ' <--- Aggiungere "Entrata preced.: (",

DEC xVec, ",", DEC yVec, ")" ' <--- Modificare DEBUG CRSRXY, 0, 12, "Premi un tasto..." ' <--- 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

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 ' Controlla se asterisco è mosso index = (14 * yVec) + xVec + 1 ' Indirizzo carattere sfondo READ indice, carattere ' Ottiene carattere sfondo DEBUG CRSRXY, xVec, yVec, carattere ' Visualizza carattere sfondo ENDIF

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

Digita coordinata X: 2 Digita coordinata Y: 1

Premi un tasto…


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 ' direttive Stamp/PBASIC '$PBASIC 2.5 ' -----[ Variabili ]------------------------------------------------------- x VAR Word ' Memorizza posizione attuale y VAR Word xVec VAR Nib ' Memorizza posizione precedente yVec VAR Nib temp VAR Byte ' Variabile finta per DEBUGIN indice VAR Byte ' Memorizza READ indice/carattere


carattere VAR Byte ' -----[ EEPROM Data ]----------------------------------------------------- DATA CLS, ' Dati per sfondo " 3| ", CR, ' 14 " 2| ", CR, ' 28 " 1| ", CR, ' 42 "------+------", CR, ' 56 "-3-2-1| 1 2 3", CR, ' 70 " -2| ", CR, ' 84 " -3| ", CR, CR ' 98 + 1 = 99 ' -----[ Inizializzazione ]------------------------------------------------ FOR indice = 0 TO 99 ' Visualizza sfondo READ indice, carattere DEBUG carattere NEXT ' -----[ Routine principale]----------------------------------------------- DO xVec = x ' Memorizza coordinate precedenti yVec = y DEBUG "Digita coordinata X: " ' Ottiene nuove coordinate DEBUGIN SDEC1 x DEBUG CR, "Digita coordinata Y: " DEBUGIN SDEC1 y x = (x * 2) + 6 ' Da Cartesiane a valori x DEBUG y = 3 - y DEBUG CRSRXY, x, y, "*" ' Visualizza asterisco IF (x <> xVec) AND (y <> yVec) THEN ' Controlla se asterisco mosso indice = (14 * yVec) + xVec + 1 ' Indirizzo carattere sfondo READ indice, carattere ' Ottiene carattere sfondo DEBUG CRSRXY, xVec, yVec, carattere ' Visualizza carattere sfondo ENDIF DEBUG CRSRXY, 0, 10, "Premi un Tasto..." ' Attende input utente DEBUGIN temp DEBUG CRSRXY, 0, 8, CLRDN ' Cancella vecchie info LOOP


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 ' Rivisualizza sfondo READ indice, carattere DEBUG CRSRXY, x, y, carattere DEBUG CRSRXY, 0, 8, ' Ottieni nuove coordinate "Diigita coordinata X: " DEBUGIN SDEC1 x DEBUG CR, "Digita coordinata Y: " DEBUGIN SDEC1 y x = (x * 2) + 6 ' da Cartesiane a valori di DEBUG y = 3 - y DEBUG CRSRXY, x, y, "*" ' Visualizza asterisco DEBUG CRSRXY, 0, 10, "Premi un Tasto..." ' Aspetta input utente DEBUGIN temp DEBUG CRSRXY, 0, 8, CLRDN ' 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 DEBUG CRSRXY, x, y, "*" ELSE index = (14 * yVec) + xVec + 1 READ indice, carattere DEBUG CRSRXY, xVec, yVec, carattere 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 posizione del gas

L’asterisco indica la posizione del gas bollente


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.

Figura 5-12: Inclinazione dell’Accelerometro e posizione del cursore

Livellato

Inclina a destra

Inclina a sinistra

Inclina in basso

Inclina in alto

Inclinazione

Centro gas bollente

(0, 0)

( - 3, 0)

(3, 0)

(0, - 3)

(0, 3)


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 ' direttive Stamp/PBASIC '$PBASIC 2.5 ' -----[ Dati in EEPROM ]----------------------------------------------------- ' Memorizza sfondo in EEPROM ' Indirizzo ultimo car su riga DATA CLS, ' 0 " 5^Y ", CR, ' 22 " 4| ", CR, ' 44 " 3| ", CR, ' 66 " 2| ", CR, ' 88 " 1| X", CR, ' 110 "----------+--------->", CR, ' 132 "-5-4-3-2-1| 1 2 3 4 5", CR, ' 154 " -2| ", CR, ' 176


" -3| ", CR, ' 198 " -4| ", CR, ' 220 " -5| ", CR ' 242 ' -----[ Variabili ]---------------------------------------------------------- x VAR Word ' Memorizza posizione attuale y VAR Word indice VAR Word ' memoria indice/carattere READ car VAR Byte ' -----[ Inizializzazione ]--------------------------------------------------- FOR indice = 0 TO 242 ' Legge & visualizza sfondo READ indice, car DEBUG car NEXT ' -----[ Routine principale ]------------------------------------------------- DO ' 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 ' Ottiene Ax ed Ay PULSIN 7, 1, y ' Calcola posizione cursore. x = (x MIN 1875 MAX 3125) - 1875 ** 1101 ' Calcola posizione x y = (y MIN 1875 MAX 3125) - 1875 ** 576 ' Calcola posizione y y = 10 - y ' Visualizza asterisco alla nuova posizione del cursore. DEBUG CRSRXY, x, y, "*" ' Visualizza asterisco 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 ' Coordinate -> indirizzo EEPROM READ indice, car ' Ottiene carattere sfondo DEBUG CRSRXY, x, y, car ' Visualizza carattere sfondo PAUSE 50 ' Pausa per effetto lampeggio

Quindi, il programma acquisisce l’inclinazione x ed y. ' Misura inclinazione. PULSIN 6, 1, x ' Ottiene Ax ed Ay PULSIN 7, 1, y

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 ' Calcola posizione x y = (y MIN 1875 MAX 3125) - 1875 ** 576 ' Calcola posizione y


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. DEBUG CRSRXY, x, y, "*" 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 nuova posizione del cursore (modificata). DEBUG CRSRXY, x, y, "*", CRSRXY, x MAX 19 + 1, y, "*", CRSRXY, x, y MAX 9 + 1, "*", CRSRXY, x MIN 1 - 1, y, "*", CRSRXY, x, y MIN 1 - 1, "*" PAUSE 50

√ 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)

HAI VINTO

Punteggio : 000

HAI PERSO


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 ' direttive Stamp/PBASIC '$PBASIC 2.5 ' -----[ Dati EEPROM ]-------------------------------------------------------- ' Memorizza sfondi in EEPROM ' 3 sfondi usati nel gioco Maze DATA @0, HOME, ' Sfondo labirinto "#####################", CR, "###### $ ########", CR, "## ### ###", CR, "# ########### ###", CR, "#$ # ####", CR, "##### # $ #####WIN", CR, "# ## ## $ #", CR, "# $ ########### # #", CR, "# ##$## # #", CR, "# ######## #", CR, "#####################", CR YouLose DATA @243, HOME, ' Sfondo YouLose (HaiPerso) "#####################", CR, "#####################", CR,


"### ####### ####", CR, "### ####### ####", CR, "#####################", CR, "########## ##########", CR, "#####################", CR, "### ####", CR, "### HAI PERSO ####", CR, "### ####", CR, "#####################", CR YouWin DATA @486, HOME, ' Sfondo YouWin (Hai vinto) " ########### ", CR, " ################# ", CR, "##### ##### #####", CR, "#### ### ####", CR, "# ### ##### ### #", CR, "# ############### #", CR, "## ########### ##", CR, "## ##", CR, " #### HAI VINTO #### ", CR, " #### #### ", CR, " ######### ", CR ' -----[ Variabili ]---------------------------------------------------------- x VAR Word ' inclin. x & y & coordinate grafiche y VAR Word indice VAR Word ' indirizzo e carattere in EEPROM car VAR Byte symbol VAR Word ' Indirizzo Simbolico per DATA EEPROM punti VAR Byte ' 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 FOR indice = 0 TO 242 ' Visualizza labirinto READ indice + symbol, car DEBUG car NEXT ' -----[ Routine principale ]------------------------------------------------- DO ' Visualizza sfondo alla posizione cursore.


indice = (22 * y) + x + 1 ' Coordinate -> indirizzo EEPROM READ indice + symbol, car ' Ottiene carattere di sfondo DEBUG CRSRXY, x, y, car ' Visualizza carattere sfondo PAUSE 50 ' Pausa per effetto lampeggio ' 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 ' Calcola posizione x y = (y MIN 1875 MAX 3125) - 1875 ** 576 ' Calcola posizione y y = 10 - y ' Visualizza asterisco in nuova posizione. DEBUG CRSRXY, x, y, "*" ' Visualizza asterisco PAUSE 50 ' Nuova pausa per effetto lampeggio ' Visualizza punteggio DEBUG CRSRXY, 0, 11, ' Visualizza punti "Punteggio: ", DEC3 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 FOR indice = 0 TO 242 ' 242 caratteri READ indice + symbol, car ' Ottiene carattere DEBUG car ' Visualizza carattere NEXT ' Iterazione successiva END ' Fine gioco ENDIF ' Fine blocco codice symbol-if LOOP ' Ripete ciclo principale

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, "#####################", CR, "###### $ ########", CR, · · · YouLose DATA @243, HOME, "#####################", CR, "#####################", CR, · · · YouWin DATA @486, HOME, " ########### ", 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 VAR Word punti VAR 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 READ indice + symbol, car DEBUG car NEXT

Tre routine devono essere aggiunte al DO...LOOP della Routine principale. La prima visualizza semplicemente il punteggio del giocatore:

' Visualizza punteggio DEBUG CRSRXY, 0, 11, ' Visualizza punti "Punteggio: ", DEC3 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 "$" ' Se "$" punti = punti + 10 ' Aggiunge punti WRITE index, "%" ' Scrive "%" sopra "$" CASE "#" ' Se "#", pone Symbol a YouLose symbol = YouLose CASE "V", "I", "N", "T", "O" ' Se V,I,N,T o O Symbol -> YouWin symbol = YouWin ENDSELECT

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 FOR indice = 0 TO 242 ' 242 caratteri READ indice + symbol, car ' 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 ' Visualizza labirinto READ indice + symbol, car IF(car = "%") THEN ' <--- Aggiungere car = "$" ' <--- Aggiungere WRITE indice + symbol, car ' <--- Aggiungere

ENDIF ' <--- Aggiungere

DEBUG car NEXT

√ 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 VAR Word ' inclinazioni x & y & coordinate y VAR Word xVec VAR Word ' <--- Aggiungere yVec VAR Word ' <--- Aggiungere

√ Aggiungete istruzioni che inizializzano xVec ed yVec. x = 10 ' Inizia car di gioco in centro xVec = 10 ' <--- Aggiungere

y = 5 yVec = 5 ' <--- 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 ' <--- Aggiungere

IF (x < xVec) THEN x = xVec MIN 1 - 1 ' <--- Aggiungere

IF (y > yVec) THEN y = yVec MAX 9 + 1 ' <--- Aggiungere

IF (y < yVec) THEN y = yVec MIN 1 - 1 ' <--- Aggiungere


' Visualizza asterisco alla nuova posizione. DEBUG CRSRXY, x, y, "*" ' Visualizza asterisco PAUSE 50 ' Nuova Pausa per effetto lampeggio xVec = x ' <--- Aggiungere yVec = y ' <--- Aggiungere

' Visualizza punteggio

√ 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. Dispositivo a interfaccia umana (Human Interface Device). Q2. CLRDN. Q3. DEBUGIN DEC1 x. Q4. 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 READ indice + symbol, car

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. E1. Soluzione esempio:

DEBUG CRSRXY, 5, 7, "* questa è la coordinata (5,7) nel Terminale di Debug "

E2. Soluzione esempio: DEBUG CLS, " 2| ", CR, " 1| ", CR, "----+----", CR, "-2-1| 1 2", CR, " -2| ", CR, CR

E3. La scalatura dell’asse X è 2 e l’offset è 10; per l’asse Y, la scalatura è -1 e l’offset è 5.


E4. Soluzione esempio: x VAR Byte y VAR Byte FOR x = 1 TO 15 FOR y = 1 TO 5 DEBUG CRSRXY, x, y, "*" 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 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

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 DEBUG "Digita coordinata X: " DEBUGIN SDEC1 x DEBUG CR, "Digita coordinata Y: " DEBUGIN SDEC1 y DEBUG CRSRXY, 15, 3, "(X,Y) = (", SDEC x, ",", SDEC y, ")", CLREOL

x = (x * 2) + 6 y = 3 - y DEBUG CRSRXY, x, y, "*" DEBUG CRSRXY, 0, 10, "Premi un tasto..."


DEBUGIN temp DEBUG CRSRXY, 0, 8, CLRDN 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

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.

Opposto

Edificio

Altezza oggetto

Adiacente

Altezza accelerometro

Linea di visione

Linea di visione


θtanadiacenteopposto

adiacente

oppostoθ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.

troaccelerome altezzaθtan adiacente oggetto altezza

troaccelerome altezzaopposto oggetto altezza

+=

+=

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.


( )( )

m19,54

m1,5m18,04

troaccelerome altezzaoppostooggetto altezza

18,04

1,804m10

θtanm10

θtanadiacenteopposto

m1.5troacceleromedell' Altezza

61θmisurato hatroacceleromeL'

m10 adiacente Distanza

=

+=

+=

=

=

=

=

=

°=

=

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 DATA (10) RecordsEnd DATA

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 RecordsEnd = 10

I byte EEPROM 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 FOR eeIndice = Records TO RecordsEnd 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 FOR eeIndice = Records TO RecordsEnd 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.

Figura 6-2 Digitazione di valori nel programma MemoriaDatiEeprom.bs2

√ 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.

Finestrella

di trasmissione

Finestrella di ricezione

Digita C, R o D C – Cancella record R – Registra record D – Visualizza record >r Digita valori da -100 a 100 Record 0 >-100 Record 1 >-75 Record 2 >-50 Record 3 >-25


√ 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 DATA (10) RecordsEnd DATA ' -----[ Variabili ]---------------------------------------------------------- car VAR Byte eeIndice VAR Word valore VAR 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: FOR eeIndice = Records TO RecordsEnd WRITE eeIndice, 100 NEXT DEBUG CR, "Record cancellati." PAUSE 1000 RETURN ' -----[ Subroutine - Registra_Data ]----------------------------------------- Registra_Dati: DEBUG CR, "Digita valori tra -100 e 100", CR FOR eeIndice = Records TO RecordsEnd 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 ' -----[ Subroutine - Visualizza_Dati ]--------------------------------------- Visualizza_Dati: DEBUG CR, "Indice Record", CR, "------ ------", CR FOR eeIndice = Records TO RecordsEnd 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

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 DATA 0 Records DATA (10) RecordsEnd DATA ' -----[ Variabili ]---------------------------------------------------------- car VAR Byte eeIndice VAR Word valore VAR Word ' -----[ 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 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, "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 di nuovo." PAUSE 1500 ENDSELECT LOOP ' -----[ Subroutine - Cancella_Dati ]----------------------------------------- Cancella_Dati: FOR eeIndice = Records TO RecordsEnd WRITE eeIndice, 100 NEXT DEBUG CR, "Record cancellati." PAUSE 1000 RETURN ' -----[ Subroutine - Registra_Dati ]----------------------------------------- Registra_Dati: DEBUG CR, "Digita valori tra -100 e 100", CR FOR eeIndice = Records TO RecordsEnd 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 ' -----[ Subroutine - Visualizza_Dati ]-------------------------------------- Visualizza_Dati: DEBUG CR, "Indice Record", CR, "------ ------", CR FOR eeIndice = Records TO RecordsEnd 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

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 (4) Cavallotti di filo

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.", CR, "Premi Invio per il menu..." 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 DATA 0 Records DATA (1000) RecordsEnd DATA ' -----[ Variabili ]---------------------------------------------------------- car VAR Byte eeIndice VAR Word valore VAR Word x VAR valore y VAR Word ' -----[ Inizializzazione ]--------------------------------------------------- Init: READ Reset, valore valore = valore + 1 WRITE Reset, valore


IF valore // 2 = 0 THEN FOR car = 10 TO 0 DEBUG CLS, "Inizio registrazione dati ", CR, "in ", DEC2 car, " secondi", CR, CR, "Premere/rilasciare Reset", CR, "per tornare a menu..." FREQOUT 4, 50, 3750 PAUSE 950 NEXT GOSUB Registra_Dati ENDIF ' -----[ Routine principale ]------------------------------------------------- DO DEBUG CLS, "Premere/Rilasciare Reset", CR, "per armare la registrazione dati ", CR, CR, " - oppure - ", CR, CR, "Digitare 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 di nuovo." PAUSE 1500 ENDSELECT LOOP ' -----[ Subroutine - Cancella_Dati ]----------------------------------------- Cancella_Dati: DEBUG CR, "Sto cancellando..."


FOR eeIndice = Records TO RecordsEnd WRITE eeIndice, 0 NEXT DEBUG CR, "Record cancellati." PAUSE 1000 RETURN ' -----[ Subroutine - Registra_Dati ]----------------------------------------- Registra_Dati: FREQOUT 4, 75, 4000 PAUSE 200 FREQOUT 4, 75, 4000 DEBUG CLS, "Sto registrando..." 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.", CR, "Premi Invio per il menu..." DEBUGIN car RETURN ' -----[ Subroutine - Visualizza_Dati ]--------------------------------------- Visualizza_Dati: DEBUG CR, "Indice asse x asse y", CR, "------ ------ ------", CR FOR eeIndice = Records TO RecordsEnd STEP 2 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 DEBUG CR, "Premi Invio per il menu..." 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 WRITE eeIndice + 1, y

...con questa operazione ATN e quest’altro commando WRITE: valore = x ATN y WRITE eeIndice, valore

√ Modificate la testata della visualizzazione nella subroutine Visualizza_Dati in modo che sia come questa: DEBUG CR, "Indice angolo ", CR, "------ ------ ", CR

√ Sostituite questi quattro comandi: READ eeIndice, x x = x - 100 READ eeIndice + 1, y y = y - 100

...con questi due: READ eeIndice, valore

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.


Figura 6-5 Misure sull’asse Y dell’Accelerometro per una automobile RC

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.

RC Car Forward and Backward

-40 -30 -20 -10

0 10 20 30

0 50 100 150 200 250 300

seconds/30

gravity/100

Accelera avanti

Decelera

Stop

Accelera indietro

Decelera


a. b.

Figura 6-6 Accelerazione dell’automobile RC vs Asse sensorio dell’Accelerometro

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.

Accelerazione a = xm

Parte anteriore Parte anteriore

Accelerazione a = ym


Figura 6-8 Misure con l’Accelerometro di un’automobile RC mentre si guida in cerchi

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.

RC Car Left then Right

-100 -80 -60 -40 -20

0 20 40 60

0 100 200 300 400 500 600

seconds/30

gravity/100

Left Turn Circles

in senso

destro

Cerchi

Straighten Out

Cerchi in senso sinistro

Marcia rettilinea


Figura 6-9: Sentire l’accelerazione durante le curve

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.

Anteriore Anteriore

Accelerazione a = +xm

Accelerazione a = - xm


√ 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

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.

secondi/30

Accelerazione dell’auto RC in avanti e indietro

gra

vità

/100


Figura 6-11: Grafico della velocità dedotto dai dati di posizione iniziale e accelerazione

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 at

2. 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.

Accelerazione dell’auto RC in avanti e indietro

secondi/30

velo

cità

(m

/sec

)


Figura 6-12: Grafico della posizione ricavato dai dai di posizione iniziale, velocità iniziale ed accelerazione

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 at

2, 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

Posizione auto RC – Marcia avanti e indietro

secondi/30

Distanza, m


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.


Figura 6-15 Accelerazione durante un Ollie

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.

Acceleration vs Time for First Ollie

-1.5 -1

-0.5 0

0.5 1

1.5 2

2.5 3

3.5

170 190 210 230 250 270

tempo (ms)

gravità (g)

a, b

c, d

e

f

Accelerazione in funzione del tempo per il primo ollie


Figura 6-16 Grafico di un Ollie leggermente migliore

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.

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.

Accelerazione vs Tempo per il secondo Ollie

-1.5 -1

-0.5 0

0.5 1

1.5 2

2.5 3

3.5

775 795 815 835 855 875

tempo (ms)

gravità, (g)

a, b

c, d e

f

Asse x

Avanti

Asse y


FOR eeIndice = Records TO RecordsEnd STEP 2 PULSIN 7, 1, y WRITE eeIndice, Word y NEXT

Modifiche analoghe saranno fatte al ciclo FOR...NEXT nella subroutine Visualizza_Dati qui riportata.

FOR eeIndice = Records TO RecordsEnd STEP 2 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 DATA 0 Records DATA (1000) RecordsEnd DATA ' -----[ Variabili ]---------------------------------------------------------- car VAR Byte eeIndice VAR Word valore VAR Word x VAR valore


y VAR Word ' -----[ Inizializzazione ]--------------------------------------------------- Init: READ Reset, valore valore = valore + 1 WRITE Reset, valore IF valore // 2 = 0 THEN FOR car = 10 TO 0 DEBUG CLS, "La registr. Dati partirà ", CR, "in ", DEC2 car, " secondi", CR, CR, "Premi/rilascia Reset", CR, "per il menu..." FREQOUT 4, 50, 3750 PAUSE 950 NEXT GOSUB Registra_Dati ENDIF ' -----[ Routine principale ]------------------------------------------------- DO DEBUG CLS, "Premi/Rilascia Reset", CR, "per iniziare a registrare ", CR, CR, " - oppure - ", CR, CR, "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, "Entrata non valida.", CR, "Prova ancora." PAUSE 1500 ENDSELECT LOOP ' -----[ Subroutine - Cancella_Dati ]-------------------------------------------- Cancella_Dati: DEBUG CR, "Cancello..." FOR eeIndice = Records TO RecordsEnd WRITE eeIndice, 0 NEXT DEBUG CR, "Record cancellati." PAUSE 1000 RETURN ' -----[ Subroutine - Registra_Dati ]----------------------------------------- Registra_Dati: FREQOUT 4, 75, 4000 PAUSE 200 FREQOUT 4, 75, 4000 DEBUG CLS, "Regisro..." FOR eeIndice = Records TO RecordsEnd STEP 2 PULSIN 7, 1, y WRITE eeIndice, Word y NEXT FREQOUT 4, 200, 4000 DEBUG CR, "Fine dei record.", CR, "Premi Invio per il menu..." DEBUGIN car RETURN ' -----[ Subroutine - Visualizza_Dati ]---------------------------------------


Visualizza_Dati: DEBUG CR, "Indice asse x asse y ", CR, "------ ------ ------", CR FOR eeIndice = Records TO RecordsEnd STEP 2 READ eeIndice, Word y DEBUG DEC eeIndice, CRSRX, 7, SDEC y, CR NEXT DEBUG CR, "Premi Invio per il menu..." 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.

a. b.

Figura 6-18 Scheda HomeWork con l’accelerometro montata sulla ruota di una bicicletta

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 6-18. 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 VAR Word contatore VAR Word DEBUG CLS 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

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

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à.

Ruota di bicicletta a due velocità differenti

-2 -1.5

-1 -0.5

0 0.5

1 1.5

2

0 100 200 300 400 500 600 700 800 900 1000

tempo, ms

gravità, g

Asse y dell’accelerometro

Asse x dell’accelerometro


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 DATA 0 Records DATA (1000) RecordsEnd DATA ' -----[ Variabili ]---------------------------------------------------------- car VAR Byte eeIndice VAR Word valore VAR Word x VAR valore y VAR Word ' -----[ Inizializzazione ]--------------------------------------------------- Init: READ Reset, valore valore = valore + 1 WRITE Reset, valore IF valore // 2 = 0 THEN FOR car = 10 TO 0 DEBUG CLS, "Inizia registraz. dati ", CR, "in ", DEC2 car, " secondi", CR, CR, "Premi/rilascia Reset", CR, "per il menu..." FREQOUT 4, 50, 3750 PAUSE 950 NEXT


GOSUB Registra_Dati ENDIF ' -----[ Routine principale ]------------------------------------------------- DO DEBUG CLS, "Premi/Rilascia Reset", CR, "per iniziare a registrare ", CR, CR, " - oppure - ", CR, CR, "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, "Entrata non valida.", CR, "Prova di nuovo." PAUSE 1500 ENDSELECT LOOP ' -----[ Subroutine - Cancella_Dati ]----------------------------------------- Cancella_Dati: DEBUG CR, "Cancello..." FOR eeIndice = Records TO RecordsEnd WRITE eeIndice, 0 NEXT DEBUG CR, "Record cancellati." PAUSE 1000 RETURN ' -----[ Subroutine - Registra_Dati ]----------------------------------------- Registra_Dati:


FREQOUT 4, 75, 4000 PAUSE 200 FREQOUT 4, 75, 4000 DEBUG CLS, "Registro..." FOR eeIndice = Records TO RecordsEnd STEP 4 PULSIN 6, 1, x PULSIN 7, 1, y WRITE eeIndice, Word x WRITE eeIndice + 2, Word y NEXT FREQOUT 4, 200, 4000 DEBUG CR, "Fine dei record.", CR, "Premi Invio per il menu..." DEBUGIN car RETURN ' -----[ Subroutine - Visualizza_Dati ]--------------------------------------- Visualizza_Dati: DEBUG CR, "Indice asse x asse y", CR, "------ ------ ------", CR FOR eeIndice = Records TO RecordsEnd STEP 4 READ eeIndice, Word x READ eeIndice + 2, Word y DEBUG DEC eeIndice, CRSRX, 7, SDEC x, CRSRX, 14, SDEC y, CR NEXT DEBUG CR, "Premi Invio per il menu..." 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, "in ", DEC2 car, " secondi", CR, CR, "Premi/rilascia Reset", 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:

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

asse x--------

2500

2700

2900

3100

3300

3500

3700

3900

1 16 31 46 61 76 91 106 121 136 151 166 181 196 211 226 241

asse x ------


StepHigh CON 3300 y VAR Word yVec VAR Word Cntpassi VAR Word yVec = 3300 PAUSE 250 ' Scollega alimentazione SEROUT 14, 84, [22, 12] ' Avvia LCD & cancella display PAUSE 5 ' 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 %11111, ' * * * * * %00011, ' 0 0 0 * * %11011, ' * * 0 * * %11011, ' * * 0 * * %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11111 ' * * * * * . . . Car9 DATA %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11011, ' * * 0 * * %11011, ' * * 0 * * %11000, ' * * 0 0 0 %11111 ' * * * * * . . .

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 + 1 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 Pagina di Prodotto “Smart Sensors and Applications” al sito www.parallax.com.

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 ' Dispositivo bersaglio = BASIC Stamp 2 ' $PBASIC 2.5 ' Linguaggio = PBASIC 2.5 ' -----[ Dati in EEPROM ]----------------------------------------------------- Car0 DATA %11111, ' * * * * * %01111, ' 0 * * * * %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11111 ' * * * * * Car1 DATA %11111, ' * * * * * %00111, ' 0 0 * * * %11111, ' * * * * *


%11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11111 ' * * * * * Car2 DATA %11111, ' * * * * * %00011, ' 0 0 0 * * %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11111 ' * * * * * Car3 DATA %11111, ' * * * * * %00011, ' 0 0 0 * * %11011, ' * * 0 * * %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11111 ' * * * * * Car4 DATA %11111, ' * * * * * %00011, ' 0 0 0 * * %11011, ' * * 0 * * %11011, ' * * 0 * * %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11111 ' * * * * * Car5 DATA %11111, ' * * * * * %10011, ' * 0 0 * * %11011, ' * * 0 * * %11011, ' * * 0 * * %11011, ' * * 0 * * %11111, ' * * * * * %11111, ' * * * * * %11111 ' * * * * * Car6 DATA %11111, ' * * * * * %11011, ' * * 0 * * %11011, ' * * 0 * * %11011, ' * * 0 * * %11011, ' * * 0 * * %11011, ' * * 0 * * %11111, ' * * * * * %11111 ' * * * * *


Car7 DATA %11111, ' * * * * * %11111, ' * * * * * %11011, ' * * 0 * * %11011, ' * * 0 * * %11011, ' * * 0 * * %11011, ' * * 0 * * %11011, ' * * 0 * * %11111 ' * * * * * Car8 DATA %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11011, ' * * 0 * * %11011, ' * * 0 * * %11011, ' * * 0 * * %11001, ' * * 0 0 * %11111 ' * * * * * Car9 DATA %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11011, ' * * 0 * * %11011, ' * * 0 * * %11000, ' * * 0 0 0 %11111 ' * * * * * Car10 DATA %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11011, ' * * 0 * * %11000, ' * * 0 0 0 %11111 ' * * * * * Car11 DATA %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11000, ' * * 0 0 0 %11111 ' * * * * * Car12 DATA %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * *


%11100, ' * * * 0 0 %11111 ' * * * * * Car13 DATA %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11111, ' * * * * * %11110, ' * * * * 0 %11111 ' * * * * * 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 CON 12 ' Nuova pagina -> cancella schermo CrLcd CON 13 ' Ritorno carrello OffLcd CON 21 ' Spegne il display (off) OnLcd CON 22 ' Accende il display (on) Riga0 CON 128 ' Riga 0, carattere 0 Riga1 CON 148 ' Riga 1, carattere 0 Definisce CON 248 ' Indirizzo che definisce car pers 0 ' -----[ Variabili ]---------------------------------------------------------- CarPers VAR Nib ' Selettore del carattere personal. indice VAR Nib ' variabile indice Eeprom carBase VAR Byte ' Carattere base per la READ RigaPunt VAR Byte ' linea puntinata da 5-pixel cursore VAR Nib ' posizionamento cursore contatore VAR Nib ' variabile che conta nel ciclo princ. riga VAR Byte ' Riga0 o Riga1 ' -----[ Inizializzazione ]--------------------------------------------------- PAUSE 100 ' scollega alimentazione SEROUT PinLcd, T9600, [OnLcd, ClsLcd] ' Inizializza LCD


PAUSE 5 ' ritardo di 5 ms per cancellare il ' display CarPers = 2 ' Sceglie Carattere Personalizzato 2 riga = Riga0 ' Grafico a barre su Riga 0. ' -----[ Routine principale ]------------------------------------------------- DO ' Ciclo principale FOR carBase = Car0 TO Car14 STEP 8 ' Attraversa i 10 caratteri personal. GOSUB Def_Car_Pers ' Definisce il carattere cursore = 7 ' Posiziona il cursore GOSUB Vis_Car_Pers ' Visualizza carattere PAUSE 200 '- carBase ' maggiore carBase – minore pausa NEXT ' Ripete la FOR carBase... PAUSE 1000 ' Pausa di 1 secondo LOOP ' Ripete ciclo principale ' -----[ 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 carattere personalizz. [Definisce + CarPers] FOR indice = 0 TO 7 ' 7 byte, definisce 7 righe di punti READ carBase + indice, RigaPunt ' Ottiene il byte per riga di punti SEROUT PinLcd, T9600, [RigaPunt] ' Lo invia al LCD NEXT 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: SEROUT PinLcd, T9600, ' Visualizza carattere personalizzato [riga + cursora, Car_Pers] RETURN


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: SEROUT PinLcd, T9600, ' Definisce Carattere Personalizzato 2 [Definisce + CarPers] FOR indice = 0 TO 7 ' 7 byte, definisce 7 righe di punti 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: SEROUT PinLcd, T9600, [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

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.

Finestrella

di trasmissione

Finestrella di ricezione

Grafico a barre visualizzato

dal LCD

Digitate valori (da 0 a 80) >1 >2 >29 >30 >31


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.

Figura 7-2 Libreria delle definizioni per il Carattere Personalizzato 2

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 ' Dispositivo di destinazione = BASIC Stamp 2 ' $PBASIC 2.5 ' Linguaggio = PBASIC 2.5

Caratteri Personalizzati

Car0 Car1 Car2 Car3 Car4


' -----[ Pin I/O ]----------------------------------------------------------- PinLcd PIN 14 ' pin I/O connesso a RX del LCD ' -----[ Costanti ]---------------------------------------------------------- T9600 CON 84 ' Vero, 8-bit, senza parità, 9600 ClsLcd CON 12 ' Pagina nuova -> cancella schermo CrLcd CON 13 ' Ritorno Carrello OffLcd CON 21 ' Spegne (off) il display OnLcd CON 22 ' Accende (on) il display Riga0 CON 128 ' Riga 0, carattere 0 Riga1 CON 148 ' Riga 1, carattere 0 Definisce CON 248 ' Indirizzo che definisce car pers 0 ' -----[ Variabili ]---------------------------------------------------------- CarPers VAR Nib ' Selettore caattere personalizzato indice VAR Nib ' Variabile indice Eeprom RigaPunt VAR Byte ' linea puntinata a 5-pixel cursore VAR Nib ' Posizionamento Cursore valore VAR Byte ' Valore da riportare in grafico. CntCar VAR Byte ' Variabile conta Carattere riga VAR Byte ' Riga0 o Riga1 ' -----[ Inizializzazione ]--------------------------------------------------- PAUSE 100 ' 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 ' -----[ Routine principale ]------------------------------------------------- DO ' Ciclo principale DEBUG ">" DEBUGIN DEC valore ' Valore dalla finestrella di Trasmiss GOSUB Grafico_a_barre ' Visualizza come grafico a barre LOOP ' Ripete ciclo principale ' -----[ Subroutine – Grafico_a_barre ]---------------------------------------


Grafico_a_barre: ' Riempie da sinistra con barre nere valore = valore MAX 80 ' valore limite – da 0 a 80 CntCar = valore / 5 ' Numero di barre nere CarPers = 3 ' Sceglie carettere person. nero IF CntCar > 0 THEN ' Se da vis. barre nere, allora FOR cursore = 0 TO CntCar - 1 ' Visual. CntCar - 1 barre nere GOSUB Vis_Car_Pers ' Visualizza barra nera NEXT ENDIF ' 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 ' Definisce carattere personalizz. 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 " " SEROUT PinLcd, T9600, [riga + cursore, " "] NEXT ELSEIF valore = 80 THEN ' Caso particolare: valore = 80 SEROUT PinLcd, T9600, [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: SEROUT PinLcd, T9600, ' Definisce carattere personalizzato [Definisce + CarPers] FOR indice = 0 TO 7 ' 7 byte, definisce 7 righe di punti SEROUT PinLcd, T9600, [RigaPunt] ' Le invia al LCD NEXT


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: SEROUT PinLcd, T9600, ' Visualizza carattere personalizzato [riga + cursore, CarPers] RETURN

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 ' Sceglie Carattere Personalizzato 3 RigaPunt = %11111 ' Annerisce tutti i pixel in ogni riga GOSUB Def_Car_Bar_Orizz ' 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.

' -----[ Routine principale ]------------------------------------------ DO ' Ciclo principale DEBUG ">" DEBUGIN DEC valore ' Valore dalla finestrella di Trasmissione


GOSUB Grafico_a_barre ' Visualizza come grafico a barre LOOP ' Ripete ciclo principale

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 ' Valore Limite – da 0 a 80 CntCar = valore / 5 ' Numero di barre nere CarPers = 3 ' 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 ricerca (lookup) memorizza %11100 nella variabile RigaPunt. La subroutine 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 ' Definisce carattere personalizz. 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: SEROUT PinLcd, T9600, ' Definisce carattere personalizzato [Definisce + CarPers] FOR indice = 0 TO 7 ' 7 byte, definisce 7 righe di punti 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 " " SEROUT PinLcd, T9600, [Riga0 + cursore, " "] NEXT ELSEIF valore = 80 THEN ' Caso particolare: valore = 80 SEROUT PinLcd, T9600, [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 DistanzaCm = CostanteCm ** tempo DEBUG HOME, DEC3 DistanzaCm, " cm" valore = DistanzaCm GOSUB Grafico_a_barre ' Visualizza come grafico a barre PAUSE 100 LOOP ' Ripete ciclo principale

√ 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: SEROUT PinLcd, T9600, [Definisce + CarPers] MapRiga = %1111111100000000 >> (valore & %1111) FOR indice = 0 TO 7 IF MapRiga.LOWBIT(indice) = 1 THEN SEROUT PinLcd, T9600, [%11111] ELSE SEROUT PinLcd, T9600, [%00000] 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 ' Dispositivo di arrivo = BASIC Stamp 2 ' $PBASIC 2.5 ' Linguaggio = PBASIC 2.5 ' -----[ Pin I/O ]----------------------------------------------------------- PinLcd PIN 14 ' pin I/O connesso ad RX del LCD ' -----[ Costanti ]---------------------------------------------------------- T9600 CON 84 ' Vero, 8-bit, senza parità, 9600 ClsLcd CON 12 ' Nuova pagina -> cancella schermo


LcdOn CON 22 ' Accende (on) il display Riga0 CON 128 ' Riga 0, carattere 0 Riga1 CON 148 ' Riga 1, carattere 0 Definisce CON 248 ' Indirizzo che definisce car pers 0 ' -----[ Variabili ]---------------------------------------------------------- CarPers VAR Byte ' selettore del carattere personal. indice VAR Nib ' variabili indice della Eeprom MapRiga VAR Byte ' riga di punti di 5-pixel cursore VAR Byte ' posizionamento cursore valore VAR Byte ' Valore da riporare in grafico riga VAR Byte ' Riga0 o Riga1 ' -----[ Inizializzazione ]--------------------------------------------------- ' inizializzazione del LCD. PAUSE 100 ' Disabilita alimentazione elettr. SEROUT PinLcd, T9600, [LcdOn, ClsLcd] ' Inizializza il LCD PAUSE 5 ' ritardo di 5 ms per cancellare il display ' subroutine valori carattere personalizzato. CarPers = 3 ' Usa il carattere personal. 3 riga = Riga0 ' Cursore in Riga0 cursore = 7 ' Cursore all’8.vo carattere ' -----[ Routine principale]-------------------------------------------------- DO ' Ciclo principale FOR valore = 0 TO 16 ' valore conta da 0 a 16 DEBUG ? valore ' Visualizza valore in terminale Debug GOSUB Def_Car_Bar_Vert ' Definisce carattere grafico barra GOSUB Vis_Car_Pers ' Visualizza carattere su LCD PAUSE 50 ' Rallenta il ciclo NEXT DEBUG CR, CR ' Spazi prima di sequenza successiva PAUSE 500 ' Ritardo prima di sequenza successiva LOOP ' Ripete ciclo principale ' -----[ 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 SEROUT PinLcd, T9600,


[Definisce + CarPers] ' 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 IF MapRiga.LOWBIT(indice) = 1 THEN ' Esamina bit seguente in MapRiga SEROUT PinLcd, T9600, [%11111] ' Se 1, invia %11111 ELSE SEROUT PinLcd, T9600, [%00000] ' Altrimenti, invia %00000 ENDIF NEXT ' Ritorno dalla subroutine. RETURN ' -----[ Subroutine - Vis_Car_Pers ]--------------------------------------- ' Questa subroutine visualizza un carattere personalizzato. La variabile riga ' 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 carat- ' teri personalizzati del LCD e dovreà essere posta ad un valore tra 0 e 7. Vis_Car_Pers: SEROUT PinLcd, T9600, ' Scrive carattere personalizzato [riga + cursore, CarPers] RETURN

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 FOR valore = 1 TO 31 SEROUT 14, 84, [Riga0 + cursore, " ", Riga1 + cursore, " "] IF valore <= 16 THEN riga = Riga1 ELSE riga = Riga0 ENDIF DEBUG ? valore GOSUB Def_Car_Bar_Vert 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.

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

Orizzontle Verticale


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 FOR valore = 1 TO 31 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 ' Dispositivo scelto = BASIC Stamp 2 ' $PBASIC 2.5 ' Linguaggio = PBASIC 2.5 ' -----[ Pin I/O ]----------------------------------------------------------- PinLcd PIN 14 ' pin I/O connesso ad RX del LCD ' -----[ Costanti ]---------------------------------------------------------- T9600 CON 84 ' Vero, 8-bit, senza parità, 9600 ClsLcd CON 12 ' Nuova pagina -> cancella schermo CrLcd CON 13 ' Ritorno carrello (a capo) LcdOff CON 21 ' Spegne (off) display LcdOn CON 22 ' Accende (on) display Riga0 CON 128 ' Riga 0, carattere 0 Riga1 CON 148 ' Riga 1, carattere 0 Definisce CON 248 ' Indirizzo di defin. car. pers. 0 ' -----[ Variabili ]---------------------------------------------------------- CarPers VAR Byte ' Selettore carattere personalizzato indice VAR Nib ' variabile indice Eeprom MapRiga VAR Byte ' riga puntinata a 5-pixel cursore VAR Byte ' posizionamento cursore valore VAR Byte ' Valore da riportare in grafico riga VAR Byte ' Riga0 o Riga1 ' -----[ Inizializzazione ]--------------------------------------------------- PAUSE 100 ' Scollega alimentazione elettr. SEROUT PinLcd, T9600, [LcdOn, ClsLcd] ' Inizializza LCD PAUSE 5 ' ritardo 5 ms per cancellaz. display ' -----[ Routine principale]-------------------------------------------------- DO ' Ciclo principale DEBUG "Digita valore oriz-", ' Richiesta offset carattere CR, "zontale (0 a 16)" DEBUGIN DEC cursore ' Ottiene offset carattere DEBUG "Digita valore ver-", CR, "ticale (1 a 31)" ' Chiede valore a utente DEBUGIN DEC valore ' Ottiene valore GOSUB Graf_Barre_O_V ' Richiama Graf_Barre_O_V


LOOP ' Ripete ciclo principale ' -----[ 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: SEROUT 14, 84, [ClsLcd] ' Cancella precedente grafico PAUSE 5 ' 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 Def_Car_Bar_Vert ' Definisce carattere personalizzato GOSUB Posizionamento_Orizzontale IF valore = 16 THEN ' caso particolare: valore = 16 valore = 1 ' display su Riga 0 CarPers = 2 GOSUB Def_Car_Bar_Vert riga = Rigae0 GOSUB Posizionamento_Orizzontale valore = 15 ' Display su Riga 1 CarPers = 3 GOSUB Def_Car_Bar_Vert riga = Riga1 GOSUB Posizionamento_Orizzontale valore = 16 ' 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: ' Inizia a definire il carattere personalizzato SEROUT PinLcd, T9600, [Definisce + CarPers] ' 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 ' Ripete 7 volte, indice conta IF MapRiga.LOWBIT(indice) = 1 THEN ' Esamina success. bit in MapRiga SEROUT 14, 84, [%11111] ' If 1, invia %11111 ELSE SEROUT 14, 84, [%00000] ' Altrimenti, invia %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 ' Cursore da 0 a 7, nessun cambio CASE 0 TO 7 GOSUB Vis_Car_Pers CASE 8 ' Cursore 8, visualizza a 7 & 8 cursore = 7 GOSUB Vis_Car_Pers cursore = 8 GOSUB Vis_Car_Pers CASE 9 TO 16 ' Cursore da 9 a 16, visual. 1 a sin. cursore = cursore - 1 GOSUB Vis_Car_Pers cursore = cursore + 1 ENDSELECT 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 ca- ' ratteri personalizzai del LCD e deve essere posta a un valore tra 0 e 7. Vis_Car_Pers: SEROUT PinLcd, T9600, ' Scrive carattere personalizzato [riga + cursore, CarPers] 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

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

Asse x

Asse y


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 VAR Word ' asse x dell’Accelerometro y VAR Word ' 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) GOSUB Graf_Barre_O_V ' Richiama Graf_Barre_O_V LOOP ' Ripete ciclo principale

√ 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].


E1. Soluzione esempio: 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.

' -----[ Routine principale ]------------------------------------------ DO ' Ciclo principale PULSOUT 15, 5 PULSIN 15, 1, tempo DistanzaCm = CostanteCm ** tempo DEBUG HOME, DEC3 DistanzaCm, " cm" valore = DistanzaCm GOSUB Graf_Barre ' Visualizza come grafico a barre SEROUT 14, 84, [Riga1, DEC4 valore, ' Visualizza misura in cm " cm"] ' sulla Riga 1 PAUSE 100 LOOP ' Ripete ciclo principale


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’as- ' se 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 ' Disppositivo scelto = BASIC Stamp 2 ' $PBASIC 2.5 ' Linguaggio = PBASIC 2.5 ' -----[ Pin I/O ]----------------------------------------------------------- PinLcd PIN 14 ' pin I/O connesso ad RX del LCD ' -----[ Costanti ]---------------------------------------------------------- T9600 CON 84 ' Vero, 8-bit, senza parità, 9600 ClsLcd CON 12 ' Nuova pagina -> cancella schermo CrLcd CON 13 ' Ritorno carrello (a capo) LcdOff CON 21 ' Spegne (off) il display LcdOn CON 22 ' Accende (on) il display Riga0 CON 128 ' Riga 0, carattere 0 Riga1 CON 148 ' Riga 1, carattere 0 Definisce CON 248 ' Indirizzo che definisce car pers. 0 Negativo CON 1 ' Segno - .bit15 delle variabili Word Positivo CON 0 ' -----[ Variabili ]---------------------------------------------------------- CarPers VAR Byte ' Selettore carattere personalizzato indice VAR Nib ' variabile indice Eeprom MapRiga VAR Byte ' riga di punti di 5-pixel cursore VAR Byte ' Posizionamento cursore valore VAR Byte ' Valore da riportare in grafico riga VAR Byte ' Riga0 o Riga1 x VAR Word y VAR Word seno VAR Word ' seno in un cerchio con r = 127 lato VAR Word ' variabile della subroutine trig angolo VAR Word ' angolo risultante - gradi segno VAR Bit ' bit del segno


' -----[ Inizializzazione ]--------------------------------------------------- PAUSE 100 ' Disattiva alimentazione elettrica SEROUT PinLcd, T9600, [LcdOn, ClsLcd] ' Inizializza LCD PAUSE 5 ' ritardo di 5 ms per cancellare il display ' -----[ Routine principale ]------------------------------------------------- DO ' 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) GOSUB Graf_Barre_O_V ' Eichiama Graf_Barre_O_V LOOP ' Ripete ciclo principale ' -----[ 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 sub- ' routine Def_Car_Barre_Vert, e Posizionamento_Orizzontale. Graf_Barre_O_V: SEROUT 14, 84, [ClsLcd] ' Cancella grafico precedente PAUSE 5 ' ritardo di 5 ms per cancellare il display ' Decide se visualizzare su Riga 0 o Riga 1. IF valore >= 16 THEN riga = Riga0 ELSE riga = Riga1 GOSUB Def_Car_Barra_Vert ' Definisce carattere personalizzato GOSUB Posizionamento_Orizzontale IF valore = 16 THEN ' Caso particolare: valore = 16


valore = 1 ' Display Riga 0 CarPers = 2 GOSUB Def_Car_Barra_Vert riga = Riga0 GOSUB Posizionamento_Orizzontale valore = 15 ' Display Riga 1 CarPers = 3 GOSUB Def_Car_Barra_Vert riga = Riga1 GOSUB Posizionamento_Orizzontale 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: ' Inizia a definire il carattere personalizzato SEROUT PinLcd, T9600, [Definisce + CarPers] ' 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 ' Ripete 7 volte, indice conta 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] ' Altrimenti, invia %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 ' Cursore da 0 a 7, nessun cambiamento CASE 0 TO 7 GOSUB Vis_Car_Pers CASE 8 ' Cursore a 8, visualizza a 7 & 8 cursore = 7 GOSUB Vis_Car_Pers cursore = 8 GOSUB Vis_Car_Pers CASE 9 TO 16 ' Cursore da 9 a 16, visualizza 1 a sinistra cursore = cursore - 1 GOSUB Vis_Car_Pers cursore = cursore + 1 ENDSELECT 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 ca- ' ratteri personalizzati del LCD e deve essere posta a un valore tra 0 e 7. Vis_Car_Pers: SEROUT PinLcd, T9600, ' Scrive carattere personalizzato [riga + cursore, CarPers] 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: ' subroutine inversa del seno GOSUB Arcocoseno ' Ottiene inversa del coseno angolo = 90 - angolo ' sin(angolo) = cos(90 - angolo) RETURN ' -----[ 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 angolo = 63 - (lato / 2) ' Approssimazione iniziale angolo DO ' Ciclo approssimazioni successive IF (COS angolo <= lato) THEN EXIT ' Fine quando COS angolo <= lato angolo = angolo + 1 ' Incrementa l’angolo LOOP angolo = angolo */ 361 ' Converte brad in gradi 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 Hex Car Nome / Funzione Dec Hex Car Dec Hex Car Dec Hex Car

0 00 NUL Null 32 20 space 64 40 @ 96 60 ` 1 01 SOH Start Of Heading 33 21 ! 65 41 A 97 61 a 2 02 STX Start Of Text 34 22 " 66 42 B 98 62 b 3 03 ETX End Of Text 35 23 # 67 43 C 99 63 c 4 04 EOT End Of Transmit 36 24 $ 68 44 D 100 64 d 5 05 ENQ Enquiry 37 25 % 69 45 E 101 65 e 6 06 ACK Acknowledge 38 26 & 70 46 F 102 66 f 7 07 BEL Bell 39 27 ' 71 47 G 103 67 g 8 08 BS Backspace 40 28 ( 72 48 H 104 68 h 9 09 HT Horizontal Tab 41 29 ) 73 49 I 105 69 i 10 0A LF Line Feed 42 2A * 74 4A J 106 6A j 11 0B VT Vertical Tab 43 2B + 75 4B K 107 6B k 12 0C FF Form Feed 44 2C , 76 4C L 108 6C l 13 0D CR Carriage Return 45 2D - 77 4D M 109 6D m 14 0E SO Shift Out 46 2E . 78 4E N 110 6E n 15 0F SI Shift In 47 2F / 79 4F O 111 6F o 16 10 DLE Data Line Escape 48 30 0 80 50 P 112 70 p 17 11 DC1 Device Control 1 49 31 1 81 51 Q 113 71 q 18 12 DC2 Device Control 2 50 32 2 82 52 R 114 72 r 19 13 DC3 Device Control 3 51 33 3 83 53 S 115 73 s 20 14 DC4 Device Control 4 52 34 4 84 54 T 116 74 t 21 15 NAK Non Acknowledge 53 35 5 85 55 U 117 75 u 22 16 SYN Synchronous Idle 54 36 6 86 56 V 118 76 v 23 17 ETB End Transmit Block 55 37 7 87 57 W 119 77 w 24 18 CAN Cancel 56 38 8 88 58 X 120 78 x 25 19 EM End Of Medium 57 39 9 89 59 Y 121 79 y 26 1A SUB Substitute 58 3A : 90 5A Z 122 7A z 27 1B ESC Escape 59 3B ; 91 5B [ 123 7B 28 1C FS File Separator 60 3C < 92 5C \ 124 7C | 29 1D GS Group Separator 61 3D = 93 5D ] 125 7D 30 1E RS Record Separator 62 3E > 94 5E ^ 126 7E ~ 31 1F US Unit Separator 63 3F ? 95 5F _ 127 7F 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 (Boe-

Bot®, 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 http://www.parallax.com/detail.asp?product_id=27977 http://www.parallax.com/detail.asp?product_id=27979

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.

Figura B-2 Connessioni di LCD seriale per la Rev E e i display successivi.

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 Voltaggio Corrente Tutti i modelli e retroilluminazione off 5 VDC 20 mA 27977/27979 e retroilluminazione on 5 VDC 80 mA

LCD Parallax

LCD Parallax


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 Descrizione Tipo di display LCD STN, YG, positivo, trasparente alla riflessione Direzione di osservazione 6H Retroilluminazione LED YG Temperatura di funzionamento -4°F~158°F (-20°C~70°C) Temperatura di conservazione -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 SW1 SW2 Test (Prova) OFF OFF 2,400 ON OFF 9,600 OFF ON 19.200 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 CON 0 Baud19200 CON 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 CON 0 Baud19200 CON 32 HIGH PinTx ' Imposta il pin alto per essere porta seriale PAUSE 100 ' Pausa per inizializzare LCD seriale SEROUT PinTx, Baud19200, [250] ' Definisce Carattere personalizzato 2 ' Ora invia gli otto byte dati SEROUT PinTx, Baud19200, [0] ' 0 = %00000 SEROUT PinTx, Baud19200, [4] ' 4 = %00100 * SEROUT PinTx, Baud19200, [14] ' 14 = %01110 * * * SEROUT PinTx, Baud19200, [31] ' 31 = %11111 * * * * * SEROUT PinTx, Baud19200, [14] ' 14 = %01110 * * * SEROUT PinTx, Baud19200, [4] ' 4 = %00100 * SEROUT PinTx, Baud19200, [0] ' 0 = %00000 SEROUT PinTx, Baud19200, [0] ' 0 = %00000 SEROUT PinTx, Baud19200, [2] ' 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 00 Visualizza carattere personalizzato 0








8 08 Backspace / Left (sinistra) – Il cursore è mosso a sinistra di una posizione. Il comando non cancella il carattere.

9 09 Right (destra) - Il cursore è mosso a destra di una posizione. Il comando non cancella il carattere.

10 0A 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.

11 0B N/A (Not Avalilable = Non Disponibile)

12 0C 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.

13 0D 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.

14 - 16 0E - 10 N/A

17 11 Accende (on) retroilluminazione (solo sui modelli 27977, 27979)

18 12 Spegne (off) retroilluminazione (Default – opzione implicita)

19 - 20 13 - 14 N/A

21 15 Spegne (off) il display

22 16 Accende (on) il display, con cursore spento e nessun lampeggio

23 17 Accende (on) il display, con cursore spento e lampeggio del carattere

24 18 Accende (on) il display, con cursore acceso e senza lampeggio (Default – implicita)

25 19 Accende (on) il display, con cursore acceso e lampeggio del carattere

26 - 31 1A - 1F N/A

32 - 127 20 - 7F Visualizza caratteri ASCII. Si veda la tabella dell’insieme dei caratteri ASCII.

128 80 Muove il cursore alla riga 0, posizione 0








Dec Hex Azione 135 87 Muove il cursore alla riga 0, posizione 7 136 88 Muove il cursore alla riga 0, posizione 8 137 89 Muove il cursore alla riga 0, posizione 9 138 8A Muove il cursore alla riga 0, posizione 10 139 8B Muove il cursore alla riga 0, posizione 11 140 8C Muove il cursore alla riga 0, posizione 12 141 8D Muove il cursore alla riga 0, posizione 13 142 8E Muove il cursore alla riga 0, posizione 14 143 8F Muove il cursore alla riga 0, posizione 15 144 90 Muove il cursore alla riga 0, posizione 16 (solo sul modello 27979) 145 91 Muove il cursore alla riga 0, posizione 17 (solo sul modello 27979) 146 92 Muove il cursore alla riga 0, posizione 18 (solo sul modello 27979) 147 93 Muove il cursore alla riga 0, posizione 19 (solo sul modello 27979) 148 94 Muove il cursore alla riga 1, posizione 0 149 95 Muove il cursore alla riga 1, posizione 1 150 96 Muove il cursore alla riga 1, posizione 2 151 97 Muove il cursore alla riga 1, posizione 3 152 98 Muove il cursore alla riga 1, posizione 4 153 99 Muove il cursore alla riga 1, posizione 5 154 9A Muove il cursore alla riga 1, posizione 6 155 9B Muove il cursore alla riga 1, posizione 7 156 9C Muove il cursore alla riga 1, posizione 8 157 9D Muove il cursore alla riga 1, posizione 9 158 9E Muove il cursore alla riga 1, posizione 10 159 9F Muove il cursore alla riga 1, posizione 11 160 A0 Muove il cursore alla riga 1, posizione 12 161 A1 Muove il cursore alla riga 1, posizione 13 162 A2 Muove il cursore alla riga 1, posizione 14 163 A3 Muove il cursore alla riga 1, posizione 15 164 A4 Muove il cursore alla riga 1, posizione 16 (solo sul modello 27979) 165 A5 Muove il cursore alla riga 1, posizione 17 (solo sul modello 27979) 166 A6 Muove il cursore alla riga 1, posizione 18 (solo sul modello 27979) 167 A7 Muove il cursore alla riga 1, posizione 19 (solo sul modello 27979) 168 A8 Muove il cursore alla riga 2, posizione 0 (solo sul modello 27979) 169 A9 Muove il cursore alla riga 2, posizione 1 (solo sul modello 27979) 170 AA Muove il cursore alla riga 2, posizione 2 (solo sul modello 27979) 171 AB Muove il cursore alla riga 2, posizione 3 (solo sul modello 27979) 172 AC Muove il cursore alla riga 2, posizione 4 (solo sul modello 27979) 173 AD Muove il cursore alla riga 2, posizione 5 (solo sul modello 27979) 174 AE Muove il cursore alla riga 2, posizione 6 (solo sul modello 27979) 175 AF Muove il cursore alla riga 2, posizione 7 (solo sul modello 27979) 176 B0 Muove il cursore alla riga 2, posizione 8 (solo sul modello 27979) 177 B1 Muove il cursore alla riga 2, posizione 9 (solo sul modello 27979) 178 B2 Muove il cursore alla riga 2, posizione 10 (solo sul modello 27979) 179 B3 Muove il cursore alla riga 2, posizione 11 (solo sul modello 27979) 180 B4 Muove il cursore alla riga 2, posizione 12 (solo sul modello 27979)


Dec Hex Azione

181 B5 Muove il cursore alla riga 2, posizione 13 (solo sul modello 27979)





186 BA Muove il cursore alla riga 2, posizione 18 (solo sul modello 27979)

187 BB Muove il cursore alla riga 2, posizione 19 (solo sul modello 27979)

188 BC Muove il cursore alla riga 3, posizione 0 (solo sul modello 27979)

189 BD Muove il cursore alla riga 3, posizione 1 (solo sul modello 27979)

190 BE Muove il cursore alla riga 3, posizione 2 (solo sul modello 27979)

191 BF Muove il cursore alla riga 3, posizione 3 (solo sul modello 27979)

192 C0 Muove il cursore alla riga 3, posizione 4 (solo sul modello 27979)










202 CA Muove il cursore alla riga 3, posizione 14 (solo sul modello 27979)

203 CB Muove il cursore alla riga 3, posizione 15 (solo sul modello 27979)

204 CC Muove il cursore alla riga 3, posizione 16 (solo sul modello 27979)

205 CD Muove il cursore alla riga 3, posizione 17 (solo sul modello 27979)

206 CE Muove il cursore alla riga 3, posizione 18 (solo sul modello 27979)

207 CF Muove il cursore alla riga 3, posizione 19 (solo sul modello 27979)

208 - 247 D0 – F7 N/A

248 F8 Definisce Carattere Pers. 0. Il comando dev’essere seguito da otto byte dati.

249 F9 Definisce Carattere Pers. 1. Il comando dev’essere seguito da otto byte dati.

250 FA Definisce Carattere Pers. 2. Il comando dev’essere seguito da otto byte dati.

251 FB Definisce Carattere Pers. 3. Il comando dev’essere seguito da otto byte dati.

252 FC Definisce Carattere Pers. 4. Il comando dev’essere seguito da otto byte dati.

253 FD Definisce Carattere Pers. 5. Il comando dev’essere seguito da otto byte dati.

254 FE Definisce Carattere Pers. 6. Il comando dev’essere seguito da otto byte dati.

255 FF Definisce Carattere Pers. 7. 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 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Base 16

0 1 2 3 4 5 6 7 8 9 A B C D E F

Base 2

0000

0001

0010

0011

0100

0101

0110

0111

1000

1001

1010

1011

1100

1101

1110

1111

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 8 F E 6 Binario 1000 1111 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 1100 0110 0000 1001 Esadecimale C 6 0 9 %1100011000001001 = $C609

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 ' Distacca alimentazione SEROUT 14, 84, [22, 12] ' Accende display e lo cancella PAUSE 5 ' 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 #800-00030.

• 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

statica, 71

studio automobile RC, 248

studio trucco di uno skateboard , 259

su percorso circolare, 251

accelerometro

a tre assi, 70

e grafico a bolle su LCD dell'inclinazione 202

misure di altezza con l'-, 229

progetto MX2125 (figura), 71

schema e diagramma cablaggio, 72

usi, 69

animazione

testo lampeggiante, 12

caratteri personalizzati clessidra, 26

caratteri personal. verme di pixel, 289

testo scorrevole, 27

finestra scorrevole, 28

arcocoseno, 109 arcoseno, 109 arcotangente, 91, 94 ASCII, tavola codice, 329 ATN, 91, 128

- B -

banda morta, 269 barre, grafico a

a due assi, 306

orizzontale, 298

verticale, 308

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

assi di sensibilità della-, 128

interpretazione delle misure di -, 127

- meccanica, 136

precauzioni con i magneti, 133

prova della -, 128

schema e diagramma di cabl., 129

taratura della -, 136

- C -

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

inclinare grafico a bolle accelerometro su -, 202

finestra scorrevole, 28

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

misura altezza con accelerometro, 229 momento, 260

- N -

negativi, numeri- in PBASIC, 85, 187

e operatore MIN, 209

divisione, 154

numeri negativi in PBASIC, 85, 187

- O -

offset dei valori di ingresso, 80 - 81 ollie, 260 orizzontale, grafico a barre, 298 oscillazioni, 262

osservazione delle coordinate di un carattere, 196

- 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

CmEPolPingLcd.bs2, 61

ConverteBinarioEsadecimale.bs2, 347

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

ProvaPing.bs2, 46

RegDatiDiAccelerazione.bs2, 244

RegDatiAsseYNonScalato.bs2, 264

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


Documents

Sensori Intelligenti e loro Applicazioni · della Parallax, Inc. HomeWork Board, Propeller, Ping))) Parallax, e il logo Parallax sono marchi di fabbrica della Parallax, Inc. Se decidete