Archivi categoria: VS 2017

Una grande novità che mi rende felice!

Bene, ora posso dirlo: dopo la chiusura della rivista ioProgrammo (mi è dispiaciuto molto della perdita di questo ultimo baluardo cartaceo italiano della programmazione generalista, dovuto probabilmente a una gestione poco accorta) e dopo aver trascorso questi mesi un po’ bloggando, un po’ studiando (MOLTO studiando!), un po’ navigando in Internet alla ricerca di nuovi lidi, ora ho trovato un nuovo “porto” dove sfogare la mia creatività!

Vi annuncio quindi che ieri ho firmato il contratto di collaborazione con Futura Group, editrice tra l’altro della rivista “ELETTRONICA IN”, una realtà italiana che esiste ormai da qualche decennio e che secondo me fa un egregio lavoro nell’ambito dell’elettronica, ma anche della programmazione, seppure orientata ai sistemi elettronici, alle schede con microcontroller (per esempio Arduino e Raspberry) e ora anche IoT.


image

image


Io mi dedicherò a “progetti misti” di “elettronica didattica” + programmazione, con qualche progettino interessante.

Nel tempo farò uso di schede Arduino e Raspberry, di componenti e sensori di vario genere, di ambienti di sviluppo dedicati o di Visual Studio, di Windows IoT Core e magari anche del cloud Azure: di idee ce ne sono tante, mi serve solo un po’ di tempo per metterle in ordine e svilupparle.

Ringrazio di cuore chi mi ha dato fiducia, rispondendo immediatamente alla mia candidatura e fornendomi tutte le informazioni necessarie per iniziare questa nuova avventura. Spero di non deludere le vostre aspettative!

A presto! Winking smile

Nuova modalità di aggiornamento di Visual Studio 2017

Come ormai sarà noto a quasi tutti quelli di voi che utilizzano Visual Studio 2017 per sviluppare applicazioni, da un po’ di tempo in qua gli aggiornamenti di Visual Studio 2017 sono diventati molto ma molto più frequenti che in passato.

Pur trattandosi sempre di Visual Studio 2017, le versioni si susseguono ormai molto rapidamente, anche dopo 2-3 giorni dal rilascio precedente: ora siamo alla versione 15.6.4 (vi ricordo che Visual Studio 2017 è anche, in codice, Visual Studio “15”), ma la prossima settimana potremmo fare un nuovo balzo in avanti di una o due versioni.

Questi rilasci così frequenti servono a correggere i molti bug che necessariamente un’applicazione così complessa introduce nella sua miriade di componenti, di moduli e di elementi di ogni genere.

Ogni tanto c’è anche qualche nuova caratteristica che ci semplifica la vita: per esempio, di recente è cambiato qualcosa nell’installer del prodotto. Infatti, avviando l’installer per effettuare un nuovo aggiornamento, appare una schermata come questa:


image


Come potete vedere sono indicate la versione correntemente installata e la nuova versione che sarà installata con l’upgrade.

L’aspetto interessante è che potete cliccare su Update Now senza chiudere il lavoro sulla soluzione che avete aperto: come indicato nell’avviso che vedete nella parte inferiore della finestra, “Visual Studio salverà il vostro lavoro, si chiuderà e si riaprirà.”, tutto questo automaticamente, senza che voi dobbiate preoccuparvi di nulla.

Una volta cliccato sul pulsante Update Now, apparirà un’altra finestra come questa:


image


Questa finestra avvierà effettivamente l’aggiornamento di Visual Studio, fornendovi le indicazioni della progressione dell’installazione e avvisandovi anche che Visual Studio sarà riavviato automaticamente dopo il completamento.

Un’altra comoda caratteristica di Visual Studio! Ne sentivamo la mancanza? Forse no, ma visto che c’è, non mi sembra nemmeno una brutta cosa!

Happy coding!  Winking smile

Windows Remote Arduino e Visual Studio 2017

Se siete interessati al mondo IoT (Internet of Things) e avete acquistato un microcontroller per fare qualche esperimento pratico e magari per realizzare qualche progetto trovato sulla Rete, prima o poi avrete la necessità di controllare il vostro dispositivo da remoto. È facile immaginare alcune applicazioni utili per voi e la vostra famiglia: apertura di portoni e cancelli con uno smartphone, sorveglianza di ambienti anche da remoto, telecontrollo e telesoccorso, domotica (controllo del riscaldamento, irrigazione del giardino, accensione e spegnimento di luci…) e molte altre soluzioni, il cui unico limite è l’immaginazione.

Le opzioni non mancano: infatti possiamo scegliere tra varie possibilità, tra le quali Windows Remote Arduino, Virtual Shields per Arduino e anche Arduino Wiring per Windows 10 IoT Core. Alcune di queste soluzioni sono utilizzabili anche o preferibilmente con Raspberry, ma per questa scheda (dovremmo forse dire mini PC) abbiamo un’ampia gamma di altre soluzioni che passano anche per Raspbian (la distribuzione Linux dedicata a Raspberry) e per Python. Si tratta solo di capire da dove iniziare, perché non c’è ancora una documentazione sufficiente su questi strumenti e quindi chi si avvicina per la prima volta può rimanerne un po’ disorientato.

