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

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

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

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

24993263_10155601250416971_4284645672449403797_n

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

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

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

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

Buona lettura! Winking smile

Annunci

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

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

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

2017-12-05_05-32-02



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

Buon aggiornamento! Winking smile


Aggiornamento dell’add-in Arduino IDE for Visual Studio

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

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

Winking smile

Rilasciata la nuova versione 15.4.4 di Visual Studio 2017

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

Potete consultare le note di release alla pagina:

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

Buon aggiornamento! Winking smile

TechSmith: SnagIt 2018 e Camtasia 9.1.0

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

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

Grazie ancora, vi sono infinitamente grato. Winking smile

Arduino & C. – Un mio articolo su ioProgrammo

Volete creare un pianoforte elettronico con Arduino e Visual Studio?

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

Buona lettura e buon divertimento! Winking smile

ioprogrammo_november2017

Annunciato il nuovo .NET Framework 4.7.1

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

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

microsoft-net-framework-4.71

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

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

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

SQL Server 2017, la nuova versione del DBMS targato Microsoft

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

Eccovi alcune foto dell’evento Winking smile.

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


Arduino & C. – Una ulteriore considerazione sulla sicurezza

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

sicurezza

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

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

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

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

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

void setup() {
}


void loop() {
}

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

Mi raccomando, massima attenzione a quello che fate!

Buon divertimento Winking smile

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

[AGGIORNATO]

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

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

Immagine04

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

  • We wish you a Merry Christmas“:

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

  • “Tanti auguri a te”:

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

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

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

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

    CA–MB–ADGDAM–CBACCBMAHG–AD–MA

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

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

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

Buon divertimento Winking smile

Arduino & C. – INPUT_PULLUP e i pulsanti

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

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

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


Pullup


Da non confondere con questo:  Open-mouthed smile

pullup_var

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

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

   pinMode(pulsante, INPUT_PULLUP);

Trovate questa nuova versione nel mio post del 15 settembre.

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

Buon pull-up!

Arduino & C. – Potenziometro

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

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

Questi sono alcuni potenziometri:

pot1pot2pot3pot4pot5pot6pot7

… e il simbolo elettrico è questo:

SimboloPotenziometro

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

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

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

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

CircuitoPotenziometro


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

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

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

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

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

KY-040

Keyes KY-040

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

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

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

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

Lo schema dei collegamenti è il seguente:

RotaryEncoder5pin

Questo è il codice dello sketch che potete utilizzare:

volatile boolean TurnDetected;
volatile boolean rotationdirection;


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


int RotaryPosition=0;


int PrevPosition;


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


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


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


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


    TurnDetected = false;


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


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

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

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

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







.

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

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

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

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

Untitled Sketch_bb


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

int LED = 13;
int pulsante = 8;


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


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

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

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

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

circuito pull-up


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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Potete vedere quali sono le modifiche apportate al codice precedente.

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

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

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

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

Alla prossima “postata”… Open-mouthed smile

Arduino & C. – Il pulsante

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

Possono esserci due specie di pulsanti:

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

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

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

Pulsante


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

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

WP_20170828_06_19_45_Pro

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

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

Untitled Sketch_bb


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

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

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

Per migliorare questa situazione dobbiamo fare due cose:

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

Per quanto riguarda il circuito, ecco la nuova situazione:

Schema

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

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

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


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


void loop() {

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

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

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

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

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

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

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

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

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

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

Arduino & C. – Misurare con il multimetro digitale

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

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

Iniziamo dalla prima:

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

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

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

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

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

V = R * I

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

P = V * I

cioè

P = R * I * I

(P = R * I^2)

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

R = V / I

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

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

Per un LED bianco, invece:

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

 

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

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

R = (Va – Vled) / I

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

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

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

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

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

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


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


void loop() {


}

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

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

coccodrilli

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

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

 

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

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

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

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

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

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

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

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

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

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

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

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

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

Per finire

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

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

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

Buona misurazione!  Open-mouthed smile

Arduino & C. – Il LED

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

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

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

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

SchemaLED

 

SimboloLED

 

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

led

 

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

ConsumoLED

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

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

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

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

Ecco il circuito che ho preparato: CircuitoLED1

 

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

 

CircuitoLED1b

 

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

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

#define LED 8

void setup() {

   pinMode(LED, OUTPUT);
}

void loop() {

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

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

CircuitoLED1c

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

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

Per questa volta abbiamo finito.

Buon lampeggiamento!  Winking smile

Arduino & C. – Codice Morse e stringhe

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

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

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

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


CodiceMorse

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

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

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

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

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

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

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

  // lettera “M” 
   M();

   // lettera “A”
   A();

  // lettera “R”
   R();

   // lettera “I”
   I();

  // lettera “O”
   O();

}

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

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

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

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

#define LED 13


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


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


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


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


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


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


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


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


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

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

Alla prossima! Winking smile

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

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

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

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

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

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

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

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


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

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

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

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

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

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


  delay(1000);

  // lettera “S”
   S();

// lettera “O”
   O();

  // lettera “S”
   S();

}

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

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

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

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

