Archivi categoria: i miei allievi

Siemens SIMATIC IOT2040 – configurazione ed utilizzo con l’IDE Arduino

L’obiettivo di questa lezione introduttiva sull’uso di IOT2040 è quello di aiutare un gruppo di miei studenti nelle sperimentazioni che in questi giorni si stanno svolgendo nell’ambito delle attività di PCTO. Seguiranno nelle prossime settimane ulteriori guide che andranno ad ampliare il curricolo del percorso di Automazione per le classi 4′ e 5′ che svolgo presso l’ITIS Pininfarina di Moncalieri.

La semplicità di utilizzo, unita all’affidabilità e alla storia in campo industriale di Siemens, rendono la serie SIMATIC IOT2000 la scelta perfetta come gateway industriale. La possibilità di programmare SIMATIC IOT2000 con l’IDE Arduino permette un facile inserimento all’interno del percorso di studi, infatti il gateway è la normale evoluzione in campo industriale di Arduino, da esso ne eredita la possibilità di utilizzare i medesimi shield che vengono usati per la scheda Arduino UNO R3. Con IOT2000 è possibile usare protocolli di comunicazione come MQTT e Modbus.

Il funzionamento del gateway di Siemens è basato su Yocto Linux. La serie SIMATIC IOT2000 comprende i modelli IOT2000, IoOT2020 e IOT2040 compatibili con la maggior parte degli sketch Arduino che possono essere caricati direttamente dall’IDE Arduino.

Nella scheda che segue vengono evidenziate le differenze tra i vari dispositivi. L’IOT2040 è ideale per un impiego in azienda, mentre l’IOT2020 può essere utilizzato in campo didattico. Per il mio istituto ho scelto di utilizzare la serie di IOT2040 in modo che gli studenti fossero già formati su un prodotto che avesse performance adatte ad un uso aziendale.

Caratteristiche principali IOT 2040

SIMATIC quality
Realizzato per operare 24/7 In ambiente industriale
AutomatIon.ConnecTed
Connessione facile all’automazione con supporto PROFINET, interfacce standard e apertura a soluzioni basate su Cloud
Aperto
Programmabile con linguaggi ad alto livello (es. Java, C++) tramite diversi IDE (es. Eclipse) e compilatori per Yocto Linux
Performance
Processore 32bit deterministico Intel Quark®x1020, 1 GB RAM e real-time-clock con batteria di buffer
Espandibilità & Connettività
Compatibile con mPCIe, Arduino Shields e varie interfacce, protocolli e driver standard

Famiglia SIMATIC IOT2000 – Scheda tecnica

SIMATIC IOT2020

Target: Per Università e istituti scolastici
Hardware:
- Intel Quark® x1000 (Galileo)
- 512 MB RAM
- 1 Ethernet interface
Espandibilità
Arduino shield / mPCIe / µSD card slot
Software
Profinet driver
Programmazione
Yocto Linux/programmazione con linguaggi ad alto livello
Supporto Tecnico
Sito internet, forum dedicato

SIMATIC IOT2040

Target: Variante “Industrial IoT” – Gateway / Collettore dati in applicazioni industriali
Hardware:
- Intel Quark® x1020 (+secure boot)
- 1 GB RAM
- 2 Ethernet interfaces
- 2 x RS232/485 interfaces
- battery buffered RTC
Espandibilità
Arduino shield / mPCIe / µSD card slot
Software
Profinet driver
Programmazione
Yocto Linux/programmazione con linguaggi ad alto livello
Supporto Tecnico
Sito internet, forum dedicato

Ambienti di sviluppo e programmazione

Eclipse – programmazione in C/C++, Java
Arduino IDE – programmazione in C
Python
Node-RED

Interfacce

1 – Cover sinistra (Arduino interface)
2 – LED
3 – Cover destra (µSD card, battery)
4 – Chiusura di sicurezza
5 – Pulsante user programmabile
6 – Pulsante RESET

7 – Porte COM (RS232/422/485)
8 – Preforati per installazione antenne
9 – Fori per alette a pressione per montaggio a muro
10 – Alimentazione