In questo articolo cercheremo di fare un po’ di chiarezza in un ambito ben preciso: infatti utilizzeremo una scheda Arduino UNO perché probabilmente è quella più diffusa e poi anche perché la libreria Windows Remote Arduino, come purtroppo anche altre librerie, non funziona con Arduino Mega 2560. In prima battuta utilizzeremo direttamente l’applicazione Windows Remote Arduino Experience per Windows 10 per pilotare manualmente dei LED collegati alla scheda. In seguito proveremo a sviluppare un’applicazione con Visual Studio 2017 per avere maggiore flessibilità e maggiore controllo sull’accensione dei LED o su qualsiasi cosa che potrebbe essere collegata alla scheda. La prima accortezza che bisogna avere, comune a tutti i tool, è quella di aver aggiornato il sistema operativo all’ultima build di Windows 10.

Windows Remote Arduino

Per la prima prova predisponiamo il nostro progetto sulla scheda Arduino: l’obiettivo che ci accingiamo di raggiungere è quello di realizzare un sistema per accendere alcuni LED, simulando un controllo a distanza dell’illuminazione di alcuni locali.

Per realizzare questo progetto, colleghiamo dieci LED ai pin dal 3 al 12, con altrettanti resistori da 220 Ω, come potete vedere dalla Fig.1. Il pin 13 è già collegato al LED interno alla scheda, mentre non bisogna mai utilizzare i pin 0 e 1 dedicati alla comunicazione via seriale; il pin 2 resta libero.


Immagine01

Fig. 1 – La realizzazione del modello di sistema di illuminazione comandato da remoto.


Con la libreria open source Windows Remote Arduino possiamo controllare una scheda Arduino per mezzo di connessioni via USB, Bluetooth, Ethernet e Wi-fi e, in particolare, possiamo attivare o disattivare pin digitali e analogici, ma anche ricevere eventi, quando i sensori si accorgono che è successo qualcosa. Naturalmente dipende da quali sensori sono presenti.

Per utilizzare Windows Remote Arduino abbiamo tre possibilità che vi elenchiamo, da quella più semplice a quella più complessa:

1. utilizzare l’app gratuita Windows Remote Arduino Experience;

2. creare un progetto Visual Studio 2017 installando un pacchetto NuGet;

3. aggiungere manualmente i file di Windows Remote Arduino a una soluzione Visual Studio 2017.

Come abbiamo già anticipato, esamineremo in dettaglio solo le prime due opzioni, perché la terza è un po’ più complessa e richiede un articolo tutto per sé.


Metodo 1: App gratuita Windows Remote Arduino Experience

Potete scaricare e installare l’applicazione dallo Store di Microsoft cercando il nome completo della stessa oppure visitando la seguente pagina informativa sul web: http://bit.ly/winremotearduinoexperience. Prima di poter utilizzare questa applicazione, però, dovete preparare Arduino in modo che sia pronto per comunicare in remoto. Per mantenere semplice il progetto utilizzeremo la connessione USB impostandola come segue:

1) collegate Arduino UNO al PC via cavo USB;

2) avviate l’IDE di Arduino (se non l’avete ancora installato, scaricatelo da arduino.cc);

3) verificate che nell’IDE siano impostati correttamente la porta COM e la scheda;

4) aprite il menu File > Esempi > Firmata e cliccate sullo sketch StandardFirmata;

5) caricate lo sketch nella scheda cliccando sull’apposito pulsante Carica;

6) avviate l’applicazione Windows Remote Arduino Experience installata in precedenza: apparirà una finestra simile a quella mostrata nella Fig.2.


Immagine02

Fig.2: L’applicazione Windows Remote Arduino Experience prima della connessione alla scheda.


Con la scheda Arduino collegata alla porta USB, selezionate la voce Connection impostandola a USB e scegliete il baud rate appropriato (deve essere uguale al valore del baud rate inserito nello scketch StandardFirmata). Se la sezione Devices discovered riporta la dicitura “No items found.” oppure riporta alcune porte USB ma senza l’indicazione della porta a cui abbiamo collegato Arduino, cliccate sul pulsante Refresh: con questa operazione dovrebbe apparire la scritta Arduino Uno (COMx), dove “x” è il numero della porta COM associata alla porta USB. Selezionate la riga con tale indicazione e poi cliccate sul pulsante Connect.

A questo punto dovreste poter gestire in remoto la scheda Arduino, ma potrebbe esserci qualche problema con il baud rate, cioè la velocità di comunicazione. Se la connessione non funziona, verificate che la velocità impostata nello sketch StandardFirmata corrisponda con la velocità del dispositivo di comunicazione che avete collegato: lo trovate cercando nello sketch l’istruzione Firmata.begin(<baud rate>). Se modificate il baud rate di StandardFirmata, poi dovrete caricare di nuovo lo sketch sulla scheda; in alternativa potete impostare il baud rate di Windows Remote Arduino Experience allo stesso valore, l’importante è che i due valori siano uguali. Se è stato fatto tutto correttamente, dopo pochi istanti dovrebbe apparire la finestra che potete vedere nella Fig.3.


