Archivio dell'autore: Mario De Ghetto

Un mio nuovo articolo su ioProgrammo di questo mese (n. 222)

Nel n. 222 di IoProgrammo, in edicola a gennaio, potete trovare un mio articolo sulla conversione di applicazioni “Desktop” (Windows Forms o WPF) per Microsoft Store, in modo da poterle veicolare su una piattaforma mondiale che ci permette di vendere i nostri prodotti in modo facile e ben visibile. Non solo: Microsoft Store gestisce i pagamenti dai clienti che installano le nostre app e gestisce i compensi agli autori delle app, fornisce uno strumento facile e trasparente per gli aggiornamenti, via via che li pubblichiamo, e ci permette di monitorare il numero di visitatori alla pagina della app, le installazioni, l’utilizzo e gli eventuali blocchi improvvisi (crash).

Nell’immagine seguente potete vedere la prima di copertina con il titolo del mio articolo evidenziato con un riquadro blu:


IoProgrammo


L’articolo evidenziato in giallo, invece, è stato scritto da Antonio Pelleriti (https://www.facebook.com/antonio.pelleriti) che segnalo perché è un argomento assolutamente interessante.

Buona lettura! Winking smile


Annunci

Aggiornamento di Visual Studio 2017 alla versione 15.5.4

Pochi giorni fa ho pubblicato un post sull’annuncio di Visual Studio 15.6 (Preview).

Intanto che aspettiamo questa nuova “minor version”, ecco che Visual Studio 2017 viene aggiornato con la versione 15.5.4, ma si tratta solo di un aggiornamento per correggere alcuni bug del software (confrontate qui), quindi non contiene nuove funzionalità.

Visual Studio 2017 version 15.5.4 is now available

Buon aggiornamento! Winking smile

Non fate l’aggiornamento dell’add-in "Arduino for Visual Studio"…

Se avete installato l’add-in “Arduino for Visual Studio” per poter programmare gli sketch direttamente nell’editor di codice di Visual Studio 2017 (o versioni precedenti), probabilmente in questi giorni avrete visto che tra gli aggiornamenti è prevista proprio la nuova versione di questo add-in e precisamente la Release 1801.14 del 14 gennaio 2017.

Se però aprite la pagina dedicata al progetto, dalla quale potete anche scaricare il pacchetto di installazione del prodotto, potrete vedere che le righe di descrizione (le “Release Notes”) della versione che ho appena indicato sono completamente barrate:


image


Non sembrano esserci delle spiegazioni sui motivi che hanno indotto il team di sviluppo a barrare la descrizione e quindi non è dato sapere cosa sia successo, anche perché l’aggiornamento dell’add-in che ho provato in prima persona è andato a buon fine.

Ho provato a creare una nuova applicazione Visual C++ > Visual Micro > Blink Led Example e sembra essere totalmente funzionante, compreso il supporto di IntelliSense per il completamento delle parole chiave del linguaggio e dei parametri delle istruzioni.

Vedremo prossimamente se l’add-in sarà ulteriormente aggiornato o se invece sarà sistemata la pagina di supporto.

Buon Arduino a tutti!  Winking smile


Visual Studio 2017 – Annuncio della versione 15.6 (preview)

Il team di sviluppo di Visual Studio 2017 ha annunciato nel suo blog il rilascio della versione 15.6 (in preview) e della versione 7.4 per Mac (anche questa in preview): https://blogs.msdn.microsoft.com/visualstudio/2018/01/10/visual-studio-2017-version-15-6-preview-2-and-visual-studio-for-mac-version-7-4-preview/

Tra le varie novità (nel post precedente avevo segnalato la funzione di duplicazione di righe o blocchi di codice) c’è la possibilità di andare alla definizione dei sorgenti decompilati con ILSpy.

Altre novità riguardano gli strumenti di diagnostica, lo sviluppo in C++, lo sviluppo per Azure, una vista gerarchica per la finestra Test Explorer e aggiornamenti a Xamarin.

Visual Studio 2017 versione 15.6 (Preview)

Nella Preview della versione 15.6 di Visual Studio 2017 è prevista una funzioncina tutto sommato piccola, ma molto utile: invece di utilizzare la Clipboard standard di Windows per copiare linee o interi blocchi di codice con la classica combinazione CTRL+C, CTRL+V ora è possibile utilizzare la combinazione CTRL+E, V. In questo modo non si cancellerà il contenuto della Clipboard di Windows che pertanto resta con il contenuto precedente.

La funzione di duplicazione è disponibile anche nel menu Edit, quindi potete utilizzare il percorso Edit > Duplicate, dopo aver selezionato una o più righe di codice da copiare.

Ecco un paio di immagini:

01

02

(Fonte: Daily .NET Tips – http://dailydotnettips.com/2018/01/12/did-you-know-now-you-can-duplicate-line-of-code-without-loosing-your-clipboard-content-within-visual-studio/)

Un traguardo per questo blog…

Prima che il 2017 fosse terminato, questo blog ha raggiunto un numero di visite piuttosto importante (almeno per me…):

650000

Grazie a tutti! Winking smile

Auguri per il nuovo anno, con in regalo (a breve) la mia nuova app-libro "Garage40 Elettronica"

Visto che il 2017 sta volgendo al termine e il 2018 sta già bussando alle porte di un quarto di mondo, tra i buoni propositi che mi pongo per il nuovo anno è una nuova app-libro: “Garage40 Elettronica“.

Si tratta di una app con contenuti dedicati all’elettronica di base, ai componenti elettronici, ad Arduino, a Internet of Things (IoT), in futuro anche a Raspberry e alle connessioni con altre tecnologie: Microsoft Azure (cloud), Visual Studio (per la programmazione), il software Fritzing (per disegnare gli schemi delle connessioni) e molto altro.

Il progetto è appena stato avviato e sarà pubblicato tra pochi giorni al prezzo iniziale di 0,00 €, cioè gratuito!

Con l’aumentare dei contenuti, aumenterà anche il prezzo dell’app, ma chi l’avrà già “acquistata” al prezzo valido al momento dell’installazione non dovrà pagare nulla.

BUON ANNO, BUON 2018 A TUTTI!

NOTA – se volete sostenere economicamente questo progetto con una donazione (di qualsiasi entità, anche piccola), potete farlo attraverso la seguente pagina: https://www.produzionidalbasso.com/project/appbook-elettronica/

Una guida gratuita ai servizi di Microsoft Azure per gli sviluppatori

Poche settimane fa è stata rilasciata la seconda edizione di una guida gratuita per gli sviluppatori: The Developer’s Guide to Microsoft Azure (per scaricarla potete cliccare sul link), di Michael Crump e Barry Luijbregts.

image

La guida è costituita da ben 7 capitoli:

  • Cap. 1: The Developer’s Guide to Microsoft
  • Cap. 2: Getting started with Microsoft Azure
  • Cap. 3: Adding intelligence to your application
  • Cap. 4: Securing your application
  • Cap. 5: Where and how to deploy your Microsoft Azure services
  • Cap. 6: A walk-through of Microsoft Azure
  • Cap. 7: Using the Microsoft Azure Marketplace

Vengono esplorati tutti i servizi di Azure, tra i quali anche i Cognitive Services, Azure IoT Hub, i servizi per la sicurezza e molto altro.

Consiglio vivamente di scaricarlo e di leggerlo, perché vi si possono trovare molte cose interessanti, sia per sviluppatori singoli che per team di sviluppo aziendali.

Buona lettura! Winking smile

Una "app-book" su Office 2016 per Windows 10

Ho appena pubblicato una innovativa “app” per PC con Windows 10, scaricando la quale potrete avere una copia del mio libro “OFFICE 2016 PER PRINCIPIANTI” pubblicata in cartaceo su Amazon (a colori http://bit.ly/office2016colori – in bianco e nero http://bit.ly/office2016bn, rispettivamente a 51,90 € e a 15,50 €).

Su Microsoft Store, invece, potete ottenerla al prezzo competitivo di 2,99 € visitando questo indirizzo:

https://www.microsoft.com/it-it/store/p/garage40-book/9nvq854f11bw?rtc=1

24993263_10155601250416971_4284645672449403797_n

La versione sullo Store è uguale alla copia a colori cartacea e quindi il vantaggio economico è enorme per chi volesse preferire la versione digitale piuttosto che quella cartacea.

A chi potrebbe servire una “app-book” come questa? A studenti (dalle elementari in su), a persone più “mature” che volessero imparare a usare Office, alle aziende che volessero organizzare corsi per i propri dipendenti, a singole persone che devono partecipare a una selezione di lavoro (concorso, colloquio con prove pratiche ecc.) e, perché no?, anche a persone semplicemente curiose.

Il vantaggio di una “app-book” in sostanza qual è? In questo caso abbiamo un libro “completo” con argomenti che vanno da Office 2016 in generale, fino ai dettagli d’uso di Word, Excel e Power Point. Ma non finisce qui: chiunque può segnalare un refuso, un errore nel testo e questo sarà corretto nella versione successiva, pubblicata nello Store e aggiornata automaticamente da Windows 10! Inoltre il libro così com’è è virtualmente “finito” (come può esserlo un libro di testo stampato), ma è potenzialmente suscettibile di adeguamenti, modifiche ed estensioni. Per esempio, se le richieste saranno relativamente numerose, si potrà aggiungere un ulteriore capitolo su un argomento di interesse, sempre incentrato su Office 2016.

Insomma, sono molto soddisfatto di questo primo risultato e spero che possa piacervi.

Buona lettura! Winking smile

Rilasciata la versione 15.5 di Visual Studio 2017 + Visual Studio for Mac

Proprio ieri è stata rilasciata la versione 15.5 di Visual Studio 2017, nonché una versione specifica di Visual Studio per Mac, ecco il blogpost con cui è stato fatto l’annuncio: https://blogs.msdn.microsoft.com/visualstudio/2017/12/04/visual-studio-2017-version-15-5-visual-studio-for-mac-released/.

Questo aggiornamento ha puntato molto sulle performance di Visual Studio: ad esempio il caricamento di un progetto può avvenire in solo 9 secondi (ovviamente la velocità dipende anche da altri fattori, ma il risultato è comunque straordinario).

2017-12-05_05-32-02



Ci sono poi altri miglioramenti in molti altri ambiti, come nei linguaggi C#, C++ e F# (purtroppo niente per Visual Basic), il supporto a Docker, diagnostica, unit testing, Azure, Xamarin… insomma, così tante novità che vi consiglio di leggere il post dell’annuncio del team di sviluppo e gli altri link correlati.

Buon aggiornamento! Winking smile


Aggiornamento dell’add-in Arduino IDE for Visual Studio

Anche Visual Micro ha aggiornato il suo prodotto: attraverso le notifiche di Visual Studio 2017, se l’avete già installato, vedrete che potete aggiornarlo alla versione 1711.19.0, rilasciata proprio oggi (19 novembre 2017).

Se lo utilizzate per i vostri progetti con Arduino, vi raccomando di aggiornare questo add-in periodicamente, in modo da avere sempre la versione corretta e con le funzionalità più recenti.

Winking smile

Rilasciata la nuova versione 15.4.4 di Visual Studio 2017

Nel tempo è diventata una consuetudine: ancora una volta è stata rilasciata, in tempi estremamente rapidi (solo 6 giorni dopo la build 15.4.3) una nuova build di Visual Studio 2017 e precisamente la 15.4.4.

Potete consultare le note di release alla pagina:

https://www.visualstudio.com/en-us/news/releasenotes/vs2017-relnotes#15.4.4.

Buon aggiornamento! Winking smile

TechSmith: SnagIt 2018 e Camtasia 9.1.0

Questo piccolo post per un semplice ringraziamento a TechSmith (https://www.techsmith.com/) che mi ha inviato gratuitamente le licenze d’uso delle nuove versioni di SnagIt 2018 (un software che permette di ritagliare immagini dallo schermo e di modificarle o di fare delle registrazioni dallo schermo) e di Camtasia 9.1.0 (un altro software che permette non solo di registrare video dallo schermo e audio dal microfono, ma anche di fare editing di qualità professionale).

Con questi software è estremamente facile prendere delle immagini dallo schermo per poi scrivere articoli, tutorial ecc., ma anche creare dei tutorial “video”, dove le spiegazioni diventano veramente efficaci e intuitive perché si può “far vedere come si fa” piuttosto che spiegarlo con centinaia o migliaia di parole.

Grazie ancora, vi sono infinitamente grato. Winking smile

Arduino & C. – Un mio articolo su ioProgrammo

Volete creare un pianoforte elettronico con Arduino e Visual Studio?

Su ioProgrammo in edicola in questi giorni (“Novembre 2017”) c’è il mio articolo con programmazione in Visual Basic e in C# (ved. riquadro in basso a destra).

Buona lettura e buon divertimento! Winking smile

ioprogrammo_november2017

Annunciato il nuovo .NET Framework 4.7.1

La nuova versione del .NET Framework 4.7.1 porta con sé numerosi miglioramenti, relativamente a:

  • accessibilità (narrazione, alto contrasto ecc.)
  • supporto di .NET Standard 2.0
  • sicurezza
  • ASP.NET
  • applicazioni WPF
  • miglioramento delle prestazioni e dell’affidabilità

microsoft-net-framework-4.71

Qui trovate l’annuncio ufficiale nel blog del team di sviluppo .NET:

https://blogs.msdn.microsoft.com/dotnet/2017/10/17/announcing-the-net-framework-4-7-1/

Nella stessa pagina ci sono i link per scaricare il pacchetto di installazione, sia in versione ridotta (Web Installer) che in versione completa (Offline Installer).

SQL Server 2017, la nuova versione del DBMS targato Microsoft

Il team di sviluppo di SQL Server, pochi giorni fa, ha annunciato alcune delle novità che sono state introdotte nella nuova versione SQL SERVER 2017, appena rilasciata per il download.

Al seguente indirizzo trovate l’annuncio ufficiale dal blog del team di sviluppo di SQL Server (ma riporto il testo anche qui di seguito): http://bit.ly/annuncioss2017

Final version of SQL Server 2017 is available for download. New version of SQL Server has a lot of enhancements compared to the previous version.

In this post will be highlighted some of the new features that are available:

Cross-platform support – you can run SQL Server 2017 on Windows, Linux, and Docker containers.

Built-in intelligence – SQL Server supports Python and native scoring using PREDICT function.

T-SQL Language enhancements – There are several enhancements in T-SQL language such as graph processing, new string functions (TRIM, TRANSLATE, CONCAT_WS), and aggregate (STRING_AGG) new Japanese collations that are unique in database market.

Intelligent query processingAutomatic tuning continuously monitors query performance and forces previous plans if some performance regression is detected. Execution of Multi-statement Table value functions is faster thanks to the interleaved execution. Batch mode processing now includes adaptive join operators and leverages memory grant feedback information to execute plans more efficiently.

Column-store enhancements – Clustered columnstore indexes support LOB types and enable you to compress your NVARCHAR(MAX), VARCHAR(MAX) and VARBINARY(MAX) columns up to 25x ratio, non-persisted computed columns enable you to put calculated expressions directly in table definitions,  NONCLUSTERED COLUMNSTORE indexes support online build/rebuild.

In-memory OLTP  enhancements – Memory optimized tables now support computed columns, naively compiled modules support new string and JSON functions, CASE statement, and WITH TIES.

Native import enhancements – BULK INSERT and OPENROWSET enable you to and to load files from Azure Blob Storage. Also, import functions are able to parse real CSV files and correctly process quoted characters.

Better monitoring – Query Store now provides you information about wait stats and a lot of new DMVs are added.

These are just some of the new features that are available in SQL Server 2017. You can find more information about new features in SQL Server 2017 here.


Mi sembra che le novità siano piuttosto interessanti, no? Winking smile

Arduino Raspberry & C. – Windows 10 IoT Core, un libro interessante

Da quando ho iniziato a interessarmi a questo grande mondo dei microcontroller, appena un paio di mesi fa, ho studiato, sperimentato e scritto molto.
Tra le tante cose che ho visto e letto, sicuramente un posto di rispetto va al libro”Windows 10 IoT Core: Il manuale per maker”, 479 pagine per 19.90 € (per Kindle), reperibile su Amazon.
Vi si parla di Wiring, Virtual Shields e appunto di Windows 10 IoT Core, per Arduino e per Raspberry Pi.
Leggetelo, ne vale la “pena” 😉

Arduino & C. – Massimo Banzi ha spiegato la situazione attuale di Arduino

Oggi voglio mettervi al corrente brevemente di cosa ha riferito Massimo Banzi (uno dei 5 fondatori originali di Arduino) all’evento “MAKER FAIRE NEW YORK 2017” (23 settembre 2017) in merito alla situazione attuale di Arduino e quale sarà lo sviluppo futuro.

Banzi conferma per Arduino alcuni concetti chiave: open source, sviluppo aperto, il sito ufficiale è http://arduino.cc (da arduino.org ci sarà un redirezionamento automatico a arduino.cc) e il lancio di due nuovi fattori di forma di ARDUINO MKR.

Il mondo Arduino quindi appare nettamente in movimento verso il futuro: nuove schede, novità all’IDE e al linguaggio degli sketch, cloud e molto altro.

Eccovi alcune foto dell’evento Winking smile.

Fonte delle foto: https://blog.adafruit.com/2017/09/23/state-of-arduino


Arduino & C. – Una ulteriore considerazione sulla sicurezza

In tema di “sicurezza”, leggendo una discussione in un gruppo Facebook dedicato ad Arduino ho imparato una cosa che non sapevo e che nemmeno mi era passata per la mente.

sicurezza

Chi fa sperimentazione come sto facendo io, con Arduino (o Raspberry) e vari componenti elettronici, ha la tendenza di seguire questo modo di operare:

  1. a scheda staccata dall’alimentazione, predispongo i sensori o gli attuatori con i relativi collegamenti via jumper, alla breadboard o direttamente alla scheda del microcontroller;
  2. scrivo lo sketch da caricare sulla scheda (perlomeno uno sketch iniziale, soggetto a varie correzioni);
  3. attivo l’alimentazione della scheda;
  4. invio lo sketch alla scheda e verifico i risultati: se c’è qualcosa che non va bene, stacco l’alimentazione e cambio le connessioni oppure modifico lo sketch e lo ricarico nella scheda, finché non ho ottenuto il risultato desiderato.

Bene, non so quanti di voi hanno considerato cosa succede tra il punto 3 e il punto 4 (io no!): quando attaccate la scheda all’alimentazione, se non è una scheda nuova (dotata di un semplice Blinker), la scheda ha una prima fase di assestamento dei componenti e poi, a regime, avvia lo sketch che avevate caricato in precedenza. Ne consegue che potreste dare corrente in uscita su un pin che invece, nella nuova configurazione, dovrebbe leggere un valore da un sensore. Questo significa che, inconsapevolmente, potreste fare la cosa sbagliata, con il risultato di danneggiare qualcosa.

Per operare nella massima sicurezza, quindi, ricordatevi sempre questi “precetti”:

  • Regola n. 0: la sicurezza prima di tutto; state lavorando con la corrente (anche se a basso voltaggio), quindi state attenti;
  • Regola n. 1: quando finite un esperimento con una certa configurazione di componenti, prima di spegnere la scheda caricate uno sketch vuoto come questo:

void setup() {
}


void loop() {
}

In questo modo, alla riaccensione avrete una scheda che non fa assolutamente nulla (ma nemmeno danni!), finché non caricate lo sketch su cui state lavorando.

Mi raccomando, massima attenzione a quello che fate!

Buon divertimento Winking smile

Arduino & C. – Nuovo articolo per ioProgrammo (Pianoforte)

[AGGIORNATO]

Mi scuserete se mi sono preso una pausa dai post su Arduino & C., ma dovevo assolutamente finire un articolo per IoProgrammo.

L’articolo tratta l’utilizzo di un’applicazione in Visual Basic e un’applicazione “gemella” in C# per pilotare una scheda Arduino a cui ho collegato un buzzer (ma ho provato anche con un piccolo speaker), ho codificato i tasti del PC e in base al tasto viene emesso un suono a una certa frequenza.

Immagine04

Nell’articolo ho messo anche 4 brevi brani musicali che servono come esempio di melodia suonata da Arduino, con tanto di pause. Eccoli qui:

  • We wish you a Merry Christmas“:

    Z-N-NANBC-C-C-A-ADANB-Z-Z-D-DFDAN-C-Z-C-A-B-N

  • “Tanti auguri a te”:

    Z-Z-CC-Z-N-B—Z-Z-CC-Z-A-N—Z-Z-HH-D-N-B-C—F-F-DD-N-A-N

  • “La marcia dell’impero” (da Star Wars):

    VV-VV-VV-<<MVV-<<MVV—FF-FF-FF-GGMVV-<<MVV—22-KK-22-11POIO

  • “Andiam, andiam, andiamo a lavorar!” (da “Biancaneve e i 7 nani”)

    CA–MB–ADGDAM–CBACCBMAHG–AD–MA

Non voglio pubblicare un video con queste musiche per non togliervi la sorpresa… Trovate il video qui: http://bit.ly/ArduinoPianoforte

Volete provare? Nel numero del mese di ottobre (o al massimo di novembre) lo troverete su IoProgrammo!

Non appena avrò conferma della pubblicazione vi farò sapere tramite questo blog (e in automatico su Facebook, Twitter e LinkedIn).

Buon divertimento Winking smile

Arduino & C. – INPUT_PULLUP e i pulsanti

Nel mio post del 13 settembre ho inserito un paio di istruzioni come queste:

   pinMode(pulsante, INPUT);
   digitalWrite(pulsante, HIGH);

per attivare il resistore di pull-up (che nella figura seguente vedete indicato da R1).


Pullup


Da non confondere con questo:  Open-mouthed smile

pullup_var

La stessa cosa si può fare utilizzando la costante INPUT_PULLUP al posto di INPUT.

In questo caso dovremo scrivere una istruzione in meno, cioè non servirà più digitalWrite(…) perché sarà implicita nella istruzione precedente. Ecco la nuova versione:

   pinMode(pulsante, INPUT_PULLUP);

Trovate questa nuova versione nel mio post del 15 settembre.

Se volete approfondire questo argomento, visitate la pagina seguente: https://www.arduino.cc/en/Reference/Constants.

Buon pull-up!

Arduino & C. – Potenziometro

Ci sono tante forme diverse di potenziometro: per esempio possono essere dei cursori o delle manopole (strette o larghe), con fermo-corsa da entrambi i lati o a rotazione continua.

Generalmente hanno tre piedini (uno per l’alimentazione a +5V, uno per GND e uno per rilevare il valore della tensione e quindi la “posizione”), ma alcuni potenziometri rotanti (“rotary encoder”) possono avere anche un pulsante e hanno cinque piedini.

Questi sono alcuni potenziometri:

pot1pot2pot3pot4pot5pot6pot7

… e il simbolo elettrico è questo:

SimboloPotenziometro

Un potenziometro non è altro che un dispositivo che rileva una resistenza variabile che quindi fa variare la tensione da zero a +5V, attraverso un cursore che scorre sul resistore. Una maggiore distanza tra l’alimentazione e il punto di contatto del cursore comporta un tratto maggiore del resistore e quindi una resistenza più alta, mentre una minore distanza fa rilevare una resistenza minore. Il potenziometro rotante senza fine corsa è un caso particolare, perché abbiamo una codifica digitale della rotazione, in un senso o nell’altro.

Per leggere un valore graduale che non sia semplicemente il valore di tensione (HIGH) o il valore GND (LOW), bisogna che il piedino del segnale sia collegato a un pin analogico (uno di quelli che nelle schede Arduino sono contrassegnati dalla sigla A0, A1 … ecc.) oppure a uno dei pin contrassegnati dalla “tilde” (~) che indica che è uno dei pin PWM (Pulse Width Modulation = modulazione ad ampiezza di impulso).

Se utilizzate un potenziometro installato su una schedina come quella della prima immagine che ho riportato qui sopra (con tre piedini), potete immediatamente sapere lo scopo di ciascun piedino: GND va sul polo negativo (pin GND), VCC va sul polo positivo (+5V) e SIG va su un pin della scheda che utilizzeremo per leggere il segnale, cioè il valore della tensione rilevata con la resistenza variabile oppure il valore codificato se il potenziometro è digitale.

Vediamo ora un potenziometro a tre piedini in un circuito collegato ad Arduino:

CircuitoPotenziometro


Se scambiate i jumper di alimentazione (+5V) e di massa (GND) non succede nulla di grave, ma ottenete il comportamento opposto a quello “normale”: girando a sinistra aumenterà il segnale (la tensione), girando a destra diminuirà.

Ora vediamo uno sketch che possiamo scrivere e caricare sulla scheda per attivare i pin e per leggere il valore del potenziometro. Per semplicità, a tale scopo utilizzeremo il Monitor Seriale, ma potremmo utilizzare molti altri metodi: un lampeggiamento più veloce o più lento di un LED, un display a cifre “a 7 segmenti”, un display LCD o, tramite la porta seriale, in una nostra applicazione Visual Studio.

int encoderPin1 = 2;
int encoderPin2 = 3;
 
volatile int lastEncoded = 0;
volatile long encoderValue = 0;
 
long lastencoderValue = 0;
 
int lastMSB = 0;
int lastLSB = 0;
 
void setup() {
   Serial.begin (9600);
 
   pinMode(encoderPin1, INPUT_PULLUP);
   pinMode(encoderPin2, INPUT_PULLUP);
 
   attachInterrupt(0, updateEncoder, CHANGE);
   attachInterrupt(1, updateEncoder, CHANGE);
 
}
 
void loop(){
   Serial.println(encoderValue);
}
 
void updateEncoder(){
   int MSB = digitalRead(encoderPin1); //MSB = most significant bit
   int LSB = digitalRead(encoderPin2); //LSB = least significant bit
 
   int encoded = (MSB << 1) |LSB; //converting the 2 pin value to single number
   int sum  = (lastEncoded << 2) | encoded; //adding it to the previous encoded value
 
   if(sum == 0b1101 || sum == 0b0100 || sum == 0b0010 || sum == 0b1011) encoderValue –;
   if(sum == 0b1110 || sum == 0b0111 || sum == 0b0001 || sum == 0b1000) encoderValue ++;
 
   lastEncoded = encoded; //store this value for next time
}

In questo esempio, se ruotate in un verso o nell’altro il valore aumenterà o diminuirà di 4 unità per ogni “scatto”.

Il codice di cui sopra funziona anche se avete, come ho io, un “rotary encoder” come questo:

KY-040

Keyes KY-040

In questo caso, se ruotate premendo contemporaneamente il pulsante vedrete che l’incremento o la diminuzione sarà di una sola unità.

Il significato dei cinque piedini di questo dispositivo è il seguente:

  • GND: è il contatto a massa (“terra”)
  • +: è il contatto che va all’alimentazione (cioè il pin +5V)
  • SW: significa “switch” e rileva la pressione del pulsante NO (normally open = normalmente aperto)
  • DT: è il piedino che, come nel caso del dispositivo a tre piedini, rileva il segnale
  • CLK: è un altro piedino che rileva un valore sfalsato di 90° rispetto al segnale DT

Se volete una spiegazione dettagliata sul funzionamento di questo dispositivo e il significato dei piedini DT e CLK, potete visitare la pagina http://bit.ly/encoderKY040 dove è spiegato tutto molto bene.

Lo schema dei collegamenti è il seguente:

RotaryEncoder5pin

Questo è il codice dello sketch che potete utilizzare:

volatile boolean TurnDetected;
volatile boolean rotationdirection;


const int PinCLK=2;
const int PinDT=3;
const int PinSW=4;


int RotaryPosition=0;


int PrevPosition;


void isr ()  {
   delay(50);  // ritardo per effetto “rimbalzo”
   if (digitalRead(PinCLK))
     rotationdirection= digitalRead(PinDT);
   else
     rotationdirection= !digitalRead(PinDT);
   TurnDetected = true;
}


void setup ()  {
   pinMode(PinCLK,INPUT);
   pinMode(PinDT,INPUT); 
   pinMode(PinSW,INPUT);
   digitalWrite(PinSW, HIGH); // resistore di Pull-Up per lo switch
   attachInterrupt (0,isr,FALLING);
   Serial.begin(9600);
}


void loop ()  {
   if (!(digitalRead(PinSW))) {
     if (RotaryPosition == 0) {
     } else {
         RotaryPosition=0;
         delay(50);
         Serial.println(RotaryPosition);
       }
     }


  if (TurnDetected)  {
     PrevPosition = RotaryPosition;
     if (rotationdirection) {
       RotaryPosition=RotaryPosition+1;}
     else {
       RotaryPosition=RotaryPosition-1;}


    TurnDetected = false;


    if ((PrevPosition + 1) == RotaryPosition) {
         Serial.println(RotaryPosition);
     }


    if ((RotaryPosition + 1) == PrevPosition) {
         Serial.println(RotaryPosition);
     }
   }
}

Caricate questo sketch sulla scheda Arduino e aprite il Monitor Seriale: vedrete che la rotazione provocherà un aumento o una diminuzione del valore, mentre la pressione del pulsante azzererà il valore perché abbiamo voluto impostare una funzione di “reset”. Ovviamente possiamo fare in modo che la pressione del pulsante abbia qualche altro significato (per esempio, in un gioco potrebbe essere il pulsante di “sparo”).

Non voglio dilungarmi ulteriormente con le spiegazioni su questo dispositivo, anche perché molto probabilmente lo utilizzerò in qualche progetto futuro.

E’ il momento di passare a un altro argomento… preparatevi!  Winking smile







.

Arduino & C. – Ancora il pulsante… come semplificare il circuito

Nel post dell’8 settembre abbiamo visto come si può connettere un pulsante ad Arduino, utilizzando tre jumper e un resistore.

Effettivamente è abbastanza semplice, ma si può rendere ancora più semplice sfruttando una caratteristica delle schede Arduino: la resistenza di pull-up.

Prima di tutto vediamo come sarà in questo caso il circuito:

Untitled Sketch_bb


E’ evidente che con questa tecnica risparmiamo materiale (meno jumper e un resistore in meno), risparmiamo spazio e abbiamo una soluzione molto più pratica e facile da utilizzare nei nostri progetti. Ma come si fa a far funzionare il pulsante, visto che nella versione precedente avevamo bisogno di collegarlo all’alimentazione (5v), a GND e a un pin per leggere il valore del pulsante (premuto o non premuto)? In questo caso utilizziamo una caratteristica delle schede Arduino, programmabile via codice!

int LED = 13;
int pulsante = 8;


void setup() {
   pinMode(LED, OUTPUT);
   pinMode(pulsante, INPUT);
   digitalWrite(pulsante, HIGH);
}


void loop() {
   if (digitalRead(pulsante) == LOW) {
     digitalWrite(LED, HIGH);
     delay(100);
     digitalWrite(LED, LOW);
   }
}

Se provate il nostro esempio, vedrete che ogni volta che premete il pulsante si accenderà il LED sulla scheda: vediamo perché funziona.

Come potete vedere, prima di tutto ho inizializzato due variabili, indicando i pin da utilizzare (il pin 13 per utilizzare il LED della scheda e il pin 8 per leggere il valore del pulsante).

Nella funzione setup() ho inizializzato il LED come dispositivo di OUTPUT e il pulsante come dispositivo di INPUT. Però subito dopo ho attivato il segnale sul pulsante, cioè ho “scritto” il valore HIGH sul pin 8. Questo può sembrare strano, perché abbiamo definito quel pin come collegamento in ingresso e non in uscita… La spiegazione è semplice: i pin hanno un resistore interno detto di “pull-up” (da 20 kilo-ohm) che si attiva con la modalità che abbiamo visto. In pratica, attivando il resistore di pull-up otteniamo un circuito simile a questo:

circuito pull-up


Immagine tratta dal testo “Introduction to Arduino” di Alan G. Smith (2011)

Nell’immagine vediamo che il pulsante è connesso a GND e al pin 2 (per noi è il pin 8), ma siccome qualsiasi circuito elettrico deve essere completo per poter funzionare e quindi deve avere anche una connessione all’alimentazione (polo positivo: 5V), ecco che entra in gioco il resistore di pull-up interno (che noi non possiamo quindi vedere ma che c’è…). Se il pulsante NON è premuto, il circuito è formato dal pin (per noi l’8°), dal resistore e dall’alimentazione e quindi l’ingresso è HIGH; se il pulsante invece è PREMUTO, allora il pin 8 entra in connessione con GND e di conseguenza il segnale rilevato dal pin è LOW.

Ecco quindi il motivo per cui abbiamo questo strano comportamento (che si vede anche nella funzione loop() del nostro esempio) secondo il quale bisogna leggere LOW per rilevare il pulsante premuto e HIGH per rilevare un pulsante rilasciato. Sembra un controsenso, ma la spiegazione è questa.

Bene, anche per questa puntata abbiamo finito, nel prossimo post passiamo a un altro componente.  Winking smile


Arduino & C. – Come si fa a misurare i riflessi con un LED e un pulsante?

Nel precedente post abbiamo visto come si fa a far diventare permanente un pulsante temporaneo, semplicemente con un po’ di programmazione della scheda Arduino.

In questo post vedremo invece come utilizzare lo stesso identico circuito, formato da una scheda Arduino, un pulsante, un LED, un paio di resistori e un po’ di cavetti, per fare qualcosa di diverso.

Proprio in casi come questi diventa evidente come un microcontrollore è fondamentale per realizzare qualcosa di completamente nuovo, senza modificare di una virgola l’hardware, cioè il circuito.

Sembrerebbe una cosa ovvia per chi utilizza un PC, dove l’hardware resta sostanzialmente lo stesso, mentre i software utilizzati sono infiniti. Per un programmatore di software questo fatto è ancora più vero.

La differenza è che nel mondo Arduino possiamo cambiare facilmente anche l’hardware, in un continuo ribollire di idee e di esperimenti senza fine.

Ecco, quindi, che come ho scritto più sopra ripartiamo dallo stesso circuito del post precedente, per cui se volete potete dargli un’occhiata, giusto per rinfrescarvi la memoria.

Cosa possiamo realizzare con questo stesso circuito? Be’, fondamentalmente è una configurazione di componenti che può essere utile in tantissimi altri progetti, ma ecco l’idea: un “riflessometro” per misurare i vostri riflessi nel premere il pulsante, non appena si accende il LED.

Arduino non è velocissimo, rispetto a un PC, ma è ancora molto più veloce di una persona, tanto da poter misurare il tempo in millisecondi: più che sufficiente per il nostro esperimento di oggi.

Visto che l’hardware resta uguale a prima, vediamo come cambia il software, cioè lo sketch che dovete caricare nella scheda:

#define LED 8
#define PULSANTE 6
int premuto = 0;
long tempoPrecedente = 0;
long nuovoTempo = 0;

void setup() {
pinMode(LED, OUTPUT);
pinMode(PULSANTE, INPUT);
digitalWrite(LED, LOW);
Serial.begin(9600);
}

void loop() {
delay(5000);
digitalWrite(LED, HIGH);
tempoPrecedente = millis();
while (premuto == 0) {
premuto = digitalRead(PULSANTE);
if (premuto == HIGH) {
nuovoTempo = millis();
digitalWrite(LED, LOW);
}
}
premuto = 0;
Serial.print(“Tempo (ms): “);
Serial.println(nuovoTempo – tempoPrecedente);
}

Come potete vedere ci sono diverse cose che sono cambiate, a partire dalla prima parte, dove abbiamo messo la dichiarazione di alcune nuove variabili: tempoPrecedente e nuovoTempo che ci servono per misurare il tempo in millisecondi tra il momento in cui si accende il LED e il momento in cui premiamo il pulsante.

Dopo aver caricato lo sketch, aprite il Monitor Seriale per vedere cosa viene inviato sulla porta seriale quando premiamo il pulsante dopo l’accensione del LED.

Già in questo modo potete iniziare a divertirvi a migliorare i vostri riflessi, ma un tempo di attesa di 5 secondi fissi (5000 millisecondi) è abbastanza prevedibile per potersi preparare alla pressione del pulsante.

Rendiamo quindi le cose un po’ più difficili, aggiungendo una funzione di definizione “random” del tempo di attesa dell’accensione del LED. Ecco quindi la nuova versione:

#define LED 8
#define PULSANTE 6
int premuto = 0;
long tempoPrecedente = 0;
long nuovoTempo = 0;

void setup() {
   pinMode(LED, OUTPUT);
   pinMode(PULSANTE, INPUT);
   digitalWrite(LED, LOW);
   Serial.begin(9600);    randomSeed(24680); }
void loop() {
   delay(random(500,10000));
   digitalWrite(LED, HIGH);
   tempoPrecedente = millis();
   while (premuto == 0) {
     premuto = digitalRead(PULSANTE);
     if (premuto == HIGH) {
       nuovoTempo = millis();
       digitalWrite(LED, LOW);
     }
   }
   premuto = 0;
   Serial.print("Tempo (ms): ");
   Serial.println(nuovoTempo - tempoPrecedente); }

Potete vedere quali sono le modifiche apportate al codice precedente.

Prima di tutto abbiamo l’istruzione randomSeed(24680) che serve per inizializzare la sequenza di numeri “pseudo-casuali” (il numero utilizzato e il primo che mi è venuto in mente, voi potete mettere quello che volete).

L’istruzione delay(random(500,10000)) ha invece, al suo interno, la chiamata alla funzione random con il passaggio dei parametri: valore minimo e valore massimo (in millisecondi, quindi da mezzo secondo a 10 secondi).

A questo punto, caricate il codice nella scheda e poi divertitevi a misurare il vostro tempo di reazione! Winking smile

Nel prossimo post vedremo un altro modo, più semplice, per collegare un pulsante ad Arduino: cioè con la resistenza interna di pull-up.

Alla prossima “postata”… Open-mouthed smile

Arduino & C. – Il pulsante

Un pulsante è un tipo di interruttore meccanico temporaneo in cui abbiamo sostanzialmente due contatti e una molla.

Possono esserci due specie di pulsanti:

  • pulsante normalmente aperto (NO: normally open): nella posizione di riposo i contatti sono separati e quindi il circuito è aperto (non scorre corrente, quindi ha lo stato LOW), premendo il pulsante si attiva il contatto e si chiude il circuito (stato HIGH). Nel rilasciare di nuovo il pulsante, la molla spinge il pulsante verso l’alto e separa i contatti (stato LOW);
  • pulsante normalmente chiuso (NC: normally closed): nella posizione di riposo i contatti sono attaccati e quindi il circuito è chiuso (scorre corrente, stato HIGH), premendo il pulsante si disattiva il contatto e si apre il circuito (stato LOW). Nel rilasciare di nuovo il pulsante, la molla spinge il pulsante verso l’alto e unisce i contatti (stato HIGH). Forse è poco intuitivo il fatto che, premendo il pulsante, la tensione venga cambiata da HIGH a LOW  (premendo il pulsante togliamo l’alimentazione al circuito) ma i “giochi” si fanno nel codice dello sketch, dove possiamo cambiare completamente la logica del circuito.

Nel kit che ho acquistato ci sono 5 pulsanti normalmente aperti, quindi in stato di “riposo” non scorre corrente e lo stato è LOW.

Questo è un esempio di pulsante con il suo schema elettrico:

Pulsante


Il fatto che ci siano quattro terminali può confondere, ma come si vede dallo schema in realtà ci sono due sezioni con due piedini ciascuna.

La forma dei piedini aiuta a posizionare il pulsante sulla breadboard evitando così dei cortocircuiti. In particolare, possiamo posizionare il pulsante a cavallo del canale centrale, con l’angolo sporgente dei piedini rivolto verso l’alto e verso il basso. Nella seguente figura vi mostro la posizione e l’orientamento del pulsante (ovviamente il pulsante va premuto sulla breadboard per inserire i piedini nel fori, ma in questa immagine l’ho estratto dalla breadboard per vedere meglio l’orientamento).

WP_20170828_06_19_45_Pro

Cosa si può fare con un pulsante? Be’, parecchie cose… Lo possiamo considerare come un semplice sensore, anche se di tipo meccanico, perché rileva se il pulsante è premuto oppure se è in stato di riposo. E’ anche un dispositivo di input, perché lo possiamo premere in qualsiasi momento e attivare le funzionalità che abbiamo associato con la pressione del pulsante.

Per iniziare, proviamo a lavorare ancora con il classico LED, pilotato però dal pulsante: per realizzare questo esempio possiamo prendere l’esempio del LED e inserire il pulsante tra il resistore e il jumper che porta al pin di alimentazione, oppure possiamo inserirlo tra il led e il jumper che porta al pin GND o, ancora, tra il LED e il resistore. E’ assolutamente indifferente. Questo è il circuito:

Untitled Sketch_bb


Se premete il pulsante il LED si accende, quando rilasciate il pulsante il LED si spegne. Tutto bene, anche se non è molto agevole tenere accesa una luce rimanendo con il dito attaccato al pulsante… Inoltre questo circuito potrebbe essere realizzato anche senza utilizzare una scheda Arduino: basta una comune pila (ovviamente tenendo in considerazione i calcoli per dimensionare correttamente il resistore in base al voltaggio).

Non è un grosso problema, ma possiamo utilizzare questo circuito solo per fare quello per cui è stato costruito: il pulsante messo in serie con il LED vincola il passaggio di corrente e non ci consente di sfruttare il microcontrollore attraverso il software.

Per esempio, se volessimo fare in modo di far diventare questo interruttore temporaneo un interruttore permanente come potremmo fare? Con questo circuito non possiamo farlo, mentre il software di Arduino può fare molto per risolvere questo e molti altri problemi. Dobbiamo, infatti, trasformare una “programmazione elettrica” (cioè una “logica circuitale” o “logica hardware”) in una “programmazione software” o a microcontrollore (ovvero una “logica programmata”).

Per migliorare questa situazione dobbiamo fare due cose:

  • separare il circuito del LED dal circuito del pulsante
  • caricare uno sketch in grado di gestire il pulsante

Per quanto riguarda il circuito, ecco la nuova situazione:

Schema

Sembra complicato, ma in realtà potete vedere chiaramente che il circuito del LED è ora separato dal circuito del pulsante: sul lato sinistro abbiamo il LED e una resistenza da 220 Ohm, il tutto collegato a GND e al pin 8; sul lato destro abbiamo un pulsante collegato ai 5 Volt (alimentazione) e a massa attraverso un resistore da 10 kiloOhm. Dato che abbiamo anche bisogno di rilevare se il pulsante è premuto o rilasciato, abbiamo anche una connessione al pin 6.

Ora non resta che creare uno sketch adeguato al compito che ci siamo prefissati:

#define LED 8
#define PULSANTE 6
int premuto = 0;
int statoLED = 0;


void setup() {
   pinMode(LED, OUTPUT);
   pinMode(PULSANTE, INPUT);
   digitalWrite(LED, LOW);
   Serial.begin(9600);
}


void loop() {

   premuto = digitalRead(PULSANTE);
 
if (premuto == HIGH) {
    statoLED = 1 – statoLED;
    if (statoLED == 1) {
      digitalWrite(LED, HIGH);
      Serial.println(“LED acceso”);
    } else {
      digitalWrite(LED, LOW);
      Serial.println(“LED spento”);
    }
     delay(250);
 
}
}

In questo sketch ho prima di tutto definito gli identificatori LED e PULSANTE, associandoli al rispettivo pin di attivazione (8) o di rilevazione (6). Poi ho definito due variabili assegnando loro il valore iniziale zero: premuto per memorizzare la lettura dello stato del pulsante e statoLED per ricordare se il LED è acceso o spento.

Nella funzione setup() ho impostato la direzione di input o output dei due componenti, ho spento il LED nell’eventualità che fosse acceso e ho aperto il canale di comunicazione con la porta seriale indicando anche la velocità in baud (Serial.begin(9600)).

Nella funzione loop(), invece, ho prima di tutto letto lo stato fisico del pulsante, ottenendo zero se lo stato è LOW e 1 se è HIGH.

Subito dopo c’è un blocco condizionale (if) che verifica se il pulsante è stato premuto: se sì, viene modificata la variabile statoLED invertendone il valore. Questa variabile, secondo le mie intenzioni, deve avere solo due valori possibili: zero oppure 1. L’istruzione statoLED= 1 – statoLED non fa altro che invertire il valore tra i due valori possibili: se statoLEDera uguale a zero, 1-0 = 1 e quindi statoLED diventa 1, se statoLED era uguale a 1, 1-1 = 0 e quindi statoLED diventa 0. Semplice no?

A questo punto non mi resta che verificare se statoLED è uguale a 1, nel qual caso accendo il LED e scrivo nella porta seriale “LED acceso”; in caso contrario lo spengo e scrivo “LED spento”.

Alla fine ho inserito un’istruzione delay(250) per evitare che la pressione del pulsante venga interpretata più di una volta in modo ravvicinato, accendendo e spegnendo il LED in modo incontrollato. Infatti Arduino è più veloce della nostra capacità di premere e rilasciare istantaneamente il pulsante e quindi nel tempo in cui lo facciamo, seppur breve, Arduino legge più volte lo stato del pulsante e inverte ogni volta lo stato del LED. Un’attesa di 250 millisecondi dovrebbe risolvere questo problema (anche se voi potete volontariamente tenere premuto il pulsante per vedere il LED che lampeggia due volte al secondo (quattro cambi di stato: acceso, spento, acceso, spento).

Se provate a caricare lo sketch, vedrete che il tutto funziona proprio come previsto.

Per quanto riguarda la comunicazione con la porta seriale, ne parliamo meglio in un post specifico.

Bene, dopo aver visto l’utilizzo del pulsante, sia in modo diretto (elettrico), sia in modo programmato (software), chiudo qui e vi auguro un buon fine settimana!  Winking smile

Arduino & C. – Misurare con il multimetro digitale

In questo post inizierò a rispondere ad alcune domande che mi sono posto io stesso (anticipando forse le vostre domande) e cioè:

  1. perché ho scelto un resistore da 220 Ohm?
  2. come faccio a misurare la corrente che sta passando nel circuito?
  3. sono daltonico, non vedo bene i colori, come faccio a scegliere il resistore giusto?
  4. se ho un LED con due terminali della stessa lunghezza come capisco qual è l’ànodo e il càtodo?

Iniziamo dalla prima:

1. Perché ho scelto un resistore da 220 Ohm?

Bisogna fare un po’ di calcoli, utilizzando anche delle formule matematiche, anche se molto semplici.

Prima di tutto fissiamo alcuni valori (V = Volt; A=Ampère; mA=milli-Ampère cioè un millesimo di Ampère; Ohm o Ω è la misura di resistenza):

  • l’alimentazione di una scheda Arduino è solitamente di 5 V (può essere anche di 3.3 V, verificate!)
  • la corrente presente nel circuito non può normalmente superare i 20 mA (si potrebbe arrivare a 30-40 mA, ma si rischia di scaldare prima e di bruciare poi qualche componente)
  • un LED deve avere una corrente tra i 15 mA e i 20 mA
  • la caduta di tensione tra i terminali di un LED dipende dal suo colore. Normalmente si registrano questi valori di tensione: rosso = 1,8 V; giallo = 1,9 V; verde = 2,0 V; arancio = 2,0 V; bianco 3,0 V; blu = 3,5 V.

La formula fondamentale che mette in relazione tensione, resistenza e corrente è questa:

V = R * I

La formula che calcola la potenza (in senso fisico è il “lavoro” fatto dal sistema, ovvero il “consumo”) è questa:

P = V * I

cioè

P = R * I * I

(P = R * I^2)

Dato che sul circuito collegato ad Arduino non possiamo/vogliamo avere più di 20 mA, utilizziamo la formula fondamentale e la trasformiamo così:

R = V / I

Prendiamo ora i valori reali per un LED rosso e facciamo il calcolo:

R = (5 – 1,8) / 0,020 = 160 Ohm

Per un LED bianco, invece:

R = (5 – 3,0) / 0,020 = 100 Ohm

 

Commercialmente sono valori di resistori non disponibili, quindi potremmo utilizzare una resistenza da 180 Ohm o da 220 Ohm. Ovviamente più grande è il valore del resistore, più il LED apparirà meno luminoso, fino a spegnersi.

Certamente avrete notato che nel calcolo della resistenza abbiamo sottratto la tensione del LED alla tensione di alimentazione. In questo caso, avendo inserito nel circuito un LED che possiamo considerare come un secondo resistore, la formula diventa la seguente:

R = (Va – Vled) / I

Altra considerazione: perché prendiamo come tensione di alimentazione esattamente di 5 Volt? Come ho già detto, le schede Arduino sono alimentate a 5 V, tranne quelle che hanno un’alimentazione di 3,3 V (attenzione a fare i calcoli giusti!).

Se abbiamo qualche dubbio in merito, possiamo fare una misurazione più precisa con il multimetro digitale.

Come possiamo fare il calcolo della tensione? Procediamo in questo modo:

  1. stacchiamo l’alimentazione della scheda Arduino (cavo USB, o alimentatore, o pile): mai effettuare modifiche sulle connessioni con la scheda alimentata!
  2. togliamo tutto e lasciamo collegati due jumper (ponticelli o cavetti) sulla scheda: uno a GND e uno a uno dei pin (diciamo il numero 8)
  3. l’altra estremità dei due ponticelli non deve essere collegata
  4. prendiamo il multimetro digitale e colleghiamo il cavo nero a COM (cioè al “comune” o GND o “terra” o “massa”, vedete voi… sono tutti sinonimi); poi collegate il cavo rosso al connettore che riporta il simbolo V (Volt). Il voltaggio della scheda Arduino è basso, quindi non ci sono problemi, ma comunque il multimetro che ho io arriva a un massimo di 1000V in continua e 750V in alternata, quindi problemi zero. Se invece dovete misurare la corrente (Ampère) potreste avere connettori separati (come ho io) per correnti fino a 10A oppure per correnti più piccole (milli- o micro- Ampère) e quindi bisogna stare attenti…
  5. girate il selettore (di solito una “ruota” con tante indicazioni intorno, in base a tipo di misurazione e grandezza da misurare) e posizionatelo su Volt in corrente continua (indicato da una linea orizzontale diritta con sotto una linea tratteggiata), massimo 60V (6V potrebbe bastare, ma per prudenza usiamo un ordine di grandezza superiore)
  6. attaccate il cavo USB della scheda al PC per alimentarla (se la scheda ha ancora lo sketch precedente (quello con cui facevamo lampeggiare un LED), avremo una tensione che alternativamente va su e va giù, ma senza LED non lo vediamo, quindi misuriamo)
  7. con il puntale nero del multimetro tocchiamo il cavetto collegato a GND, poi con il puntale rosso tocchiamo l’altro cavetto collegato al PIN 8

Sul display del multimetro dovremmo vedere la misura che va da 0V a 4,98V e poi di nuovo a 0V e poi di nuovo 4,98V.

Per vedere la tensione stabile, carichiamo uno sketch che accenda stabilmente il PIN 8:


void setup() {
pinMode(13,OUTPUT);
digitalWrite(13,LOW);
pinMode(8, OUTPUT);
digitalWrite(8, HIGH);
}


void loop() {


}

Ora riproviamo a misurare la tensione: dopo una breve attesa, nel mio caso ho visto salire il valore a 4,99V e poi a 5,00V, quindi sono sicuro che la tensione è corretta.

Per poter toccare i cavetti con i puntali in modo stabile, senza avere un contatto incerto, potete utilizzare dei “coccodrilli”, cioè delle piccole pinze a coccodrillo come nell’immagine seguente:

coccodrilli

Se non avete pinze a coccodrillo, potete utilizzare uno dei seguenti trucchetti:

  • inserire le due estremità libere dei ponticelli in altrettanti fori della breadboard, facendo però attenzione di non inserire fino in fondo. Con il puntale potete poi toccare la parte di filo che sporge dal cavo e dalla breadboard, senza che questo “scappi via”.
  • in alternativa potete utilizzare delle mollette da bucato. Winking smile

 

2. Come faccio a misurare la corrente che sta passando nel circuito?

A proposito di misure: ma quanta corrente c’è in Arduino se non mettiamo alcun carico (come un LED)?

Riprendiamo il multimetro e cambiamo la posizione del connettore rosso: da V al simbolo di mA e poi spostiamo il selettore su A (di Ampère) a corrente continua, massimo 600m. Risultato = 85,5A.

Abbiamo la tensione (5V), abbiamo la corrente (85,5A), quindi possiamo misurare quanta resistenza c’è sul circuito. Applichiamo la formula  V = R * I, ovvero  R = V / I, cioè  R = 5 / 0,0855 = circa 58 Ohm.

3. Sono daltonico, non vedo bene i colori, come faccio a scegliere il resistore giusto?

Io non sono daltonico, ma anch’io ho qualche problema nell’identificare i colori, specialmente quando scuri: posso confondere il marrone con il verde scuro o con il grigio scuro e qualche volta con il blu scuro, a seconda della tonalità del colore stesso e della scarsa luminosità ambientale, quindi questo problema me lo sono subito posto anch’io.

Anche in questo caso la soluzione è il multimetro. Basta procedere nel seguente modo:

  1. mettere il connettore nero su COM (cioè a massa): va sempre lì, quindi non lo dirò più!  Winking smile
  2. mettere il connettore rosso sul simbolo di Ohm (cioè la lettera greca òmega)
  3. spostare il selettore sulla zona del simbolo degli Ohm (dato che parliamo di resistenze che vanno da 220 Ohm a valori anche di milioni di Ohm, cioè MOhm, possiamo provare con il valore 600 Ohm)
  4. prendiamo un terminale del resistore (staccato dal circuito!) e lo stringiamo con il puntale nero (con il dito, con un coccodrillo, con una molletta…)
  5. poi prendiamo l’altro terminale del resistore e lo stringiamo con il puntale rosso

Probabilmente bisogna lasciare un po’ di tempo al multimetro per assestarsi: nel mio caso, con un resistore da 220 Ohm, la misura è partita da circa 250 Ohm per poi scendere, prima velocemente e poi molto più lentamente, fino a 222 Ohm. Forse, attendendo ancora un po’, sarebbe arrivata vicino ai 220 Ohm dichiarati, ma non è troppo importante: 2 Ohm di differenza è una misura veramente piccola che non cambia la sostanza.

4. Se ho un LED con due terminali della stessa lunghezza come capisco qual è l’ànodo e il càtodo?

Normalmente i LED hanno l’ànodo più lungo del càtodo, proprio per poterli riconoscere subito. In qualche caso potrebbero essere della stessa lunghezza, perché magari sono stati tagliati per poter saldare il LED su di un circuito stampato. Come facciamo quindi a riconoscere i due terminali?

Questa operazione è molto semplice e possiamo utilizzare il seguente metodo: create un circuito come quello del mio post del 4 settembre 2017 e inviate lo sketch Blink (modificato per attivare il pin appropriato) alla scheda Arduino. Se il LED si accende, funziona ed è posizionato correttamente; se non si accende potrebbe essere bruciato (oppure è invertito, nel qual caso basta invertire il LED per verificare se funziona).

Una volta accertato in quale posizione funziona, sapete che il terminale collegato all’alimentazione è l’ànodo, mentre il terminale collegato a GND è il càtodo.

Per finire

Attenzione a utilizzare l’ordine di grandezza corretto nei calcoli:

  • nelle formule la tensione si indica in Volt (V): se sono (per esempio) milli-Volt bisogna convertire il valore in Volt
  • nelle formule la corrente si indica in Ampère (A): se sono (per esempio) milli-Ampère bisogna convertire il valore in Ampère
  • nelle formule la resistenza si indica in Ohm: se sono (per esempio) kilo-Ohm bisogna convertire il valore in Ohm

Ovviamente voi potreste avere dei valori leggermente diversi: va benissimo (se non sono MOLTO diversi), perché non è detto che i valori siano assolutamente precisi, l’importante è che siano abbastanza vicini e che teniate sempre presente i calcoli che abbiamo fatto in questo post per adattarli alla vostra situazione reale.

Buona misurazione!  Open-mouthed smile

Arduino & C. – Il LED

Nei miei post precedenti ho utilizzato il LED della scheda per fare qualche esempio di programmazione, ma la domanda potrebbe sorgere spontanea: che cos’è un LED?

Dal dizionario di Google leggiamo questa descrizione: “Diodo a semiconduttore che al passaggio di corrente elettrica emette radiazioni luminose, utilizzato come luce spia o, nei display, per formare caratteri luminosi.”.

Se cerchiamo in Wikipedia, invece, leggiamo questa introduzione: “In elettronica il LED (sigla inglese di Light Emitting Diode) o diodo a emissione di luce è un dispositivo optoelettronico che sfrutta la capacità di alcuni materiali semiconduttori di produrre fotoni attraverso un fenomeno di emissione spontanea. Questa si origina dalla ricombinazione di coppie elettrone-lacuna secondo il principio del diodo a giunzione, caratterizzato dalla presenza nel dispositivo di due zone drogate differentemente in modo da avere portatori di carica diversi.

Leggendo, si potrebbero fare diverse facili battute su alcuni termini: “radiazioni luminose” (… allora è radioattivo?), “luce spia” (… ci spiano!) e le “zone drogate” (… LED=LSD?). Tornando seri, vediamo come è fatto veramente un tipico LED e qual è il suo simbolo elettronico utilizzato negli schemi:

SchemaLED

 

SimboloLED

 

Come potete vedere il LED è un componente polarizzato: l’ànodo deve essere collegato al polo positivo e il càtodo al polo negativo. In un tipico LED, l’ànodo (+) si riconosce perché è il terminale più lungo mentre il càtodo è quello più corto (-). In sostanza il terminale più corto va collegato al pin GND (che sta per “ground”, ovvero “terra” o “massa”, identificato comunemente con il colore NERO per esempio nel cavo e nella presa del multimetro o nelle breadboard), mentre il terminale più lungo va collegato al pin di alimentazione o che emette una tensione (come i pin da 2 a 13 di un comune Arduino, solitamente identificato con il colore ROSSO, sempre nel cavo e nella presa del multimetro o in altre situazioni come nelle breadboard). Questo è un LED reale, dove potete vedere anche i due terminali, uno più lungo (ànodo +) e uno più corto (càtodo –):

led

 

Uno dei maggiori vantaggi dei LED è il basso consumo. Infatti, rispetto alle vecchie lampadine a incandescenza, le lampade a LED hanno la stessa resa in Lumen con un consumo in Watt molto inferiore:

ConsumoLED

“Bene, ora che abbiamo fatto un po’ di teoria, che cosa si fa ora?”, potreste chiedermi… Si fa ancora pratica, naturalmente.

Nei post precedenti abbiamo utilizzato il LED della scheda (identificato con la lettera “L”), ma non abbiamo ancora realizzato nulla, abbiamo solo provato il funzionamento della scheda e un po’ di programmazione.

Ora vediamo come si accende un LED esterno alla scheda e, per fare questo, utilizzeremo quanto segue:

  • una scheda Arduino o un suo clone
  • il cavo USB per collegare la scheda al PC
  • un LED colorato a vostro piacere (non dovete colorarlo voi, di solito si comprano già di un colore specifico!)
  • un resistore da 220 ohm
  • due ponticelli (indichiamo così i cavetti di connessione dalla scheda alla breadboard o tra un punto e l’altro della breadboard stessa)

Ecco il circuito che ho preparato: CircuitoLED1

 

… e questo è lo schema (più visibile) fatto con Fritzing:

 

CircuitoLED1b

 

Le connessioni mi sembrano piuttosto chiare e semplici. Nella simbologia Fritzing il LED ha un terminale diritto (càtodo –) e un terminale con una parte piegata (ànodo +): di conseguenza il terminale diritto l’abbiamo collegato a GND, mentre l’ànodo l’abbiamo collegato al PIN 8, ma passando attraverso un resistore da 220 ohm (controllate i colori se non ci credete…). Il resistore può essere inserito sul lato dell’ànodo o sul lato del càtodo, non importa, basta che ci sia, altrimenti un eccesso di corrente può bruciare il LED (che poi è da buttare).

Per far lampeggiare questo LED (che ora è spento) basta ricaricare lo sketch Blink e cambiare il PIN attivo:

#define LED 8

void setup() {

   pinMode(LED, OUTPUT);
}

void loop() {

   digitalWrite(LED, HIGH);
delay(1000);
digitalWrite(LED, LOW);
delay(1000);
}

Et voilà, abbiamo completato il nostro “Hello World” avanzato! (si fa per dire…). Questo è il risultato:

CircuitoLED1c

NOTA: se invertite il LED, cioè collegate l’ànodo alla massa e il catodo all’alimentazione, non succede nulla. Sì, intendo proprio dire che non succede nulla: non si guasta nulla, ma non si accende nemmeno il LED. Questo succede perché il LED è un diodo e quindi la corrente può scorrere solo in un verso, mentre l’altro verso è interdetto. Ecco spiegato anche il simbolo elettronico del LED (simile a quello del diodo): la freccia indica la direzione in cui scorre la corrente, indietro non si torna!

Nel prossimo post faremo un ulteriore approfondimento su come si fanno le misurazioni e come si può calcolare quale resistenza dobbiamo inserire nel circuito, ovvero: “perché abbiamo scelto un resistore da 220 ohm?”, ma anche “non ci capisco niente con il codice dei colori dei resistori, anche perché non si distinguono bene (magari per un problema di daltonismo ecc.), come faccio a usare il resistore giusto?”. Suggerimento: ci serve un multimetro.

Per questa volta abbiamo finito.

Buon lampeggiamento!  Winking smile

Arduino & C. – Codice Morse e stringhe

Qui i post aumentano e più si va avanti, più vengono nuove idee!

Bene, nel post precedente abbiamo messo un po’ di ordine nello sketch per visualizzare il segnali Morse di “SOS” con il LED della scheda. In questo post, invece, faremo qualcosa con le stringhe, dato che nel post precedente avevamo ipotizzato uno sketch un po’ più generico (lampeggiamento di un codice Morse corrispondente a una stringa).

Innanzi tutto per conoscere meglio il codice Morse potete guardare a questa pagina di Wikipedia: https://it.wikipedia.org/wiki/Codice_Morse.

Qui trovate una tabella con la parte principale della codifica, ma poi ci sono altri codici speciali che al momento non ci interessano.


CodiceMorse

Con questa tabella sarà semplicissimo codificare nel nostro sketch le lettere dell’alfabeto, ma per brevità ho inserito solo quelle che ci servono per questo esempio, cioè: “M”, “A”, “R”, “I” e “O” per comporre la parola “MARIO”:

void M() {
   linea();
   linea();
   delay(500);
   }

void A() {
   punto();
   linea();
   delay(500);
   }

void R() {
   punto();
   linea();
   punto();
   delay(500);
   }

void I() {
   punto();
   punto();
   delay(500);
   }

Ora potremmo anche ridefinire la funzione loop() in questo modo:

void loop() {
   // ritardo iniziale per non confonderci con il Blinker attivo
   // e per dividere due messaggi “SOS” tra loro
   delay(1000);

  // lettera “M” 
   M();

   // lettera “A”
   A();

  // lettera “R”
   R();

   // lettera “I”
   I();

  // lettera “O”
   O();

}

ma sarebbe banale e dispersivo, anche perché con parole o frasi più lunghe dovremmo di nuovo scrivere moltissime istruzioni in fila, una dietro l’altra.

Per migliorare anche questa situazione andiamo a vedere come creare una sorta di “funzione stringa” che ci potrà semplificare il compito nell’estrarre carattere per carattere da, appunto, una stringa:

  unsigned int i;
  String str = “MARIO”;
   unsigned int lunghezza = str.length();
   char val[lunghezza];
   String mystr = str;
   mystr.toCharArray(val,lunghezza);

Questo frammento di codice ci permette di prendere una stringa (str), a cui abbiamo assegnato un valore (“MARIO”), e di scomporla nei singoli caratteri da trattare poi con la parte che effettua il lampeggio in codice Morse con i segnali appropriati per ciascuna lettera. Il vettore contenente i singoli caratteri (char) è mystr, mentre l’accesso ai singoli elementi del vettore è fatto attraverso l’indice i, cioè con mystr[i].

#define LED 13


void setup() {
   pinMode(LED, OUTPUT);
   digitalWrite(LED,LOW);
   Serial.begin(9600);
}


// the loop function runs over and over again forever
void loop() {
   unsigned int i;
   String str = “MARIO”;
   unsigned int lunghezza = str.length();
   char val[lunghezza];
   String mystr = str;
   mystr.toCharArray(val,lunghezza);
   for (i=0;i<lunghezza;i++) {
     delay(1000); 
     switch (mystr[i]) {
       case ‘M’:
         M();
         break;
       case ‘A’:
         A();
         break;
       case ‘R’:
         R();
         break;
       case ‘I’:
         I();
         break;
       case ‘O’:
         O();
         break;
       default:
         //
       break;
     }
   }
   delay(1000);
}


void M() {
   linea();
   linea();
   delay(500);
}


void A() {
   punto();
   linea();
   delay(500);
}


void R() {
   punto();
   linea();
   punto();
   delay(500);
}


void I() {
   punto();
   punto();
   delay(500);
}


void O() {
   linea();
   linea();
   linea();
   delay(500);
}


void punto() {
   digitalWrite(LED, HIGH);
   delay(250);
   digitalWrite(LED, LOW);
   delay(250);
}


void linea() {
   digitalWrite(LED, HIGH);
   delay(500);
   digitalWrite(LED, LOW);
   delay(500);
}

Quando vedremo l’utilizzo della porta seriale per poter inviare una stringa dal PC alla scheda, sarà molto semplice modificare questo esempio e far lampeggiare qualsiasi segnale in codice Morse voi desideriate.

Alla prossima! Winking smile

Arduino & C. – Il LED lancia un “SOS”!

Nel post precedente abbiamo visto un programmino molto grezzo per lanciare un segnale di “SOS” in codice Morse con il LED della scheda.

Come abbiamo visto, è uno sketch piuttosto lungo (per quello che fa…), con molte istruzioni ripetute e poca chiarezza: un’altra persona non sarà subito in grado di capire lo scopo dello sketch e dovrà studiarlo un po’ prima di capirci qualcosa.

In questo post, quindi, ci prefiggiamo l’obiettivo di migliorare lo sketch, rendendolo molto più comprensibile, corto e magari con alcune parti riutilizzabili in altri sketch.

Cominciamo dalla funzione setup(): invece di utilizzare direttamente la costante LED_BUILTIN, possiamo definire una variabile di tipo int e di nome LED. A questa variabile assegniamo la costante LED_BUILTIN. Questa modifica ci permetterà di utilizzare il nome LED in tutti i punti del programma in cui era utilizzata la costante LED_BUILTIN, risparmiando un po’ di spazio (che non guasta). In più, se vogliamo sostituire la costante LED_BUILTIN con un diverso PIN, basterà modificare l’assegnazione alla variabile LED per cambiare l’impostazione in tutti i punti dello sketch.

void setup() {
   int LED = LED_BUILTIN;
   pinMode(LED, OUTPUT);
}

Un’altra modifica che possiamo fare è definire due subroutine di nome punto() e linea(), contenenti le istruzioni per fare un singolo lampeggiamento di durata adeguata:

void punto() {
   digitalWrite(LED, HIGH);
   delay(250);
   digitalWrite(LED, LOW);
   delay(250);
}


void linea() {
   digitalWrite(LED, HIGH);
   delay(500);
   digitalWrite(LED, LOW);
   delay(500);
}

A questo punto verrà quasi naturale di definire l’alfabeto Morse con i lampeggiamenti corretti. In questo esempio definiamo solo le lettere “S” e “O” che ci servono per il segnale “SOS”:

void S() {
   punto();
   punto();
   punto();
   delay(500);
}

void O() {
   linea();
   linea();
   linea();
   delay(500);
}

Be’, ormai è fatta, la funzione loop() ormai è ridotta ai minimi termini:

void loop() {
// ritardo iniziale per non confonderci con il Blinker attivo
// e per dividere due messaggi “SOS” tra loro


  delay(1000);

  // lettera “S”
   S();

// lettera “O”
   O();

  // lettera “S”
   S();

}

Che cosa ve ne pare?  Più semplice e comprensibile di così non si può!

Con lo sketch così strutturato possiamo facilmente estendere il nostro alfabeto Morse e creare le parole che vogliamo.

Ci sarebbe un ultimo passo da provare, cioè per esempio prendere in input una stringa dalla porta seriale e trasformarla in un messaggio in codice Morse, ma in questo momento non abbiamo ancora padronanza di altre funzioni disponibili che ci permettono di manipolare le stringhe. Ci penseremo più avanti.

Consiglio: cercate di riordinare lo sketch mettendo sempre setup() e loop() ai primi posti e poi tutte le altre funzioni più sotto. L’ordine è importante per non perdere l’orientamento…

Ecco lo sketch finale:

void setup() {
   int LED = LED_BUILTIN;
   pinMode(LED, OUTPUT);

}

void loop() {
// ritardo iniziale per non confonderci con il Blinker attivo
// e per dividere due messaggi “SOS” tra loro
delay(1000);

  // lettera “S”

  S();

  // lettera “O”
   O();

  // lettera “S”

  S();

}

void punto() {

  digitalWrite(LED_BUILTIN, HIGH);
   delay(250);
   digitalWrite(LED_BUILTIN, LOW);
   delay(250);

}

void linea() {
   digitalWrite(LED_BUILTIN, HIGH);
   delay(500);
   digitalWrite(LED_BUILTIN, LOW);
   delay(500);

}

void S() {

  punto();
   punto();
   punto();
   delay(500);
}

void O() {

  linea();
   linea();
   linea();
   delay(500);
}

Caricatelo sulla scheda e provatelo: in caso di emergenza questo sketch potrebbe salvarvi!  Winking smile

Good coding!

Visual Studio 2017 versione 15.4 (Preview)

La versione 15.3 è durata veramente poco e sta già arrivando la versione 15.4: https://blogs.msdn.microsoft.com/visualstudio/2017/08/25/visual-studio-2017-version-15-4-preview/

Una novità che mi ha subito colpito positivamente è il fatto che ci sarà un nuovo template tra i progetti: serve per pacchettizzare una normale applicazione .NET (o C++) di tipo Windows Desktop all’interno di un pacchetto .appx per poterla pubblicare più facilmente sul Microsoft Store!

Non vedo l’ora di provare questa funzionalità… Ma devo aspettare il rilascio dell’update di Windows (“Windows Fall Creators Update”) e preferisco non installare una preview.

Per le altre novità date un’occhiata al blog post del team di Visual Studio che ho riportato all’inizio di questo post.

Happy coding! Winking smile