11 – USB Type A
12 – USB Type Micro B
13 – Porta Ethernet 10/100 Mbps
14 – Porta Ethernet 10/100 Mbps PoE

15 – Fissaggio a guida DIN

Nella parte interna sono ben evidenti, partendo da sinistra, i pin a cui è possibile connettere gli shield Arduino, a destra invece l’alloggiamento per la micro SD e batteria per l’RTC.

Configurazione di SIMATIC IOT2040

Per lo svolgimento di questa esercitazione è indispensabile avere:

Cavo ethernet
SD Card da almeno 8GB
Alimentazione a 24 Vcc
Arduino IDE
Siemens SIMATIC IOT 2040

Manuali di riferimento

Impostazione

Prima di procedere è indispensabile prelevare il software e la documentazione necessario dal portale di supporto di Siemens, registratevi e accedete al portale di supporto Siemens per poter poi prelevare tutto ciò che serve per configurare il dispositivo.
Il punto di riferimento da cui partire è il forum dedicato su cui troverete tutto ciò che vi serve e da cui potrete ottenere il supporto di Siemens per qualsiasi richiesta relativa all’hardware. Tutti i modelli della serie serie IOT2000 si configura allo stesso modo quindi, quindi questo tutorial risulta valido per: IOT2000, IOT2020 e IOT2040.

Per procedere alla creazione dell’SD di boot da inserire all’interno dell’IOT 20×0 fate riferimento alla seguente pagina web sul sito di Siemens: Immagine di esempio scheda SD SIMATIC IOT2000
Eseguire il download di: Example_Image_V2.4.0.zip (365,0 MB)
Inserire la micro SD all’interno del vostro computer, oppure utilizzate un’adattatore esterno.
Scompattate il file che avete scaricato e copiatelo sull’SD. Per la copia su SD per gli utenti Windows rimando alla pagina 9 del manuale allegato: SETTING UP the SIMATIC IOT2020, SIMATIC IOT2040 in cui viene utilizzato Win32 Disk Imager.
In alternativa per gli utenti MacOSX, Window e Linux consiglio l’utilizzo balenaEtcher applicazione estremamente utile e semplice da utilizzare.

Avviare balenaEtcher e selezionare il file compattato sul vostro HD:

Selezionare l’unità su cui compare l’immagine:

Selezionare la periferica:

Avviare la copia facendo click su “Flash!”:

Verrà richiesto l’inserimento della password di amministratore per effettuare cambiamenti sul disco di destinazione:

L’operazione di copia può durare parecchi minuti:

Inserire ma micro SD all’interno del dispositivo

Aprire la cover destra (µSD card, battery)

Spostare verso il basso il blocco SD

Aprire il blocco

Inserire la micro SD

Chiudere il blocco e spostare verso l’alto

Primo avvio del Simatic IOT 2040

I passi che seguono mostrano come accedere al SIMATIC IOT2040 mediante l’IP statico per configurare la rete. E’ importante ricordare che SIMATIC IOT 2040 ha come impostazione predefinita l’indirizzo DHCP sulla porta porta Ethernet – X2P1 e se lo si desidera è possibile accedere direttamente utilizzando l’indirizzo IP assegnato.

Con IOT2040 spento collegare un’estremità del cavo Ethernet al computer e l’altra alla porta Ethernet-X1P1 del dispositivo SIMATIC IOT2000, se state usando un IOT2040 la porta X1P1 è quella che si trova sulla sinistra.

Attenzione: Usare una tensione di alimentazione continua dai 9 ai 36V massimi

Una volta acceso SIMATIC IOT2000, vedrete il seguente comporatamento dei LED:

PWR: fisso; dispositivo acceso
SD: intermittente successivamente si spegnerà
USB: fisso; dispositivo acceso

Il LED SD sarà intermittente perché viene modificata la dimensione del filesystem, questa fase potrebbe durare qualche minuto (dipende da che tipo di SD state utilizzando) attendere fino a quando non cambia lo stato del LED da fisso a spento, a questo punto potrete accedere all’IOT.