Immagine03

Fig. 3 – La scheda Digital con i pin digitali da 0 a 13 e da A0 ad A5.


Se ora provate a cliccare sugli interruttori di destra (che riportano la tensione 0V), nei numeri da 3 a 13, vedrete accendere i LED corrispondenti e vedrete che sarà riportata la tensione di 5V; cliccando di nuovo lo stesso interruttore sarà abbassata la tensione, spegnendo il LED. Gli interruttori di sinistra, invece, servono per indicare la direzione verso la quale deve lavorare il pin corrispondente: in input o in output. Per esempio, per accendere un LED bisogna attivare il pin in output, mentre per leggere un sensore (per esempio un DHT11 per rilevare la temperatura ambientale), bisognerà impostare il pin in input.

Forse avrete notato che ci sono anche altre schede: la scheda Analog con i pin analogici da A0 ad A5 e la scheda PWM con i pin 3, 5, 6, 9, 10 e 11. I pin da A0 ad A5 appaiono sia nella scheda Digital, sia nella scheda Analog, perché possono essere attivati in entrambe le modalità. Ovviamente se vengono attivati in modalità digitale potranno avere solo i valori 0V o 5V, mentre in modalità analogica non possono essere attivati in modalità di output, potendo solo leggere valori discreti corrispondenti ai valori intermedi tra 0 e 5 Volt.

Per quanto riguarda la scheda PWM possiamo notare una curiosità: se attiviamo uno dei sei pin, abbiamo a disposizione una barra di scorrimento con la quale possiamo accendere i LED collegati ai pin stessi, con gradazioni di luminosità crescente da 0 a 5 V.


Metodo 2: Applicazione Visual Studio 2017 e NuGet

Il secondo metodo è più adatto ai programmatori, dato che permette di realizzare con Visual Studio 2017 un’applicazione in grado di connettersi alla scheda Arduino. Nell’esempio noi opteremo ancora per la connessione via USB, ma anche in questo caso sono disponibili le connessioni via Bluetooth o rete Ethernet/WiFi. Procedete come segue:

1. aprite Visual Studio 2017 e create un nuovo progetto dal menu File > New > Project;

2. tra i template di Visual Basic selezionate Windows Universal > Blank App (Universal Windows), modificate il nome del progetto in “WRA” (cambierà automaticamente anche il nome della soluzione) e, se lo desiderate, cambiate la cartella di destinazione della soluzione, poi confermate cliccando sul pulsante OK (Fig.4).


Immagine04

Fig.4: Creazione della soluzione Visual Basic in Visual Studio 2017.


3. Apparirà una finestra di selezione della versione minima e massima di Windows 10 che devono essere supportate dall’applicazione UWP: modificate questi valori solo se necessario e confermate con OK.

Non appena sarà creata l’applicazione vuota, procedete in questo modo per aggiungere la libreria da NuGet:

4. selezionate il menu Tools > NuGet Package Manager > Package Manager Console;

5. nella Console di NuGet digitate il seguente comando e confermate con un invio:


Install-package Windows-Remote-Arduino


Pochi secondi dopo lo scorrimento di varie scritte sulla Console vedrete terminare l’installazione e, se sarà andato tutto come previsto, dovrebbe essere apparsa anche la riga seguente:


Successfully installed ‘Windows-Remote-Arduino 1.4.0’ to WRA


Inoltre, nella finestra Solution Explorer dovrebbe essere apparsa la voce Windows-Remote-Arduino nel nodo References (Fig.5).


Immagine05

Fig.5: Il riferimento a Windows-Remote-Arduino nella finestra Solution Explorer.


A questo punto dobbiamo modificare il codice che ci serve per modificare lo stato dei LED.

6. Aprite il file MainPage.xaml.vb e all’inizio del codice inserite le seguenti dichiarazioni per importare le funzioni della libreria Windows Remote Arduino:


Imports Microsoft.Maker.RemoteWiring

Imports Microsoft.Maker.Serial


7. Appena prima della dichiarazione del metodo New() inserite le seguenti dichiarazioni di variabili:


Dim connection As UsbSerial

Dim arduino As RemoteDevice


8. Nel metodo New(), dopo l’istruzione InitializeComponent(), inserite il seguente codice:


connection = New UsbSerial(“VID_2A03”, “PID_0043”)

arduino = New RemoteDevice(connection)

AddHandler connection.ConnectionEstablished, AddressOf OnConnectionEstablished

connection.begin(57600, Microsoft.Maker.Serial.SerialConfig.SERIAL_8N1)


La prima istruzione definisce un nuovo oggetto di tipo UsbSerial, passandogli due parametri: “VID_2A03” e “PID_0043”. Questi due parametri non sono sempre uguali, dipendono dalla configurazione sul vostro PC. Per rilevare quali sono i vostri parametri, premete la combinazione di tasti “Windows”+X, selezionate Gestione dispositivi, espandete il nodo Porte (COM e LPT) e trovate la porta di comunicazione (COMx) di Arduino UNO. Cliccate sul nome della porta con il tasto destro del mouse e selezionate Proprietà: nella finestra delle proprietà passate alla scheda Eventi, dove potrete vedere i due parametri nel riquadro Informazioni. I due parametri sono concatenati ad altre informazioni in una unica stringa, ma sono facilmente identificabili (Fig.6).


