Archivi categoria: Programmazione

Grandi novità dal mondo Microsoft!

Finalmente l’annuncio dell’uscita di aggiornamenti di molti prodotti di punta di Microsoft:

  • Windows Server 2019
  • Aggiornamento 1809 di Windows 10 denominato “Windows 10 October 2018 Update”
  • Office 2019

WindowsServer2019

(N.B. immagine non ufficiale)


A parte l’aggiornamento di Windows 10 che non appare tra i prodotti scaricabili da MSDN, forse perché alcuni siti hanno segnalato problemi avuti da qualche utente, gli altri sono già scaricabili e installabili. Se fate l’aggiornamento, quindi, fate attenzione agli eventuali avvisi di incompatibilità (pare che il problema sia un driver di Intel) per evitare che il computer diventi inutilizzabile o che si perdano dati e documenti (fate i backup!).

Office365

Trovo particolarmente interessante Office 2019 che potrebbe essere l’ultima versione “a pacchetto”, perché sembra che le intenzioni di Microsoft siano quelle di spingere verso l’edizione online (OFFICE 365) per garantire aggiornamenti immediati, con correzione di bug “al volo” e introduzione di nuove caratteristiche di volta in volta che vengono rilasciate. Questo significherebbe la stabilizzazione del marchio OFFICE 365 a scapito delle edizioni annuali (“Office 2013…2016…2019”), così come è stato fatto con Windows 10, dove gli aggiornamenti modificano la build ma non il “nome di base” WINDOWS 10.

A questo punto mancano solo due altri tasselli per un rinnovo totale del mio “ecosistema” informatico: l’aggiornamento a Visual Studio 2019 (già in corso d’opera e che ha avuto già qualche accenno di annuncio) e l’aggiornamento di SQL Server (al momento l’ultima versione è la 2017, quindi è probabile che non ci saranno ulteriori aggiornamenti a breve… vedremo).

Bene, tutti a fare il download e mi raccomando: sempre avanti, chi si ferma è perduto!

Winking smile


ULTIM’ORA PER WINDOWS 10

https://support.microsoft.com/…/windows-10-update-history
“We have paused the rollout of the Windows 10 October 2018 Update (version 1809) for all users as we investigate isolated reports of users missing some files after updating.”


“ULTIMA ULTIM’ORA” PER VISUAL STUDIO 2019 E LA RELEASE 15.9 DI VISUAL STUDIO 2017

Oggi è giornata di aggiornamenti vari delle notizie che ho pubblicato… Nel tempo trascorso scaricando e installando Office 2019 ho visto un nuovo post relativo a Visual Studio 2019 e quindi ve lo riporto subito

https://blogs.msdn.microsoft.com/visualstudio/2018/10/05/visual-studio-2017-and-visual-studio-for-mac-support-updates/

#4 Ottenere l’indirizzo IP [== AGGIORNATO ==]

Questo era un post che avevo pubblicato in questo blog ben 10 anni fa e ora lo riprendo perché è opportuno che venga modificato qualcosa…

In particolare il metodo Dns.GetHostByName() è deprecato e quindi bisogna utilizzare un codice diverso. Quello che vi consiglio io è questo:

Private Function GetIPv4Address() As String
    GetIPv4Address = String.Empty
    Dim strHostName As String = System.Net.Dns.GetHostName()
    Dim iphe As System.Net.IPHostEntry =
  System.Net.Dns.GetHostEntry(strHostName)

    For Each ipheal As System.Net.IPAddress In iphe.AddressList
        If ipheal.AddressFamily =
  System.Net.Sockets.AddressFamily.InterNetwork Then
            GetIPv4Address = ipheal.ToString()
            If GetIPv4Address.Substring(0, 7) = "192.168" Then
                Return GetIPv4Address
            End If
        End If
    Next
End Function

Ho sperimentato vari metodi, ma l’unico che ho trovato che permetta di estrarre un indirizzo IPv4 (in particolare l’indirizzo locale 192.168.xxx.xxx) è quello di questa variante.

Se togliete il test sulla stringa “192.168 è probabile che invece vi venga presentato l’indirizzo IP che il router ADSL ha sulla rete esterna.

[VECCHIO TESTO]:

Per ottenere l’indirizzo IP della macchina (collegata in rete) sulla quale gira il programma, ecco una soluzione valida per Visual Basic 2005:

Private Shared Sub NamedSub() 
  Dim loip() As System.Net.IPAddress = _ 
    System.Net.Dns.GetHostAddresses(System.Net.Dns.GetHostName) 
  Dim ip As String = loip(0).ToString 
  MessageBox.Show(ip) 
End Sub

E’ possibile ottenere altre informazioni sulla connessione di rete leggendo questo articolo pubblicato su MSDN

Il metodo usato in Visual Basic 2003 è obsoleto e da evitare:

Dim ip As String = _ 
System.Net.Dns.GetHostByName(System.Net.Dns.GetHostName) 
.AddressList(0).ToString 

N.B.: l’istruzione deve essere scritta tutta su una singola riga

Visual Studio 2017 si aggiorna…