SIMATIC IOT2000 permette l’accesso tramite seriale, SSH e Telnet; in questa guida effettueremo una connessione SSH.

SIMATIC IOT2000 ha come indirizzo statico di default: 192.168.200.1. Per stabilire una connessione SSH, il vostro computer dovrà avere la stessa sottorete di SIMATIC IOT2000.

Se state utilizzando Windows utilizzate la guida SETTING UP the SIMATIC IOT2020, SIMATIC IOT2040

Gli utenti Linux e MacOSX possono seguire i passi che seguono.

Quanto la rete del vostro computer è configurata con la stessa sottorete del SIMATIC IOT2040 verificare la connettività con un ping:

ping 192.168.200.1

Il risultato dovrebbe essere simile a quanto indicato nell’immagine che segue, se ciò accade vuol dire che il dispositivo è correttamente configurato

PING 192.168.200.1 (192.168.200.1) 56(84) bytes of data.
64 bytes from 192.168.200.1: icmp_seq=1 ttl=64 time=1.04 ms
64 bytes from 192.168.200.1: icmp_seq=2 ttl=64 time=1.03 ms
64 bytes from 192.168.200.1: icmp_seq=3 ttl=64 time=1.00 ms

Accedere al gateway utilizzando il comando

ssh root@192.168.200.1

Al primo accesso verrà chiesto di approvare la connessione SSH, scrivete “yes” e premete invio per continuare.

Una volta stabilito l’accesso vedrete la seguente struttura sul vostro terminale:

root@iot2000:~#

Come dette sopra, l’indirizzo statico del SIMATIC IOT 2040 è impostata a 192.168.200.1 pertanto, se è necessario un altro indirizzo IP statico o un indirizzo DHCP, questo può essere impostato nel file “interfaces” nella directory “/etc/network”.

Per fare questo dovete spostarvi nella directory:

cd /etc/network/

Aprire il file “interfaces” usando l’editor nano:

nano interfaces

Il contenuto del file “interface” è per default impostato come di indicato di seguito:

# /etc/network/interfaces -- configuration file for ifup(8), ifdown(8)
# The loopback interface
auto lo
iface lo inet loopback
# Wired interfaces
auto eth0
iface eth0 inet static
        address 192.168.200.1
        netmask 255.255.255.0
auto eth1
iface eth1 inet dhcp

Se state lavorando con SIMATIC IOT2040 l’indirizzo DHCP è configurato per default sulla seconda porta (X2P1LAN). Accertatevi che il cavo di rete sia connesso sulla seconda porta Ethernet e riavviate il gateway

Se lavorate con SIMATIC IOT2020 e desiderate impostare l’indirizzo DHCP dovete modificare l’interfaccia come indicato di seguito e riavviare successivamente il gateway:

# /etc/network/interfaces -- configuration file for ifup(8), ifdown(8)
# The loopback interface
auto lo
iface lo inet loopback
# Wired interfaces
auto eth0
iface eth0 inet dhcp

Utilizzo dell’Arduino IDE

SIMATIC IOT2000 è compatibile con l’IDE Arduino attraverso il pacchetto Galileo. Seguire i passi in elenco per configurare correttamente la scheda.

1 – Aprite l’IDE Arduino

2 – in Tools selezionare Board > Boards Manager

3 – inserire nel campo di ricerca Intel i5 e fate click su Install

4 – Selezionare Intel Galileo Gen2 dal menù Tools > Board

5 – Utilizzare la connessione micro USB per connettere IOT2040 al computer

6 – Selezionare la porta COM assegnata da Tools > Port > Intel Galileo

7 – Aprire lo sketch di esempio Blink: File > Examples > 01.Basics > Blink e effettuare l’upload sullo IOT2040, al termine del trasferimento il LED USER lampeggerà. Se il vostro computer non rileva la scheda l’IOT2040 dovrete provvedere ad aggiornare manualmente i driver seguendo il link.

Lunga vita e prosperità!

Errori comuni nell’uso di Arduino – fare più azioni nell’if senza l’uso delle parentesi graffe

1 Replica