Immagine06

Fig.6: La finestra delle proprietà della porta COM collegata ad Arduino.


La seconda istruzione crea un oggetto di tipo RemoteDevice per avviare la connessione al dispositivo. La terza istruzione aggiunge un gestore di evento secondo lo schema


AddHandler evento, AddressOf nome_subroutine


dove in questo caso l’evento che viene rilevato è quello che scatta quando viene stabilita la connessione al dispositivo, mentre il nome_subroutine indica il metodo Sub che viene invocato al verificarsi dell’evento stesso.

La quarta istruzione avvia effettivamente la connessione, indicando il baud rate e la modalità di comunicazione: SERIAL_8N1 indica una comunicazione seriale, con (8) bit di dati, (N)essun bit di parità e (1) bit di stop.

9. Ora dobbiamo creare il metodo OnConnectionEstablished() per gestire l’evento di avvenuta connessione e quindi scriviamo quanto segue:


Private Sub OnConnectionEstablished()

   Dim action = Dispatcher.RunAsync(

      Windows.UI.Core.CoreDispatcherPriority.Normal,

      New Windows.UI.Core.DispatchedHandler(

         Sub()

            OnButton.IsEnabled = True

         End Sub))

End Sub


Utilizziamo quindi un Dispatcher in asincrono per abilitare il pulsante OnButton che così potrà essere premuto per accendere un LED. Ovviamente le istruzioni che potete inserire all’interno del blocco Sub() … End Sub possono essere le più varie, per eseguire qualsiasi funzione che abbiate deciso.

10. Nella fase di scrittura del codice vedrete che OnButton non viene riconosciuto. Il motivo è ovvio: non abbiamo ancora creato i pulsanti nell’interfaccia utente. Aprite il file MainPage.xaml e inserite tre pulsanti, ai quali darete i nomi OnButton (descrizione “On”), OffButton (descrizione “Off”) e Sequence (descrizione “Sequenza”). Eseguite un doppio-click su ogni pulsante e inserite il seguente codice:


Private Sub OnButton_Click(sender As Object, e As RoutedEventArgs) Handles OnButton.Click

   Dim i As Byte

   For i = 3 To 13

      arduino.digitalWrite(i, PinState.HIGH)

   Next

End Sub

Private Sub OffButton_Click(sender As Object, e As RoutedEventArgs) Handles OffButton.Click

   Dim i As Byte

   For i = 3 To 13

      arduino.digitalWrite(i, PinState.LOW)

   Next

End Sub

Private Sub Sequence_Click(sender As Object, e As RoutedEventArgs) Handles Sequence.Click

   Dim i, j As Byte

   ‘ CICLO di accensione/spegnimento alternati

   For j = 1 To 10

      For i = 3 To 13 Step 2

         arduino.digitalWrite(i, PinState.HIGH)

      Next

      For i = 4 To 12 Step 2

         arduino.digitalWrite(i, PinState.LOW)

      Next

      Task.Delay(250).Wait()

      For i = 3 To 13 Step 2

         arduino.digitalWrite(i, PinState.LOW)

      Next

      For i = 4 To 12 Step 2

         arduino.digitalWrite(i, PinState.HIGH)

      Next

      Task.Delay(250).Wait()

   Next

   ‘ spegnimento di tutti i LED

   For i = 3 To 13

      arduino.digitalWrite(i, PinState.LOW)

   Next

End Sub


Questo codice è molto semplice da comprendere e ricalca anche la struttura di un ipotetico sketch caricato sulla scheda Arduino, quindi non riteniamo necessario dare ulteriori specifiche. L’unica particolarità degna di nota è l’utilizzo dell’istruzione Task.Delay(250).Wait() anziché di Thread.Sleep. Trattandosi di un’applicazione UWP non possiamo utilizzare quest’ultimo e quindi dobbiamo optare per l’oggetto Task per ottenere un tempo di attesa di 250 millisecondi: in caso contrario non vedremmo lampeggiare i LED, ma li vedremmo accesi solo per un istante, prima dello spegnimento completo.

11. L’ultima modifica che dobbiamo apportare è quella al file di manifesto, Package.appxmanifest, precisamente nella sezione <Capabilities>:


<Capabilities>

   <Capability Name=”internetClient” />

   <DeviceCapability Name=”serialcommunication”>

      <Device Id=”any”>

         <Function Type=”name:serialPort”/>

      </Device>

   </DeviceCapability>

</Capabilities>


In questo modo avremo aggiunto l’abilitazione all’utilizzo del dispositivo sulla porta seriale.

L’applicazione finale, molto semplice, è visibile nella Fig.7.


Immagine07

Fig.7: L’applicazione WRA in fase di esecuzione.


Il gestore dell’evento Click del pulsante OnButton accende tutti i LED, mentre quello del pulsante OffButton li spegne tutti. Invece, l’evento Click del pulsante Sequence accende e spegne dieci volte i LED, alternandoli tra di loro.