Vi sarete accorti che gli aggiornamenti di Visual Studio 2017 sono ripresi a ritmo serrato: dopo la versione 15.8.2 che ha portato qualche problema critico, sono state rilasciate rapidamente le versioni 15.8.3 e l’attuale 15.8.4.


image


Naturalmente non ci si ferma mai, quindi ecco anche il post dal blog del Team di sviluppo di Visual Studio, con l’annuncio della nuova Preview (Visual Studio 2017 version 15.9 Preview 2):
https://blogs.msdn.microsoft.com/visualstudio/2018/09/11/visual-studio-2017-version-15-9-preview-2/?utm_source=vs_developer_news&utm_medium=referral

Visual Studio Installer showing Windows 10 Preview SDK as optional


Buon aggiornamento!

Winking smile

GANTT per MS Access – Aggiornamento

Testo originale in https://deghetto2.wordpress.com/2008/03/04/access-diagrammi-di-gantt-con-access/:

Sul sito Microsoft (portale per le PMI) è disponibile un articolo che spiega come è possibile creare diagrammi di Gantt con Access per la pianificazione di progetti. Dalla stessa pagina è possibile scaricare un file PDF con l’intero articolo e un file .zip con il database Access di esempio.

AGGIORNAMENTO del 9 settembre 2018

A quanto pare l’articolo è stato tolto, ma del resto era un articolo di almeno 10 anni fa e quindi piuttosto superato anche rispetto alle versioni di MS Access.

Per ovviare a questo problema, ammesso che nessuno comprensibilmente abbia scaricato il testo integrale e l’esempio, un’idea potrebbe essere quella di installare un add-in per Access come questo: https://download.cnet.com/Gantt-Chart-Builder-Access/3000-2076_4-10074558.html.

Attenzione: dato che il software viene scaricato gratuitamente da un sito che non è lo Store di Microsoft non garantisco né per il funzionamento, né per eventuali effetti collaterali negativi (compatibilità, errori, malware ecc.).


Intelligenza Artificiale (AI) – un articolo interessante

Se siete interessati ad argomenti come computer quantico, intelligenza artificiale, servizi cognitivi (Cognitive Services), Machine Learning e così via, con le opportunità e i rischi che saranno affrontati in un futuro non molto lontano, vi consiglio di leggere questo lungo articolo:

https://www.ai4business.it/intelligenza-artificiale/intelligenza-artificiale-cose/

Spiega molto bene cos’è l’intelligenza artificiale e gli sviluppi della tecnologia in questo vasto campo.

AI

Una grande novità che mi rende felice!

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

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


image

image


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

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

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

A presto! Winking smile

Annunciato il nuovo Visual Studio 2019

E’ ancora presto per sapere come cambierà Visual Studio nella versione 2019, ma intanto è uscito il primo annuncio:

https://blogs.msdn.microsoft.com/visualstudio/2018/06/06/whats-next-for-visual-studio/

image


Una novità è anche il fatto che il nome del prodotto sia già definito in fase di annuncio: infatti, in tutte le precedenti versioni si è sempre parlato del nome in codice o del numero di versione (questo dovrebbe essere Visual Studio 16), mentre questa volta il nome Visual Studio è già associato alla versione 2019, il ché fa pensare a una tempistica di rilascio abbastanza stringente.

Vedremo prossimamente cosa succederà… intanto aspettiamo.

Restate sintonizzati! Winking smile

Aggiornamento alla versione 15.5.6 di Visual Studio 2017

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

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

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

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


image


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

Buon aggiornamento!  Winking smile

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

A quanto pare ci siamo!

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

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

2018-01-28_11-51-52

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

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


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

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


Buona installazione! Winking smile

Rispondo alla richiesta di un lettore…

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


Buonasera …

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

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

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

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

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

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

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


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

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

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


IoProgrammo


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

Buona lettura! Winking smile


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

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

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


image


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

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

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

Buon Arduino a tutti!  Winking smile


Altri due miei articoli su ioProgrammo

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

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

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

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


26903953_10213696427956457_5934473290513948998_n

Buona lettura! Winking smile

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

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

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

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

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

BUON ANNO, BUON 2018 A TUTTI!

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

Una guida gratuita ai servizi di Microsoft Azure per gli sviluppatori

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

image

La guida è costituita da ben 7 capitoli:

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

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

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

Buona lettura! Winking smile

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

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

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

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

24993263_10155601250416971_4284645672449403797_n

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

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

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

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

Buona lettura! Winking smile

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

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

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

2017-12-05_05-32-02



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

Buon aggiornamento! Winking smile


Rilasciata la nuova versione 15.4.4 di Visual Studio 2017

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

Potete consultare le note di release alla pagina:

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

Buon aggiornamento! Winking smile

Arduino & C. – Un mio articolo su ioProgrammo

Volete creare un pianoforte elettronico con Arduino e Visual Studio?

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

Buona lettura e buon divertimento! Winking smile

ioprogrammo_november2017

Annunciato il nuovo .NET Framework 4.7.1

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

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

microsoft-net-framework-4.71

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

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

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

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