Continua la segnalazione degli errori che spesso vengono commessi durante le prime attività di programmazione con Arduino.
La sequenza di istruzioni da eseguire se risulta vera la condizione dell’istruzione if (il corpo della if) deve essere racchiusa tra parentesi graffe. L’errore è immaginare che l’indentazione sia sufficiente per indicarne l’appartenenza al corpo della if, modalità valida in altri linguaggi di programmazione come in Python, ma non in C:

Uso non corretto

1if (temperatura > 25)
2  digitalWrite (normaleTemp, LOW);
3  digitalWrite (allarmeTemp, HIGH);

Uso corretto

1if (temperatura > 25)
2{
3  digitalWrite (normaleTemp, LOW);
4  digitalWrite (allarmeTemp, HIGH);
5} // fine del controllo temperatura &gt; 25

Buon lavoro

Gestire con micro:bit un display 1602 I2C

2 Repliche

Ho realizzato questo tutorial come risposta ad un quesito che mi è stato posto da un’amica collega sull’utilizzo del display 1602 I2C comandato da micro:bit.
Per quanto riguarda la descrizione tecnica del display vi rimando al post su questo sito:

Utilizzo dell’LCD 16×2 Hitachi HD44780 1602 con modulo I2C PCF8574T

Per un utilizzo con micro:bit è sufficiente conoscere il tipo esatto di integrato I2C che gestisce la comunicazione tra display e micro:bit nella modalità indicata da questo tutorial.

Aprite un nuovo progetto dall’ambiente grafico di programmazione di micro:bit.
Aggiungiamo l’estensione che consente la gestione di un display 16×2 I2C, per far ciò selezionate “+Extensions”:

nel campo di ricerca inserite: I2C

dovreste ottenere il seguente risultato:

Selezionate l’estensione indicata nell’immagine:

All’interno dei blocchi disponibili ritroverete quelli che fanno riferimento al display:

Ogni dispositivo I2C dispone di un indirizzo, un codice a cui bisogna far riferimento in fase di programmazione e per quanto riguarda la scheda di comunicazione I2C disposta sul retro del display troverete due tipi di dispositivi con indirizzo differenti l’uno dall’altro. La differenza consiste nel tipo di circuito integrato che gestisce la comunicazione I2C:

PCF8574 > indirizzo 39
PCF8574A > indirizzo 63

L’indirizzo dovrà essere inserito all’interno di un apposito blocco come indicato di seguito.

Per sapere quale indirizzo usare potete leggere la sigla dell’integrato, come indicato nell’immagine che segue:

nel mio caso l’indirizzo da inserire sarà il 39.

L’altro metodo consiste nel sostituire, nel codice che segue, gli indirizzi sopra indicati in modo da individuare il numero corretto che permette la visualizzazione del testo sul display.

Per il collegamento del circuito avete necessità di alimentare il display a 5V, in commercio esistono degli edge connector (connettore per collegare micro:bit alla breadboard) che prelevano dalla USB i 5 volt, nel mio caso questa funzionalità non è fornita, l’unica tensione disponibile è di 3,3V non sufficienti per alimentare il display.

Se anche voi siete nelle medesime condizioni allora alimenterete via USB il micro:bit mentre il display dovrà essere alimentato esternamente mediante una tensione di 5V. Se agite in questo modo ricordate che la terra (GND) dovrà essere la medesima (collegate insieme) per entrambi i dispositivi. Fate riferimento allo schema di seguito indicato:

Sul micro:bit il pin 20 corrisponde all’SDA e il pin 19 all’SCL, pin che avranno una corrispondenza con il display. Per le mie sperimentazioni dispongo di un cavo USB modificato per poter inserire su breadboard la tensione di 5V proveniente dalla USB del computer.

Realizzeremo un semplice programma che consente di visualizzare su due righe il testo:

BBC micro:bit
Italy timer

dove timer è il numero di secondi trascorsi dall’avvio del programma.

L’inserimento della prima istruzione provocherà la visualizzazione del display I2C:

L’istruzione “LCD initialize with Address 39” assegna al display l’indirizzo 39