Conclusione

In questo articolo abbiamo visto l’utilizzo di Windows Remote Arduino Experience, sia con un’interfaccia fornita da una app distribuita via Microsoft Store (per Windows 10), sia con una applicazione creata con Visual Studio 2017.

Quest’ultima opzione è estremamente interessante perché è molto più flessibile e ci consente di agire sulla scheda remota e di leggere i valori rilevati dai pin della scheda, premessa importante per realizzare le nostre soluzioni IoT nel modo migliore.

Aggiornamento alla versione 15.5.6 di Visual Studio 2017

Eccoci alla versione 15.5.6 di Visual Studio 2017: gli aggiornamenti non sono mai stati così frequenti come in questi ultimi mesi!

Sicuramente un vantaggio per chi aspetta la correzione di una caratteristica malfunzionante, ma anche una preoccupazione e talvolta un fastidio per chi vorrebbe aggiornamenti meno frequenti e versioni più stabili nel tempo.

Ovviamente non si può avere tutto e quindi ci prendiamo il nostro tempo per aggiornare VS 2017, magari quando stiamo facendo qualcos’altro.

Il nuovo aggiornamento ha una piccola ma interessante novità: avviandolo, come sempre partirà l’installer che ormai conosciamo bene e che ci aiuta a gestire aggiornamenti, aggiunte e rimozioni di caratteristiche di Visual Studio. Questa volta, però, vedrete apparire questa nuova finestra:


image


La finestra spiega in modo chiaro qual è la sua funzione: possiamo chiudere l’istanza di Visual Studio e premere il pulsante Riprova, oppure possiamo cliccare su Continua e in tal caso sarà l’installer a preoccuparsi di salvare lo stato dei processi, a chiuderli e poi a ripristinarli con lo stato precedente, al termine dell’installazione. Decisamente utile e comodo.

Buon aggiornamento!  Winking smile

Ora sì! Installiamo l’aggiornamento 1801.27 dell’add-in "Arduino for Visual Studio" di Visual Micro

A quanto pare ci siamo!

In un mio post del 17 gennaio avevo scritto di non installare l’aggiornamento di Visual Micro dell’add-in “Arduino for Visual Studio”: infatti la documentazione ufficiale riportava le note di rilascio con il testo barrato e quindi non era dato sapere se l’aggiornamento fosse funzionante o se introducesse ulteriori problemi. Io l’avevo installato per un breve test e tutto sembrava funzionare ma…

Avviando Visual Studio 2017 vedrete apparire un messaggio di avvertimento sulla possibilità di aggiornare l’add-in:

2018-01-28_11-51-52

Potete scaricare il nuovo aggiornamento dalla pagina ufficiale, oppure utilizzare la finestra Notifications di Visual Studio 2017: in ogni caso vi consiglio di fare questo aggiornamento, non si sa mai.

Nell’aggiornamento sono inclusi i soliti bug fix, ma anche qualche caratteristica in più:


Release 1801.27 – 27th Jan 2018 – Visual Studio 2012-2017

  • Workaround Visual Studio VSIX bug that suddenly refuses to include newtonsoft.json dll in the VSIX. This is the reason the last release was retracted.
  • Copy sub folders when copying/cloning library examples
  • Support the creation of projects with name containing period (dot)
  • Allow libraries to compile even if they specify an incompatible architecture= in the library.properties settings. Many libraries specify only “avr” when they actually do work with other architectures. The supposedly incompatible libraries will not be displayed on “Add Library” menus but adding #includes will enable intellisense and compile.
  • Add clearer messages when library headers can not be resolved.
  • Code efficiency: Prevent various internal code exceptions with better validation
  • Fix: Upload failed for Boards that did not use a programmer or a com/ip port to upload when a user had never previously connected a COM port whilst using Visual Micro.
  • Fix: Certain STM32 cores (any core that included both a wpogram.h and an arduino.h) would fail to compile. Visual Micro will now use the “arduino.h” if it exists in preference to the “wprogram.h”. This applies to the automatic #include created in the temp folder during compilation. If neither file exists in the core folder then the “arduino.h” is #included (and would be expected to be resolved via the automatically discovered include paths).
  • NB: Visual Micro uses the standard C# SerialPort object in the serial monitor. Some USB/Serial drivers are specified for Windows10 Universal only will fail with C# in WinXp, Win7, Win8 and Win10. Confusingly the arduino ide java serial access works better with Win10 universal drivers than Microsoft’s own C# serial port object! Rule of thumb is use the correct driver for the OpSys that you are using.
  • Improved intellisense for SAMD boards (_asm_(x) and _Pragma(x))
  • Free Use: To keep support to a minimum, unlicenced users must update this software before Feb 2019


Buona installazione! Winking smile

Rispondo alla richiesta di un lettore…