Ecco lo sketch finale:

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

}

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

  // lettera “S”

  S();

  // lettera “O”
   O();

  // lettera “S”

  S();

}

void punto() {

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

}

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

}

void S() {

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

void O() {

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

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

Good coding!

Visual Studio 2017 versione 15.4 (Preview)

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

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

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

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

Happy coding! Winking smile

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!

 

Arduino & C. – Il software

Come avevo già accennato in uno dei precedenti post introduttivi, il mondo Arduino non è composto solo da hardware, cioè schede e componenti, ma anche da software.

Il primo software che devo necessariamente citare è “Arduino IDE”, una semplice interfaccia di programmazione che permette di connettere il PC con una o più schede Arduino attraverso il cavo USB (che è visto come una porta seriale COMn).

Se avete Windows 10 potreste anche scaricare il programma da Microsoft Store, ma ve lo sconsiglio, perché le app dello Store vengono memorizzate in una cartella nascosta e protetta dove non avrete accesso. Siccome per utilizzare correttamente l’add-in avete bisogno di indicare dove si trova l’eseguibile di “Arduino IDE”, dovete poter accedere alla cartella del software. Andate quindi alla pagina https://www.arduino.cc/en/Main/Software, nella sezione “Download the Arduino IDE” e scaricate dal link “Windows Intaller” (non da “Windows App – Get” con il simbolo di Windows).

Ovviamente “Arduino IDE” ha bisogno di sapere a quale porta seriale deve collegarsi e quindi dopo averlo installato bisogna configurarlo, indicando di quale scheda si tratta (Uno, Due, Mega2560 ecc.), di quale processore (una scheda può essere venduta con processori diversi) e quale porta.

Con questo IDE potete scrivere gli sketch (così si chiamano i programmi di Arduino), compilarli in un linguaggio a basso livello e caricarli direttamente nella scheda. Dopo aver fatto tutto questo, la scheda si resetterà e farà partire immediatamente il nuovo programma.

 

ArduinoIDE

 

Come potete vedere ci sono due routine di base che devono esserci sempre: setup() che viene eseguito solo una volta all’avvio della scheda e loop() che viene eseguito ripetutamente, all’infinito.

Lo sketch caricato sulla scheda rimane memorizzato anche se staccate l’alimentazione. All’accensione, riparte nuovamente, esegue setup() e poi esegue continuamente loop().

Potete anche vedere tre istruzioni tipiche:

  • pinMode(…, …); – serve a definire un determinato “pin” della scheda come INPUT o OUTPUT;
  • digitalWrite(…, …); – definisce il livello HIGH o LOW di tensione del pin indicato;
  • delay(…); – fa una pausa per un tempo corrispondente ai millisecondi indicati (1000 = 1 secondo).

Ci torneremo più avanti.

Il secondo software che vi propongo è un add-in di Visual Studio: “Arduino IDE for Visual Studio” scaricabile da qui:

https://marketplace.visualstudio.com/items?itemName=VisualMicro.ArduinoIDEforVisualStudio

Questo add-in permette di fare da ponte tra Visual Studio e l’”Arduino IDE”, in modo da lavorare direttamente in Visual Studio anche per la scrittura e il caricamento degli sketch sulla scheda.

Ovviamente anche l’add-in per Visual Studio deve essere configurato per far sapere a Visual Studio a quale porta seriale ci si deve collegare per interagire con la scheda Arduino.

Fatto questo, potrete anche creare le vostre applicazioni in Visual Basic, in C# o in F# e fare in modo di interagire con la scheda Arduino attraverso una comunicazione via porta seriale (USB).

Di tutto questo ne ho parlato in un mio articolo che ho scritto per la rivista “ioProgrammo”: l’articolo sarà pubblicato probabilmente nel numero di ottobre 2017 (quindi in uscita a settembre).

In questo post, però, non ho finito qui, perché c’è un altro software di cui vi voglio parlare: Fritzing!

Il software, gratuito, è scaricabile dalla seguente pagina: http://fritzing.org/home/ (attualmente è in versione 0.9.3b, ma è perfettamente funzionante).

A cosa serve? Semplicemente a disegnare i nostri progetti elettronici con tanto di schede Arduino (ci sono tutte le versioni!), componenti, breadboard e quant’altro!

Il programma non necessita di installazione, basta scompattare il “pacchetto” in una cartella che poi potete copiare nella cartella C:\Programmi

Ecco un piccolo esempio:

Fritzing

 

Ed ecco fatto un piccolo semaforo!

Con Fritzing potete progettare il circuito in modo grafico e poi, quando siete soddisfatti della disposizione dei componenti, lo potete realizzare fisicamente, senza dover procedere per tentativi per far stare tutto quello che volete disporre sulla breadboard e sulla scheda Arduino. Inoltre potete utilizzarlo come ho fatto io, per pubblicare un’immagine del progetto, magari per un post nel vostro blog…

Anche per questa volta abbiamo finito: non siamo andati molto a fondo negli argomenti perché la prima parte (Arduino IDE e l’add-in per Visual Studio, nonché la programmazione di un’applicazione Visual Basic) è spiegata per filo e per segno nell’articolo che uscirà su ioProgrammo, quindi vi invito ad acquistare il numero di ottobre 2017 e di leggerlo attentamente. Inoltre il software Fritzing è veramente intuitivo e quindi dopo qualche tentativo iniziale vi vedrete immediatamente inserire cavetti, LED e resistenze senza alcun problema.

Detto questo, buone vacanze per chi è già in vacanza o sta per partire, oppure buon lavoro per chi sta rientrando o è già al lavoro da un po’.

Buon Arduino a tutti!

 

Arduino & C. – Qualche accessorio utile per lo spazio di lavoro

Nel post precedente abbiamo visto alcuni kit (comprensivi di schede Arduino-like, vari componenti elettronici e sensori) e alcuni libri interessanti da studiare e da provare.

Oggi vediamo qualche oggetto che può esserci di aiuto per lavorare comodamente senza rovinare il tavolo di lavoro, ma anche per iniziare a comporre la nostra attrezzatura.

Prima di tutto vi consiglio un “Piano da taglio” di 45 x 30 x 0,3 cm (https://www.amazon.it/gp/product/B00ABJQNOM) del costo di 16,77 Euro. Ne esistono anche di più grandi, ma questo dovrebbe essere sufficiente, almeno finché non inizierete a lavorare con molti attrezzi. La sua funzione principale dovrebbe essere appunto quella di poter usare un taglierino senza rovinare il tavolo (per esempio quando fate la rilegatura con la plastica trasparente ai libri di scuola di vostro figlio…). Il piano è però così resistente e bello che mi è sembrato un ottimo piano di lavoro anche per altri lavoretti di casa o, appunto, di elettronica.

PianoTaglio

Vi serviranno poi degli attrezzi… qui c’è un buon set di attrezzi (https://www.amazon.it/gp/product/B000K2LL6K) al costo di 28,99 Euro: cacciaviti, pinze, cercafase, tronchesino e qualche accessorio. E’ quasi completo, nel senso che quando ho tentato di smontare un hard disk ormai “andato” ho scoperto che la vite utilizzata ha l’intaglio a 6 punte ma con una dimensione un po’ più piccola di quella della punta disponibile in questo kit. Pazienza, più avanti troverò un cacciavite singolo con questa punta, ma adesso non è fondamentale.

KitAttrezzi

Ultima cosa: a un certo punto inizierete ad avere bisogno di fare qualche misurazione. Per esempio, i resistori hanno una resistenza di determinati Ohm: quanti Ohm di resistenza abbia un resistore lo si vede dai “codici colore” presenti sul corpo del resistore stesso. Per chi non è così pratico, pur avendo davanti la tabella dei codici colore, o nel caso in cui i colori non si vedano così nettamente, è necessario prendere una misura con il multimetro. Questo è un multimetro più che sufficiente per le nostre esigenze (https://www.amazon.it/gp/product/B01N0537U0) e costa 31,97 Euro, prezzo quasi dimezzato da quello in origine. Presenta parecchie misurazioni: Volt, Ampere, Ohm, diodi, temperatura, condensatori, Hertz e ha anche una interessante caratteristica, cioè la posizione NCV che permette di verificare se c’è una tensione in un circuito, in un apparecchio, in una presa di corrente ecc., semplicemente avvicinando la parte anteriore dell’apparecchio, senza alcun contatto: in tal caso emette un suono di avvertimento e si accende una luce. Può esserci il caso in cui l’apparecchio o il circuito è così ben isolato da non permettere questa “misurazione senza contatto”, ma nella maggior parte dei casi è in grado di impedirci di fare una grossa sciocchezza…

Multimetro

Naturalmente non è finita qui: per il nostro laboratorio serviranno anche altre cose, tra cui un saldatore o una “stazione saldante”, degli occhiali di protezione eventualmente sovrapponibili agli occhiali (per evitare schizzi di stagno bollente negli occhi…), magari una base di protezione del tavolo più resistente per saldare, uno spelafili per creare i nostri ponticelli o anche per “crimpare” connettori (es. Ethernet) ecc… Ma al momento ci fermiamo qui, perché forse siamo già andati un po’ oltre. Anche perché per fare i nostri esperimenti, al momento ci basta una “breadboard” (basetta sperimentale) e dei cavetti di collegamento (ponticelli): non c’è bisogno per il momento di saldare nulla, anche perché così possiamo riutilizzare i componenti elettronici per altri esperimenti, senza dover impazzire per dissaldare i collegamenti!

Nel prossimo post affronterò alcuni aspetti relativi al software per programmare le schede Arduino, ma anche per altre utilità, così avrete anche voi il vostro piccolo laboratorio per lavorare sui vostri progetti. Open-mouthed smile

Alla prossima! Winking smile

Arduino & C. – Kit di componenti

Per iniziare assolutamente da zero avrete bisogno di molte cose… quello che non deve mancare sono:

  • n. 1 scheda Arduino originale o un clone
  • una serie di componenti di vario genere (LED, resistori, ponticelli, pulsanti ecc. ecc.)
  • e soprattutto un libro che vi spieghi tutto per bene, compresi vari progetti da costruire e sperimentare

Questo obiettivo lo possiamo raggiungere acquistando l’Original Starter Kit di Arduino, del costo di 79,00 Euro (su Amazon https://www.amazon.it/Arduino-k010007-Original-Starter-Kit-manuale-Italiano/dp/B00FDW8JJE): contiene un libro con 15 progetti da realizzare e quasi 220 componenti, compresa una scheda “Arduino UNO Rev.3” originale.

ArduinoKit

La mia scelta è stata invece un po’ diversa, perché ho optato per un kit da 54,99 Euro (su Amazon https://www.amazon.it/Elegoo-MEGA2560-Progetto-Completo-Tutorial/dp/B01JLTVX6U/) che comprende:

  • n. 1 scheda “Elegoo Mega 2560 R3” (un clone identico ad Arduino)
  • più di 300 componenti di vario genere
  • n. 1 CD-ROM con una guida in PDF: la guida di Elegoo non è perfettamente tradotta in italiano ma è sufficientemente comprensibile e ha delle immagini chiare sui vari progetti proposti.

ElegooKit1

Se volete, comunque, potete optare per lo stesso insieme di elementi ma con una scheda Arduino UNO R3 a 49,99 Euro (https://www.amazon.it/Elegoo-Progetto-Completo-Principianti-Apprendimento/dp/B01JJ23CI6). E’ una scheda più piccola, con meno pin, ma anch’essa adatta per iniziare gli esperimenti.

Inoltre ho acquistato un ulteriore kit di sensori da 32,99 Euro (su Amazon https://www.amazon.it/Elegoo-Sensore-Elettronici-Tutorial-Inglese/dp/B01N79PG4G/) con sensori e dispositivi di vario genere.

Anche in questo caso c’è in dotazione un CD-ROM con la guida d’uso in PDF dei vari sensori.

ElegooKit2

Entrambi i kit arrivano con una valigetta in plastica, dotata di vari scomparti che permettono di tenere in ordine i due kit.

Questi due kit permettono di fare le prime sperimentazioni su breadboard (basetta sperimentale fornita in dotazione).

Naturalmente nulla vi vieta di fare una lista di tutti i componenti inclusi nei due kit e andare in un negozio di elettronica vicino casa ad acquistare via via solo quello che intendete utilizzare di volta in volta nei vostri progetti: alla fine, però, probabilmente avrete speso più di quanto non avreste speso acquistando i kit su Amazon.

Sono poi disponibili altri kit, anche senza scheda ma con più componenti elettronici (LED, resistori ecc.), ma con le due “valigette” a disposizione potete già fare parecchie cose e a questo punto conviene acquistare solo quello che serve singolarmente.

Un’ultima cosa per questo post: le guide in PDF non sono sufficienti per capire veramente cosa state facendo quando inserite i vari componenti sulla scheda e sulla breadboard, ma vi aiutano solo a identificare i componenti, a capire come fare i collegamenti e ad arrivare al progetto finito. Per capire veramente i concetti in modo da poterli applicare in modo cosciente e permettervi di modificare i progetti e di adattarli alle vostre esigenze, oppure di creare nuovi progetti in base alla vostra creatività, è opportuno acquistare uno o più libri.

Ecco una piccola selezione di libri che vi posso consigliare per studiare e acquisire maggiore consapevolezza di quello che state facendo:

  • “Arduino: la guida ufficiale” – Edizioni Tecniche Nuove – di Massimo Banzi e Michael Shiloh, costo su Amazon da 12,99 a 14,37 Euro (N.B.: Massimo Banzi è uno dei fondatori di Arduino!)
  • “Creare progetti con Arduino for Dummies” – Edizioni Hoepli – di Brock Craft, costo su Amazon da 12,99 a 21,17 Euro
  • “Elettronica per maker: guida completa” – Edizioni LSWR – di Paolo Aliverti, costo su Amazon da 17,99 (Kindle) a 21,17 (libro) Euro

I primi due parlano propriamente di progetti che potete realizzare con Arduino, mentre il terzo è più specificamente orientato all’elettronica (indipendentemente da Arduino), con una importante parte teorica. Tutti e tre i libri vi danno anche una iniziale spiegazione sull’attrezzatura che dovreste prendere per crearvi un piccolo laboratorio casalingo, sulle precauzioni da adottare, sulle modalità di utilizzo degli attrezzi e dei componenti e molto altro.

A proposito: avrete notato che finora non ho parlato di attrezzi: cacciaviti, pinze, multimetro, saldatore e così via… Di questo ne parleremo più avanti in altri post, ma andiamo gradualmente: in elettronica ci vuole tanta pazienza!  Winking smile

Buoni acquisti e buono studio, ci vediamo al prossimo post!  Open-mouthed smile

 

Arduino & C. – Una doverosa premessa

Eccomi ancora qui a parlare di Arduino, come promesso. Open-mouthed smile

Per prima cosa voglio precisare alcune cose che per alcuni potrebbero essere scontate e ad altri invece no:

  • mi sono sempre occupato molto di software, abbastanza di sistemi operativi, un po’ di installazioni di reti locali, relativamente poco di hardware (a parte sostituire il microprocessore del mio Commodore C-128D, assemblare più PC rotti in qualche PC funzionante e installare qualche scheda interna);
  • ho superato qualche corso universitario su questi argomenti, tra cui: elettrotecnica, elettronica (microelettronica con resistenze, diodi, condensatori, transistor… MOSFET, BJT e company), controlli automatici (aspetti matematici e stabilità dei sistemi… i famosi “zeri”), comunicazioni elettriche/reti e calcolatori (con un progettino in Assembler fatto con una scheda su cui era montato un Motorola 68000). NON SONO PERO’ UN ESPERTO DI ELETTRONICA, non ho mai fatto pratica con i componenti elettronici o altro e quindi mi ritengo un quasi assoluto neofita (livello beginner);
  • recentemente ho letto qualche articolo su Arduino e mi si è accesa la “fiammella”  della curiosità, per cui ho pensato di approfondire;
  • i costi per iniziare sono tutto sommato abbordabili (anche grazie ad Amazon) e quindi ho iniziato a dare un’occhiata alle varie schede e kit di componenti: dato che non mi sono mai occupato di elettronica avevo pochissimi attrezzi e quindi ho dovuto un po’ documentarmi e capire cosa poteva servirmi per iniziare.

Fatte queste premesse e appurato che l’unica mia spinta è la passione e la curiosità, il mio scopo di questi post è quello di provare ad aiutare quelli che come me vogliono partire praticamente da zero e imparare strada facendo. Su questo blog, quindi, inizialmente vedrete cose veramente semplici che potranno anche far sorridere chi è più esperto, ma che certamente possono interessare i “beginner” in questo ambito, come me.

Passiamo quindi alle premesse relative ad Arduino: cos’è e a cosa serve?

Potremmo dire senza paura di smentita che si tratta di una piattaforma per costruire prototipi di piccoli sistemi elettronici, dotati di una scheda Arduino (ce ne sono vari modelli), una basetta sperimentale (vedremo poi cos’è), vari componenti “semplici” (LED semplici e LED RGB, resistenze, cavetti di connessione detti anche ponticelli, pulsanti ecc.), eventuali sensori (luce, suono, gas, temperatura, umidità, pressione, vibrazione, ribaltamento e così via), “shield” (circuiti integrati già pronti con varie funzionalità come comunicazioni via Ethernet, WI-FI, BlueTooth o GSM, che possono essere semplicemente sovrapposti sulla scheda Arduino perché condividono alcuni “pin” e che insieme formano un “panino”) e naturalmente il software.

NOTA: i pin sono i “punti” di connessione di una scheda elettronica; il “panino” rappresenta un insieme a più strati, ma non si mangia!

Con Arduino è possibile costruire anche qualche dispositivo utile per la casa (annaffiare il giardino e le piante, controllare fughe di gas, creare una stazione meteo, comunicare…), per l’auto (comunicazioni e localizzazioni, antifurto, rilevazione climatica…), per le persone (giocattoli, comunicazione e altro). Ovviamente non mettetevi in testa che potrete guadagnare qualcosa inventandovi qualcosa di utile: un apparecchio costruito con Arduino non solo è relativamente ingombrante (con sistemi industriali potete costruire apparecchi molto più piccoli), non solo è lento (le connessioni attraverso la basetta sperimentale o breadboard non sono le migliori possibili), ma non diventerà sicuramente un prodotto realmente commercializzabile.

Tuttavia potete acquisire sempre maggiore esperienza, costruire qualche cosa magari anche di utile per voi e se la cosa funziona, potete rivolgervi a qualcuno che può reingegnerizzare il prodotto con strumenti industriali e renderlo appetibile per il mercato: per esempio fornendovi il circuito stampato (sulla base delle connessioni che vi servono) su cui saldare i componenti del vostro apparecchio.

Una “penultimissima” premessa che riguarda la sicurezza elettrica.

Nella maggior parte dei casi (forse tutti) faremo uso solo di corrente continua: cavo USB collegato al PC o alimentazione a pile. La corrente alternata, cioè quella delle prese di casa, è troppo pericolosa soprattutto in tutto il periodo di studio e sperimentazione iniziale.

In ogni caso evitate il più possibile di sistemare i componenti elettrici/elettronici con l’alimentazione attaccata, anche se usate la corrente continua. Una corrente non tenuta perfettamente sotto controllo può danneggiare la scheda Arduino, i componenti, il PC e anche voi (in qualche caso anche il vostro ambiente circostante). Inoltre utilizzate sempre delle precauzioni: prima di dare l’alimentazione controllate sempre di aver fatto tutto nel modo corretto, ricontrollate una seconda volta e se necessario anche una terza. Inoltre cercate di procurarvi un bracciale antistatico per scaricare l’eventuale energia statica (quella che vi dà la scossa per esempio quando indossate un maglione di lana e le scarpe con la suola isolante) perché potreste scaricare la corrente su un componente, bruciandolo.

Ho anche letto di una particolare tecnica utilizzata soprattutto quando si lavora con la corrente alternata: con una mano si lavora alle connessioni e l’altra si tiene dietro alla schiena. Questo serve per evitare che la corrente, entrando da una mano e uscendo dall’altra mano possa passare per il cuore… inutile dire qual è il rischio, vero? Bene, fate attenzione sempre sempre sempre: con la corrente non si scherza.

E ora l’ultima premessa: non mi assumo alcuna responsabilità di qualsiasi cosa vi succeda provando gli esperimenti che vi suggerisco! Ovviamente non vi dirò di mettere due dita nella presa di corrente di casa, ma vi consiglio sempre di verificare i progetti consigliati e di attuare tutte le misure di sicurezza del caso. Ci tengo ai miei lettori, quindi state attenti e non fatevi male!

Ok, ho fatto tutte le premesse del caso: dal prossimo post vi darò qualche dritta sulle cose che potete acquistare per iniziare e sui software che potete scaricare e installare per lavorare sulla parte più “soft” dei progetti “hard”  Smile with tongue out

Buon inizio settimana!  Winking smile

Arduino & C. – Cosa c’entra la programmazione .NET

Arduino è sicuramente interessante come piattaforma di sviluppo e di prototipizzazione, soprattutto in ambito personale e casalingo. In ambito industriale le raccomandazioni tecniche e le norme di settore richiedono maggiore isolamento dalle interferenze e questo è un dato di fatto.

Mega2560_R3_Label-small-v2

Ciò non toglie il fatto che sia un prodotto veramente innovativo, soprattutto perché mette questa tecnologia a disposizione della gente comune. Un po’ come oltre 30 anni fa è stato con il Commodore VIC-20 (è stato il mio primo home computer), con il C64 o l’evoluto Amiga, ma anche con Atari e ZX Sinclair: un Olivetti M24 nel 1987 costava 7 milioni di Lire (circa 3.500 Euro attuali), mentre un Commodore VIC-20 nel 1984 (tre anni prima) costava 200.000 Lire (circa 100 Euro attuali). E’ vero che gli home computer della prima generazione avevano una RAM piccolissima, avevano l’unità a nastro (o il floppy 5,25” nel C128D), ma con i Commodore (anche Amiga), i ZX Sinclair e gli Atari hanno iniziato a lavorare (o a “smanettare” come si iniziò a dire) nell’informatica migliaia o centinaia di migliaia di persone in tutto il mondo… Con Arduino prevedo una progressione abbastanza simile.

Sono strumenti piccoli ma con grandi potenzialità: si connettono al PC con la porta USB e con appositi shield è possibile connetterli in Ethernet, Wi-Fi o Bluetooth. Ci sono una infinità di sensori acquistabili e collegabili in modo estremamente facile e sono programmabili con un linguaggio tutto sommato semplice (un C ma molto simile a C# o a JAVA, anche se con un set di istruzioni limitato).

Non ultimo è possibile gestirli opportunamente con un’applicazione scritta da noi, per esempio in Visual Basic oppure in C#, o anche in F#: basta avere perfettamente in mente che c’è una parte hardware, una parte software sul lato-Arduino e una parte software sul lato-PC.

Inoltre è possibile gestire la parte di sviluppo anche in Visual Studio 2017: basta un add-in che si aggancia in modo trasparente all’”Arduino IDE” originale.

Di tutto questo ho spiegato nell’articolo che ho appena finito di scrivere per la rivista “ioProgrammo”: l’articolo dovrebbe essere pubblicato fra un paio di mesi.

Nel frattempo continuo a studiare e a sperimentare: in particolare l’interazione tra un’applicazione .NET e Arduino, ma con un po’ di “elettronica spicciola”.

L’entusiasmo che suscita in me questa inaspettata evoluzione dei miei interessi mi fa sentire come 33 anni fa, nel 1984, quando ho acquistato il Commodore VIC-20 e ho iniziato a studiare il manuale di istruzioni!


Risultati immagini per ferragosto


Arduino & C. … IoT a portata di mano!

Ecco qua la “bestiolina”, un clone esattamente uguale ad Arduino Mega 2560 R3. E’ arrivato anche per me il momento di esplorare questo mondo di microcontroller, componenti elettronici e sensori, con i quali si possono realizzare soluzioni IoT (Internet of Things), ma anche tante altre cose utili non necessariamente connesse. Si parte per una nuova avventura fatta di software e di hardware. A breve qualche post sul mio blog https://deghetto.wordpress.com e un articolo sulla rivista ioProgrammo!

Elegoo Mega 2560 R3

Un periodo di grande creatività e fermento

Mi sono appena reso conto che è parecchio che non aggiorno il mio blog e così mi è venuta l’idea di scrivere questo post, un post molto poco tecnico ma utile per far capire a chi mi legge che non sono sparito, non sono stato fermo, anche se qui non ho scritto nulla.

Ci siamo lasciati con il mio precedente post a fine marzo, con il quale annunciavo la certificazione della mia prima app per Microsoft Store, “Garage40 TheVoice”, una semplice app creata con Visual Studio e con il template Windows Forms, poi convertita per lo Store. Questa applicazione permette di inserire un semplice testo in una casella RichTextBox (o anche copiando-incollando il testo da un’altra fonte), per poi attivare la lettura del testo dalla voce del PC. Nella mia macchina era installata solo la voce italiana, ma volendo provarlo anche in inglese ho installato il pacchetto di lingua inglese di Windows 10, trovando così anche altre due voci con una pronuncia inglese decisamente buona. Ecco la schermata dell’app con relativa finestra delle informazioni.

Garage40_TheVoice

Il passo successivo è stato quello di creare altre due applicazioni di produttività personale: un elaboratore di testi di nome “Garage40 Write” (relativamente simile a Word, anche se ovviamente Word è inarrivabile) e un foglio elettronico di nome “Garage40 Calc” (relativamente simile a Excel, anche questo inarrivabile). Entrambe le app hanno la funzione di lettura da PC (Text To Speech) rispettivamente del testo e del contenuto della cella. Ho poi convertito queste due applicazioni per lo Store, utilizzando Visual Studio 2017, e ho affrontato la procedura di certificazione: a parte una piccola impasse con la questione “privacy dell’utente”, poi superata, entrambe le app hanno superato la certificazione e sono attualmente in vendita nello Store. Qui sotto riporto qualche immagine delle due app.

Garage40_Write

Garage40_Calc

Potete trovare tutte le mie app in Microsoft Store semplicemente ricercando la stringa “Garage40” perché ho deciso a dare questa specie di brand alle mie app per dare maggiore facilità di ricerca.

NOTA: il riferimento al “garage” è ovviamente una celebrazione dei molti progetti informatici e di molte software house o aziende produttrici di hardware nate in piccoli garage casalinghi, nell’epoca pionieristica dell’informatica di massa, tra gli anni 70 e 80; il “40” non è altro che il civico della mia abitazione, intendendo così riferirmi al mio “garage” personale, in senso scaramantico…

Nel frattempo si è conclusa la revisione del mio ultimo (in ordine di tempo) libro: “SQL SERVER 2016 – LA GUIDA”, edito da LSWR.it (ordinabile dalla pagina seguente: http://www.edizionilswr.it/libri/sql-server-2016/; materiali degli esempi scaricabili da http://books.bell1.net). Ecco la copertina:

LibroSQLServer2016

Non finisce qui: a fine aprile ho consegnato un articolo a “ioProgrammo” su una classifica con le migliori novità di SQL Server 2016, mentre in questo momento sto lavorando su altri due articoli, uno sull’interazione tra Visual Studio 2017 e i database di SQL Server 2016 e l’altro sulla conversione di applicazioni “desktop” per Microsoft Store utilizzando Visual Studio 2017.

Ultimamente ho iniziato anche ad approfondire alcune tecniche, soprattutto nell’ambito delle app “universali” (Universal Windows App), del cloud di Microsoft (Azure) e delle app “mobili” (Xamarin).

Ultimo, ma non di minore importanza, ho iniziato anche la redazione di un libro su “Visual Basic 2017” che, se tutto va bene, potrebbe vedere la luce verso questo autunno o, nel peggiore dei casi, per l’inizio del 2018. Mi piacerebbe scrivere anche il “libro gemello” su C#, come avevo fatto in occasione della redazione del libro “Visual Basic 2008 spiegato a mia nonna” e del libro “C# 2008 spiegato a mia nonna”, ma LSWR.it ha già un autore di un esteso libro su C# e quindi temo che il mio libro non avrà spazio.

Detto questo non mi resta che augurarvi buona lettura per le mie produzioni o buon uso delle mie app, sperando che possano esservi utili.

Stay tuned!