L’istruzione “show string” mostrerà sul display il testo incluso nel primo campo: “BBC micro:bit” che verrà scritto a partire dalla colonna 0 e riga 0 (in prima riga).

La seconda “show string” mostrerà sul display il testo “Italy” alla colonna 0 e riga 1 (in seconda riga):

Definiamo una nuova variabile che andremo successivamente ad incrementare:

assegnamo alla variabile il nome: contatore

All’interno della funzione “forever” inserire l’istruzione “change” per incrementare di una unità la variabile “contatore”.

Con l’istruzione “show number” visualizziamo sul display un numero, inserendo nel primo campo la variabile “contatore” il numero visualizzato sarà quello memorizzato nella variabile contatore:

La visualizzazione del numero contenuto in “contatore” avverrà in colonna 6 riga 1:

Aggiungendo una pausa di 1 secondo l’incremento del numero che appare sul display sarà di 1 secondo:

Questo il risultato:

Buon Coding a tutti

Errori comuni nell’uso di Arduino – uso non corretto della digitalWrite

Lascia una risposta

Errore: considerare la “,” come separatore di istruzioni e non come separatore di valori. In C una scrittura del tipo: (a, b, c) è una sequenza di espressioni separate da virgola che valuta l’ultima espressione c, mentre {a; b; c;} è una sequenza di istruzioni che non valuta nulla.
La virgola si inserisce solamente tra due espressioni a differenza del punto e virgola che si inserisce alla fine di un’istruzione (ma non di un’istruzione di blocco come: if, for, while, do while).

Esempio non corretto

`1`	`digitalWrite ((5, 6, 7), HIGH);`

Esempio corretto

1digitalWrite (5, HIGH);
2digitalWrite (6, HIGH);
3digitalWrite (7, HIGH);

O ancora meglio usando un ciclo for:

`1`	`for` `(byte i = 5; i<= 7; i++)`

`2`	`digitalWrite(i, HIGH);`

Domanda che in genere faccio ai ragazzi:
“perché ho dichiarato i come byte e non come int?”

La risposta la trovate in: Appunti di programmazione su Arduino: tipi di dati in cui viene evidenziato che la dimensione del tipo byte è di 8 bit (1 byte) e rappresenta interi (senza decimali) ed hanno un range da 0 a 255, mentre gli int sono dei tipi di dato usati per memorizzare numeri senza decimali e memorizzano valori a 16 bit (2 byte) nel range da 32.767 a -32.768, quindi usando il tipo byte occupiamo meno spazio in memoria.

Buon Coding a tutti

Disegnare caratteri personalizzati con Arduino per un LCD 16×2

Lascia una risposta