Un mio lettore mi ha inviato un’e-mail con una serie di domande … visto che ogni tanto capita che ci siano delle domande ricorrenti sull’acquisto di Visual Studio, su un mio libro introvabile, sull’eventualità che io scriva e pubblichi altri libri, su consigli di altri libri sullo stesso argomento per principianti e così via, ho pensato di pubblicare la mia risposta (chiaramente senza nome del destinatario) in modo da aiutare chiunque avesse gli stessi problemi. Spero che vi possa essere utile! Winking smile


Buonasera …

Prima di rispondere alle domande, vorrei segnalare che non è necessario acquistare la licenza di Visual Studio 2017: infatti da un po’ di tempo (non ricordo se dalla versione 2013 o dalla 2015) esiste “Visual Studio Community 2017”, equivalente in tutto e per tutto alla versione Professional di Visual Studio 2017. Manca qualcosa che serve solo ai team di sviluppo e che quindi non è significativo per gli sviluppatori individuali, quindi può tranquillamente installarlo “a tempo indeterminato”, con licenza che autorizza anche alla produzione di applicazioni destinate alla vendita, quindi non ci sono problemi. Unica accortezza è che non può essere utilizzato da gruppi di oltre 5 sviluppatori oppure all’interno di aziende di medio-grande dimensione (il riferimento se non sbaglio è a 1.000.000 di dollari di fatturato). Per scaricarlo può utilizzare questo link: https://www.visualstudio.com/it/thank-you-downloading-visual-studio/?sku=Community&rel=15.

Per quanto riguarda il mio libro “Visual Basic 2010 spiegato a mia nonna”, è un “tomo” di circa 800 pagine che inizia praticamente dal “livello zero” della programmazione per poi andare gradualmente in crescita, sia per impegno che per difficoltà, fino a un livello medio-avanzato. Leggendo con attenzione i capitoli iniziali e sperimentando in prima persona i programmi sono sicuro che si può raggiungere un livello soddisfacente di autonomia, anche per chi parte da zero.

Il libro in versione cartacea è ormai quasi introvabile, qualche volta vedo che ci sono singoli “resi” all’editore, quindi periodicamente si potrebbe provare a contattarli per vedere se ne è tornato indietro almeno uno. In alternativa è sempre possibile acquistare il libro in versione “ebook”, cioè digitale. Può essere una soluzione per risparmiare qualcosa, anche se io stesso avrei un po’ di difficoltà a leggere a lungo un libro sullo schermo di un PC… con un Kindle potrebbe andare meglio, la versione Kindle è acquistabile da Amazon qui: https://www.amazon.it/Visual-Basic-2010-spiegato-nonna-ebook/dp/B006B1Y6XO. Come vedrà ci sono commenti discordanti: per qualcuno è troppo difficile, per qualcun altro è adatto ai principianti… la valutazione è assolutamente personale ed è difficile affermare con certezza una cosa o l’altra perché dipende anche dall’impegno e dalla costanza che ci si mette e dalle conoscenze acquisite in precedenza.

Nel 2017 avevo ipotizzato di scrivere una versione aggiornata del libro con un nuovo editore (LSWR.it) … senza la nonna, perché il ramo d’azienda è stato acquistato appunto da LSWR.it dove non sono più interessati a questa tipologia di testo (cioè alla nonna!). Con loro ho pubblicato il mio nuovo libro su SQL Server 2016 che però non ha avuto fortuna come i libri precedenti e quindi ho deciso di rinunciare. Non ha senso lavorare un anno per poi raccogliere poco più che “spiccioli”, non so se mi spiego. In futuro non si può mai dire, è possibile che io riveda il testo e lo pubblichi in autonomia su Amazon.it, in modo da avere io qualche guadagno in più e di ridurre il costo del libro per il lettore che lo acquista. Sto anche cercando di sperimentare una applicazione per Microsoft Store, destinata ai PC desktop o portatili con Windows 10, ma il progetto è ancora in corso.

Libri alternativi ne conosco, ma la stragrande maggioranza è in lingua inglese. Per l’Italia io “mi sono ritirato”, l’amico Francesco Balena anche (per gli stessi miei motivi)… gli unici che resistono sono quelli del gruppo di ASPItalia.com che periodicamente escono con un libro scritto in più programmatori, come questo libro su Visual Basic 2015 scritto da ben 6 programmatori: https://www.amazon.it/Visual-basic-2015-completa-sviluppatore/dp/8820371006. Anche in questo caso non mi risulta che sia uscita la versione 2017. Non so se ci stanno lavorando o se hanno rinunciato anche loro, considerato che Visual Studio ormai cambia troppo velocemente: non si fa in tempo a finire di scrivere un libro che esce la nuova versione!

C’è però da dire che per quanto riguarda le basi del linguaggio e la programmazione orientata agli oggetti (OOP) le tecniche sono più o meno le stesse dalla prima versione di VB.NET in poi: sono state aggiunte nuove tecniche, ma la base è la stessa, quindi anche un libro sulla versione 2010 o sulla versione 2015 può andare bene per imparare il linguaggio. Molto spesso cambia l’interfaccia grafica e vengono aggiunte nuove funzionalità a Visual Studio, quindi potrebbero esserci delle differenze sui menu, sulle finestre e su qualche caratteristica modificata o introdotta con la nuova versione.

Spero di aver risposto chiaramente a tutte le domande e spero che lei possa trovare il modo per soddisfare il suo desiderio di imparare Visual Basic!


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


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


Altri due miei articoli su ioProgrammo

Nel numero di dicembre 2017 di ioProgrammo potete trovare due miei articoli su Machine Learning:

– “Il computer che impara“, algoritmi e tecniche di previsione con un servizio Microsoft

– “SQL Server 2017 è qui!“, con una parte dell’articolo che spiega l’applicazione delle tecniche di Machine Learning in SQL Server.

Se vi interessa l’argomento, quindi, acquistate ioProgrammo!


26903953_10213696427956457_5934473290513948998_n

Buona lettura! 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/)

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


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

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

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

Arduino & C.– “Hello World!”

Nei precedenti post ho parlato di schede, componenti, attrezzi e software che si possono acquistare per allestire il vostro piccolo laboratorio Arduino.

Ora che siamo attrezzati a sufficienza (per il momento) possiamo iniziare qualche piccolo esperimento. Ovviamente all’inizio gli esperimenti saranno semplicissimi, perché voglio che questi post costituiscano una piccola guida per chi parte da zero come me.

Sulla rete ci sono parecchie guide per i neofiti e anche i libri che vi ho consigliato hanno molte informazioni su come iniziare e come proseguire su questo percorso, ma voglio comunque fare con voi un percorso sperimentale che, passo-passo, ci permetta di esplorare con soddisfazione questo mondo e magari fare anche qualcosa di interessante.

Come in ogni buon libro o corso per imparare un nuovo linguaggio di programmazione, la prima cosa che si fa sempre è una applicazione “Hello World!”, cioè una prova che sia la più semplice possibile per verificare che tutto sia a posto per iniziare. Alla fine l’applicazione “Hello World!” è diventata un “must” nell’ambito tecnico perché dovete tenere presente questo:

REGOLA #1 DELLO SPERIMENTATORE:
prima di provare qualcosa di nuovo, partire da una situazione o uno stato
sicuramente funzionante sia dell’hardware che del software

Nel mondo Arduino l’applicazione “Hello World!” è ormai tradizionalmente il programma (sketch) Blink: un semplice insieme di istruzioni che fanno lampeggiare il LED presente su tutte le schede Arduino (collegate anche al PIN 13). Questo è lo sketch: 

/*
Blink
Turns on an LED on for one second, then off for one second, repeatedly.


  Most Arduinos have an on-board LED you can control. On the UNO, MEGA and ZERO
it is attached to digital pin 13, on MKR1000 on pin 6. LED_BUILTIN is set to
the correct LED pin independent of which board is used.
If you want to know what pin the on-board LED is connected to on your Arduino model, check
the Technical Specs of your board  at
https://www.arduino.cc/en/Main/Products

This example code is in the public domain.


  modified 8 May 2014
by Scott Fitzgerald

modified 2 Sep 2016
by Arturo Guadalupi

modified 8 Sep 2016
by Colby Newman
*/



// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(LED_BUILTIN, OUTPUT);
}


// the loop function runs over and over again forever
void loop() {
digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)
delay(1000);                       // wait for a second
digitalWrite(LED_BUILTIN, LOW);    // turn the LED off by making the voltage LOW
delay(1000);                       // wait for a second
}

 

Potete digitare questo sketch all’interno dell’IDE standard di Arduino oppure, più semplicemente, lo potete recuperare dalla sua libreria di esempi: menu File > Esempi > 01.Basics > Blink.

Molto spesso, quando acquistate una scheda Arduino o anche un clone, lo sketch Blink è già precaricato e quindi per provare che la scheda funziona basterà collegare il cavo USB all’apposito connettore sulla scheda Arduino e poi sulla porta USB del PC. Dopo un paio di secondi iniziali, durante i quali la scheda si assesta, vedrete lampeggiare il LED on-board: un secondo acceso e un secondo spento, alternativamente.

Ovviamente questo non ci soddisfa, ma prima di modificare lo sketch proviamo a dare un’occhiata al codice dello sketch Blink.

Prima di tutto ci sono varie righe di commenti, racchiusi in un blocco  /* … */ come nei linguaggi C, C++, C# e Java (e forse anche altri…). I commenti a singola linea invece sono preceduti da una doppia barra (//). Attenzione a non confondere le barre con la barra rovesciata o back-slash (\) perché è un simbolo che rappresenta i “caratteri di escape” (una codifica speciale).

A seguire vediamo due subroutine che non restituiscono alcun dato (hanno la specifica void), di nome setup() e loop().

La sub setup() permette di definire una volta per tutte le variabili o le costanti utilizzate nello sketch oppure di inserire le istruzioni da eseguire solo una volta, all’inizio.

Nella sub setup() dello sketch Blink possiamo vedere che è stato definito il pin LED_BUILTIN (cioè il LED presente sulla scheda, preassegnato al PIN 13) come segnale in uscita (OUTPUT). Questo ci permette di utilizzare il nome dell’identificatore nel resto del codice, invece di utilizzare il “numero secco” del pin, cioè il 13, che sarebbe poi poco comprensibile quando lo sketch diventa più complesso.

La sub loop(), invece, permette di inserire le istruzioni che devono essere eseguite continuativamente in un ciclo senza fine: qui si entra e non si esce più (“lasciate ogni speranza, o voi ch’entrate!”). Per uscire dal ciclo possiamo solo resettare la scheda (ma poi ci torniamo dentro nel nuovo riavvio dello sketch) oppure caricare un nuovo sketch (ma entreremo in loop() nel nuovo codice).

In questo esempio troviamo quattro istruzioni, ripetute a due a due: la prima (digitalWrite) fa in modo che venga inviato un segnale alto (HIGH) oppure basso (LOW) sul pin LED_BUILTIN. La seconda istruzione fa semplicemente fare una pausa di attesa di 1000 millisecondi, cioè un intero secondo.

Questo significa, in parole povere, che il LED sarà acceso per un secondo, poi resterà spento per un secondo, poi ricomincia il ciclo e si ripete all’infinito la sequenza. Facile no?

Ora che abbiamo avviato la scheda e abbiamo visto che il led lampeggia, abbiamo la sicurezza che la scheda funziona. Non abbiamo però provato la connessione via USB per caricare uno sketch per verificare che anche da questo punto di vista le cose siano a posto.

Aprite “Arduino IDE”, caricate l’esempio Blink (File > Esempi > 01.Basics > Blink) e cliccate sul primo pulsante con la spunta (“Verifica”): questo permette di compilare il codice in un linguaggio a basso livello comprensibile alla scheda Arduino, ma anche di verificare che non ci siano errori (istruzioni sbagliate, le sub setup o loop mancanti ecc.). In alternativa potete cliccare sul pulsante “Carica” (il secondo, quello con la freccia orientata verso destra), il quale eseguirà la verifica del codice, la compilazione e il caricamento sulla scheda Arduino.

Se non ci sono errori, vedrete lampeggiare il LED on-board sulla scheda Arduino, ma dato che aveva già precaricato lo sketch Blink, probabilmente non vedremo alcuna differenza.

Allora dobbiamo modificare lo sketch per rendere la modifica visibile: un modo semplice è quello di cambiare le due istruzioni delay(1000), variando la durata della pausa: se riducete il numero, il LED lampeggerà più velocemente, se lo aumentate, il LED rallenterà.

Provate per esempio a modificare da 1000 a 250 e a caricare lo sketch, poi modificate a 2000 e ricaricate. Non abbiate paura di modificare il programma, dobbiamo sperimentare!

Proviamo ora a fare qualcosa di più interessante (siamo a livello molto semplice, quindi non sono esperimenti proprio così entusiasmanti, ma se non conosciamo come funzionano le cose non possiamo modificarle…): vediamo come si può generare il segnale Morse di “SOS” con il LED. Anche se questo codice è ormai caduto in disuso, perché oggigiorno esistono modalità più pratiche e veloci per inviare un messaggio, può sempre essere utile per fare qualche esperimento. Ecco il codice dello sketch da digitare e caricare:

 

void setup() {

pinMode(LED_BUILTIN, OUTPUT);

}

void loop() {

// ritardo iniziale per non confonderci con il Blinker attivo

// e per dividere due messaggi “SOS” tra loro

delay(1000);

// lettera “S”

digitalWrite(LED_BUILTIN, HIGH);

delay(250);

digitalWrite(LED_BUILTIN, LOW);

delay(250);

digitalWrite(LED_BUILTIN, HIGH);

delay(250);

digitalWrite(LED_BUILTIN, LOW);

delay(250);

digitalWrite(LED_BUILTIN, HIGH);

delay(250);

digitalWrite(LED_BUILTIN, LOW);

delay(500);

// lettera “O”

digitalWrite(LED_BUILTIN, HIGH);

delay(500);

digitalWrite(LED_BUILTIN, LOW);

delay(500);

digitalWrite(LED_BUILTIN, HIGH);

delay(500);

digitalWrite(LED_BUILTIN, LOW);

delay(500);

digitalWrite(LED_BUILTIN, HIGH);

delay(500);

digitalWrite(LED_BUILTIN, LOW);

delay(500);

// lettera “S”

digitalWrite(LED_BUILTIN, HIGH);

delay(250);

digitalWrite(LED_BUILTIN, LOW);

delay(250);

digitalWrite(LED_BUILTIN, HIGH);

delay(250);

digitalWrite(LED_BUILTIN, LOW);

delay(250);

digitalWrite(LED_BUILTIN, HIGH);

delay(250);

digitalWrite(LED_BUILTIN, LOW);

}

 

A prima vista è un’accozzaglia di segnali di accensione e di spegnimento, ma funziona. Certamente non è ottimizzato (occupa un sacco di spazio in memoria) e se lo fate vedere a qualcun altro, certamente avrà qualche difficoltà a capire cosa fa perché non è comprensibile. Per un programma di questa semplicità non è il migliore risultato che potevamo ottenere.

Nel prossimo post vedremo come migliorare questo sketch, intanto meditate e provate la vostra scheda Arduino in modo da essere pronti per i prossimi esperimenti.

A presto!