Durante le attività di sperimentazione capita spesso la necessità di utilizzare caratteri speciali o icone che non fanno parte del set di caratteri ASCII standard (https://www.asciitable.com) visualizzatili su un display 16×2. Ovviamente un display LCD 16×2 non permette risoluzioni elevate, ma la qualità che si riesce ad ottenere è più che accettabile.

Tutti i display LCD basati sul controller Hitachi HD44780 hanno due tipi di memorie in cui vengono memorizzati i caratteri: CGROM e CGRAM (Character Generator ROM & RAM). La memoria CGROM non è volatile e non può essere modificata mentre la memoria CGRAM è volatile e può essere modificata in qualsiasi momento.

CGROM è usato per memorizzare tutti i caratteri permanenti che possono essere visualizzati usando il loro codice ASCII. Ad esempio, se scriviamo 0x4D, sul display viene visualizzato il carattere “M”. CGRAM è un’altra memoria che può essere utilizzata per la memorizzazione di caratteri definiti dall’utente.

Questa RAM è limitata a 64 byte, cioè implica che per LCD a 5 × 8 pixel come LCD 16×2 Hitachi HD44780, nel CGRAM possono essere memorizzati fino a 8 caratteri definiti dall’utente.

Un carattere sul display viene realizzato utilizzando una matrice di pixel 5 × 8, quindi per definire un nostro carattere dovremo lavorare in quest’area.

La definizione del carattere personale avviene utilizzando la funzione createChar() della libreria LiquidCrystal.

Prima di utilizzare la libreria createChar() è necessario impostare un array di 8 byte ed ognuno di essi definisce una riga della matrice costituita dalla lettera b che definisce il tipo del dato (byte) e la serie di 1 e 0 definiscono i pixel attivi o disattivi: nell’array i bit a 1 indicano i pixel attivi, mentre gli 0 indicano i pixel disattivi.

Nell’esempio che segue viene utilizzato un display 16×2 i2c

Per quanto riguarda la libreria LiquidCrystal_I2C vi rimando alla lezione:
Utilizzo dell’LCD 16×2 Hitachi HD44780 1602 con modulo I2C PCF8574T

Nel caso abbiate necessità di sviluppare in modo più semplice ed agevole i vostri caratteri personalizzati potete utilizzare una soluzione grafica che immediatamente vi permettessi impostare l’array di byte, fate riferimento a questi due link:

da cui ho realizzato velocemente le icone, il codice corrispondenti è poi stato inserito all’interno dello sketch come si può evincere dallo sketch che segue:

/* 
 *  Prof. Michele Maffucci
 *  Crezione di caratteri personali
 *  Utilizzo di un display LCD 16×2 Hitachi HD44780 1602
 *  con modulo i2C PCF8574T
 *  Data: 17.01.2020 - v01
*/

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// inizializzazione della libreria in cui è descritta la modalità di utilizzo dei pin
LiquidCrystal_I2C lcd(0x27, 16, 2); // impostazione dell'indirizzo dell'LCD 0x27 di 16 caratteri e 2 linee

// caratteri personalizzati

byte lucchettoChiuso[8] = {
  0b01110,
  0b10001,
  0b10001,
  0b10001,
  0b11111,
  0b11011,
  0b11011,
  0b11111
};

byte lucchettoAperto[8] = {
  0b01110,
  0b10000,
  0b10000,
  0b10000,
  0b11111,
  0b11011,
  0b11011,
  0b11111
};

byte Altoparlante[8] = {
  0b00001,
  0b00011,
  0b01111,
  0b01111,
  0b01111,
  0b00011,
  0b00001,
  0b00000
};

byte batteriaMezza[8] = {
  0b01110,
  0b11011,
  0b10001,
  0b10001,
  0b10001,
  0b11111,
  0b11111,
  0b11111
};

byte alieno[8] = {
  0b10001,
  0b01010,
  0b11111,
  0b10101,
  0b11111,
  0b11111,
  0b01010,
  0b11011
};


byte pacmanBoccaChiusa[8] = {
  0b01110,
  0b11101,
  0b11111,
  0b11111,
  0b11000,
  0b11111,
  0b11111,
  0b01110
};

byte pacmanBoccaAperta[8] = {
  0b01110,
  0b11101,
  0b11111,
  0b11100,
  0b11000,
  0b11000,
  0b11111,
  0b01110
};

byte fantasmino[8] = {
  0b01110,
  0b11111,
  0b10101,
  0b11111,
  0b11111,
  0b11111,
  0b11111,
  0b10101
};

void setup()
{
  lcd.begin();      // inizializzazione dell'LCD
  lcd.backlight();  // attivazione della retroilluminazione

  // creazione nuovi caratteri
  lcd.createChar(0, lucchettoChiuso);
  lcd.createChar(1, lucchettoAperto);
  lcd.createChar(2, Altoparlante);
  lcd.createChar(3, batteriaMezza);
  lcd.createChar(4, alieno);
  lcd.createChar(5, pacmanBoccaChiusa);
  lcd.createChar(6, pacmanBoccaAperta);
  lcd.createChar(7, fantasmino);
  
  // Cancella il display
  lcd.clear();

  // Stampa la stringa
  lcd.print("maffucci.it");

}

void loop()
{
  lcd.setCursor(0, 1);
  lcd.write(byte(0));

  lcd.setCursor(2, 1);
  lcd.write(byte(1));

  lcd.setCursor(4, 1);
  lcd.write(byte(2));

  lcd.setCursor(6, 1);
  lcd.write(byte(3));

  lcd.setCursor(8, 1);
  lcd.write(byte(4));

  lcd.setCursor(10, 1);
  lcd.write(byte(5));

  lcd.setCursor(12, 1);
  lcd.write(byte(6));

  lcd.setCursor(14, 1);
  lcd.write(byte(7));
  
}

Dopo aver incluso la libreria, è necessario inizializzare l’array che definisce il carattere personalizzato definito da 8 byte.

...
byte alieno[8] = {
  0b10001,
  0b01010,
  0b11111,
  0b10101,
  0b11111,
  0b11111,
  0b01010,
  0b11011
};
...

Nel setup() bisogna inizializzare il carattere personalizzato mediante la funzione createChar(), che accetta due parametri, il primo, compreso tra 0 e 7 è utilizzato come indirizzo ad uno degli 8 caratteri creati personalizzati, il secondo parametro definisce il nome dell’array di byte che definisce il carattere personalizzato.

  // creazione nuovi caratteri
  lcd.createChar(0, lucchettoChiuso);
  lcd.createChar(1, lucchettoAperto);
  lcd.createChar(2, Altoparlante);
  lcd.createChar(3, batteriaMezza);
  lcd.createChar(4, alieno);
  lcd.createChar(5, pacmanBoccaChiusa);
  lcd.createChar(6, pacmanBoccaAperta);
  lcd.createChar(7, fantasmino);

Successivamente nel loop, per la visualizzazione del carattere personalizzato viene utilizzata la funzione write() che ha come parametro il numero (l’indirizzo) assegnato al carattere.

...
void loop()
{
  lcd.setCursor(0, 1);
  lcd.write(byte(0));

  lcd.setCursor(2, 1);
  lcd.write(byte(1));

  lcd.setCursor(4, 1);
  lcd.write(byte(2));

  lcd.setCursor(6, 1);
  lcd.write(byte(3));

  lcd.setCursor(8, 1);
  lcd.write(byte(4));

  lcd.setCursor(10, 1);
  lcd.write(byte(5));

  lcd.setCursor(12, 1);
  lcd.write(byte(6));

  lcd.setCursor(14, 1);
  lcd.write(byte(7));
}
...

Esercizi per i miei studenti

Esercizio 1

Realizzare uno sketch che mostra un omino che cammina da sinistra verso destra e ritorno, in modo continuo. Il movimento deve essere accompagnato dall’emissione di due note che mettono in evidenza il passo.

Esercizio 2

Realizzare un Pac Man che partendo dalla riga 0 colonna 0 mangi una serie di puntini , scende alla riga 1 colonna 0 e prosegue fino alla riga 1 colonna 15 dove si trova un fantasma che deve essere mangiato. Predisporre un buzzer che emette due tipi di suoni, uno che identifica quando Pac Man mangia un puntino ed uno quando Pac Man mangia il fantasma. Quando il fantasma viene mangiato il display fa un 3 blink e l’azione comincia nuovamente con il Pac Man che si posizione in riga 0 colonna 0.

Esercizio 3

Realizzare un sistema che rilevi il livello di carica di batterie da 1,5V.
Utilizzare 7 icone che definiscono livelli diversi di carica della batteria e a fianco di ogni icona deve anche apparire in modo numerico il valore di tensione misurato.

Esercizio 4

Realizzare uno sketch che valuta in percentuale la quantità di luce in una stanza e la mostra su display mediante numero in percentuale e una barra di livello realizzata con caratteri personalizzati che può aumentare o diminuire in funzione della quantità di luce che colpisce l’LDR.
Mediante la pressione di un pulsante viene attivata la calibrazione del sistema, questa fase dura 5 secondi in cui viene misurate il valore minimo di luce (comprendo con mano il sensore) e valore massimo della luce (togliendo la mano dal sensore). La fase di calibrazione deve essere evidenziato dalla scrittura su display del messaggio: “calibrazione” e icone animate che dovete inventare.

Condividi:

Articoli correlati:

Condividi:

Articoli correlati:

Condividi:

Articoli correlati:

Condividi:

Articoli correlati:

Condividi:

Articoli correlati: