Eink paper display: what is this?

EPD (Electronic Paper Display) is a bunch of microsphere filled with two, or more, pigments elettrostaically charged.

When you change polary of voltage applied to the display the pigments change position and therefore a pixel has been created.

This is from producer Eink: “The two pigment electronic ink system is made up of millions of tiny microcapsules, each about the diameter of a human hair. Each microcapsule contains negatively charged white particles and positively charged black particles suspended in a clear fluid. When a positive or negative electric field is applied, corresponding particles move to the top of the microcapsule where they become visible to the viewer. This makes the surface appear white or black at that spot“.

Why is called paper display?

Because this kind of display has been massively used on e-paper reader like Kindle and Kobo. This e-reader is mainly used to read e-book in a black and white display like an old fashioned paper book.

Limitations and special property of Eink technology

In the past was able to display two color only: black and white. Now in the market is coming a multi color EPD display.

+++ Low energy consumption

No power needed to hold an image. No backlight needed (it is sunlight visible). Wide view angle (near 170° like OLED displays).

+++ Static image duration

“E Ink’s technology is commonly referred to as “bistable”. Bistablility refers to the fact that an image on an E Ink screen will be retained even when all power sources are removed. This means that the display is consuming power only when something is changing”.

+++ Flexyble

— High display refresh time

In the FAQ of Eink producer has been stated a 120 ms refresh rate. Adafruit EPD display have, at least, 180 seconds recommended refresh rate. WaveShare state 0,3 seconds for partial refresh. An e-paper display will use around 2 seconds each time it updates entirely its contents.

This new poducer claim a 30 Frame per Second refresh rate for full RGB colors display: ClearInk

Library for Arduino

From hardware point of view EPD display, like Eink producer, needs up to 15 Volt power supply. A special driver must be used to drive electrostatic charge that change the pixels status (Bi-stable). For Arduino application purposes we need an all in one, ready to use solution.

SPI port is mainly used to up-date the display image.

This are links to some library ready to use with an Arduino board:

– WaveShare products

– Adafruit products

– ZinggJM

– Adafruit LEARN

– Open source e-paper

Proof of working with Adafruit Library

Arduino UNO

I’m using the EPDTest file included into the example folder provided with the Adafruit Arduino Library. As a quick reference you can find Arduino UNO pinout diagram below:

This are the pins for setting data exchange (CONNECT the D12 pin to the display otherwise could not be work properly):

You must uncomment some code line related to the display size and type are you programming. In my case I’m going to use a 2,7 inch tri-color display.

Results

Below some text size capability:

Velocity for refreshing are:

How much Arduino UNO resources I need ?

The sketch use 12186 byte (37%) of total avalaible program space. Maximum is 32256 byte.
Globals variable uses 990 byte (48%) of the dinamic memory.

WARNING WARNING WARNING

Please set the e-Paper to sleep mode or power off it directly, otherwise, the e-Paper is damaged because of working in high voltage for long time.

You need to update the content of three-color e-Paper at least one time every 24h to avoid from burn-in problem.

Partial refresh: It don’t flicker if you use partial refresh (only some of the two-color e-paper support partial refresh). Note that you cannot use Partial refresh all the time, you should full refresh e-paper regularly, otherwise, ghost problem will get worse even damage.

What maker market offer ?

You can buy from 1’44 to 10’2 inch, in monochrome (Black and White) to 3 chrome (B+W+Yellow or Red). Some size of flexible are avalaible too.

How much this post worth ? 12 hours of work

Useful links & Credits for Eink display & Arduino

Eink company

Eink Blog

New technology fast rate refresh and full color EPD display

VIDEO Tutorial 7.5 inch

11 Myths about paper displays

Sizes

Produttore Europeo

Eink display IL0373-UC8151 driver controller

EPD display Driving Application Note

PiMoroni shop

WaveShare 1.54inch_e-paper_module_user_manual_en

How to make a font

Arduino blog

15 Projects

L'articolo Eink Paper Display for Arduino sembra essere il primo su Sciamanna Lucio.

Cos’è un QR Code o Codice QR ?

E’ un disegno composto da tanti puntini quadrati (bit) che tutti insieme memorizzano una informazione digitale. Il puntino nero è equivalente ad 1 bit di informazione digitale. Il puntino bianco, o l’assenza del puntino nero, è ancora una informazione digitale, in questo caso, di valore opposto al puntino nero.

Il primo esempio è un Codice che contiene il testo “QR Code”. Occupa 100 x 100 pixel.

L’esempio sotto è un micro QR Code. Si riconosce perchè ha un solo quadrato di centratura.

Un QR Code può memorizzare fino a 4296 caratteri alfanumerici. Il micro QR Code memorizza massimo 25 caratteri alfanumerici. Per fare un esempio il link del sito “https://www.sciamannalucio.it/” necessita di 29 caratteri alfanumerici.

A cosa serve ?

A memorizzare informazioni in forma grafica. Per leggere l’informazione si carica una specifica APP sul proprio telefonino smartphone. Si inquadra tutto il QR Code e la APP, o programma, restituisce il testo memorizzato.

Inventato dalla Giapponese Denso Wave è diventato molto utile e per questo è attualmente normato dalla ISO/IEC 18004:2006. La Denso Wave ha lasciato il brevetto libero con licenza gratuita.

Come integrarlo in una applicazione basata su Arduino ?

Bisogna scaricare una libreria adatta per Arduino. Per esempio questa sembra ben quotata anche sul forum ufficiale di Arduino:

Libreria Arduino per generare QR Code – RICMOO

Compilando la libreria per Arduino UNO il risultato è:

“Lo sketch usa 6458 byte (20%) dello spazio disponibile per i programmi. Il massimo è 32256 byte.
Le variabili globali usano 270 byte (13%) di memoria dinamica, lasciando altri 1778 byte liberi per le variabili locali. Il massimo è 2048 byte.”

Il file di esempio stampa sul monitor seriale un codice QR Code che descrive il testo “HELLO WORLD”. Il risultato appare come nella immagine che riporto sotto.

Provando a decrittare il contenuto con la app del mio smartphone il risultato è “03373101”, che non corrisponde al dato inserito nel generatore.

Riprovo con un altro testo da confrontare con i generatori online

Il testo è “QR Code”. Vediamo cosa esce dal monitor seriale di Arduino IDE:

Una cosa salta all’occhio: i quadrati di allineamento sono scorretti. Cambio la riga di codice che stampa i caratteri speciali e gli faccio stampare 1 e 0, come se fossero il contenuto digitale. Il risultato è di seguito:

Con il formato digitale e la libreria grafica Adafruit ecco quello che appare sul display Nokia 5110:

Se provi a scansionarlo con lo smartphone ti apparirà la scritta “QR Code”.

Programmi gratuiti online per generare un QR Code

Ce ne sono tanti ma quello che mi sembra molto completo, e gratuito, è questo:

Generatore Online gratis – NAYUKI

il file utilizza 302 byte

Questo è in alternativa e genera un file di 647 byte per memorizzare la stessa informazione, e cioè il testo “QR Code”.

Generatore Online gratis

Come creare con text editor un file immagine formato BitMap BMP

Questo è la struttura e come comporla per creare dal nulla un file immagine in formato BitMap BMP:

Vi servirà un programma per editare il file con formato “HEX”, come NotePad++ programma open source e gratuito (si deve aggiungere il plugin HEX Editor).

VIDEO come creare un immagine BitMap con Text Editor NotePad++

How much this post worth ? 8 hours

Link utili e Credits per “QR Code – Codice QR – Arduino”

Free Online generator

da Wikipedia

encoder C library

VIDEO come creare un immagine BitMap con Text Editor NotePad++

VIDEO Come creare un immagine BitMap con C++

A beginner guide to BitMap

Com’è fatto un file BitMap

L'articolo Generare i QR Code con Arduino e con programmi online sembra essere il primo su Sciamanna Lucio.

Questo sensore di distanza integra, in un singolo piccolissimo chip, un emettitore laser e un sensore a infrarossi IR. Per calcolare la distanza il chip misura il tempo trascorso tra l’emissione del fascio laser e la ricezione della luce, invisibile a occhio nudo.

Il laser ha una bassa Potenza di emissione ed è in classe 1.

E’ un alternativa ai sensori di distanza a ultrasuoni (tipo HC-SR04) o LED IR infrarossi.

Il chip costa circa 2€ per quantità di 5000 pezzi. Si può acquistare anche un solo chip al costo di circa 4€.

Come usare sensore di distanza con Arduino?

Il chip comunica la misura di distanza in formato digitale. Si deve utilizzare il protocollo di comunicazione I2C. Il produttore ST fornisce una libreria API da integrare nel Vostro firmware sviluppato con la IDE di Arduino.

Il chip funziona con una tensione di alimentazione continua di 2,8 Volt, pertanto se volete usarlo con schede Arduino UNO o MEGA dovete adattare i segnali digitali da 5V a 3 Volt.

Puoi usare una delle tante piccolo schedine che trovi in commercio. Sono già pronte per essere utilizzate su tutte le versioni delle schede Arduino.

Rimuovi il foglietto di plastica che protegge la parte ottica del sensore.

Se non lo fai avrai degli errori di misura di distanza.

Schema di collegamento

Download delle librerie per Arduino

DOWNLOAD Adafruit_VL53L0X-master

per avere la libreria più aggiornata clicca sul link: https://github.com/adafruit/Adafruit_VL53L0X

Dalla IDE di Arduino Strumenti -> Gestione Librerie, cerca nel filtro “Adafruit_VL53L0X” e clicca su “Installa”.

Programma la tua scheda con la demo che trovi negli esempi della libreria.

Verifica con il monitor seriale che cambiando la distanza alla quale hai posizionato un oggetto la misura di distanza varia.

Precisione misura di distanza con VL53L0X

Ci sono varie versioni di questo sensore di distanza integrato prodotto dalla ST. Il VL53L0X può rilevare oggetti a una distanza massima di 2000 mm, 200 centimetri, oppure 2 metri. Il campo di misura può essere impostato tramite software.

Il campo di misura standard è da 0 a 1200 mm.

La precisione nella misura di distanza varia a seconda del colore dell’oggetto posto di fronte al sensore. Il sensore è in grado, con una velocità minima di 33 millisecondi, di rilevare un oggetto ad una distanza di 1200 millimetri con un errore Massimo di 84 millimetri.

La precisione della misura varia in base alla distanza dell’oggetto posto di fronte al sensore.

Link e Video sul sensore di distanza VL53L0X a tecnologia laser scanner

Sensore di distanza a tecnologia LASER VL53L0X – ADAFRUIT product

Cos’è e come funziona un LIDAR

DOWNLOAD datasheet vl53l0x laser scanner sensor ST

Mouser al 26-04-19 circa 50’000 pezzi in pronta consegna

Articolo comparazione sensori vari (Francese)

DOWNLOAD libreria Pololu

L'articolo Sensore Distanza LIDAR Laser Scanner VL53L0X sembra essere il primo su Sciamanna Lucio.

Come usare

Con Arduino si intende una serie di schede a microprocessore. Un potenziometro digitale è un chip, che al suo interno, ha una serie di resistenze collegate come divisore di tensione.

Un potenziometro digitale possiede le seguenti caratteristiche:

• è un potenziometro a tutti gli effetti, ma non si deteriora con l’utilizzo
• per essere tarato non ha bisogno di un intervento manuale (girare il cacciavite)
• si programma con un microcontrollore
• può essere resinato e mantiene la possibilità di essere ri-tarato
• è meno sensibile all’umidità
• ha un profilo meno ingombrante di un tradizionale potenziometro
• è meno sensibile alle vibrazioni

Utilizzi del potenziometro digitale

• sostituzione dei potenziometri tradizionali
• ritardi, filtri e costanti di tempo programmabili
• controllo di volume e stereofonia
• compensazione delle impedenze di linea
• regolazioni negli alimentatori

  

Modelli di potenziometro digitale

I potenziometri tradizionali, diciamo analogici, si diversificano per almeno due caratteristiche principali:

• valore resistivo
• tipo di linearità: lineare/logaritmica

La progressione della resistenza tra il pin centrale e uno dei pin laterali è analogica, cioè procede in modo continuo tra 0 e il valore resistivo nominale massimo.

Nel potenziometro digitale la resistenza viene incrementata a scatti. Nel chip che compone il potenziometro digitale ci sono una serie di singole resistenze, collegate tra loro in serie. Il pin centrale viene collegato, tramite la programmazione, ai capi di un nodo tra due resistenze. Così si forma un partitore di tensione, che è l’utilizzo tipico di un potenziometro, detto anche reostato.

Il numero degli scatti/resistenze definisce la definizione che può avere il potenziometro digitale. Nei datasheet viene specificata in numero di bit.

Ci sono potenziometri con appena 6 bit, equivalenti a 64 scalini resistivi. Sono i componenti che costano meno. Altri modelli con 7, 8 o 10 bit (128, 256 0 1024 scalini resistivi).

Memorizzazione della programmazione

Un potenziometro digitale deve essere programmato. La programmazione può essere permanente o a memoria temporanea.

Permanente significa che il rapporto di partizione è memorizzato in una EEProm. Ogni volta che l’integrato viene spento, e poi riacceso, viene ripristinata la programmazione impostata in precedenza.

Memoria temporanea RAM significa che ogni volta che viene spento, e poi riacceso, l’integrato ripristina la programmazione di default. Solitamente coincide con una programmazione del partitore a metà corsa (pari resistenza tra il pin centrale e i pin laterali).

Tensione e corrente di lavoro

Un dato da valutare è la tensione applicabile al partitore. Normalmente la tensione massima applicabile è variabile da 2,7 a 5,5 Volt. Ci sono modelli con tensioni più elevate variabili dai 15 ai 30 Volt (sono anche più costosi).

La corrente di lavoro massima è quella che può scorrere all’interno del partitore resistivo interno all’integrato. E’ riportato in “Absolute Maximum Ratings” alla riga “Maximum current into A, W and B pins”. Può variare tra +/- 2,5mA fino a +/- 25mA.

Circuiti integrati potenziometro digitale

Nel modello MCP4018 e MCP4019 notate come il pin B è collegato insieme al pin dell’alimentazione negativa GND/Vss. Questo ne limita l’utilizzo solo ai circuiti partitori di tensione.

Programmare Arduino come potenziometro digitale

Un esempio lo trovate nella IDE di Arduino: File –> Esempi –> Wire –> digital_potentiometer

Questo programma utilizza il circuito integrato AD5171 potenziometro digitale. Viene utilizzato il metodo di scambio dati I2C.

// I2C Digital Potentiometer
// by Nicholas Zambetti <https://www.zambetti.com>
// and Shawn Bonkowski <https://people.interaction-ivrea.it/s.bonkowski/>
// Demonstrates use of the Wire library
// Controls AD5171 digital potentiometer via I2C/TWI
// Created 31 March 2006
// This example code is in the public domain.

#include <Wire.h>

void setup()
{
  Wire.begin(); // join i2c bus (address optional for master)
}

byte val = 0;

void loop()
{
  Wire.beginTransmission(44); // transmit to device #44 (0x2c)
                              // device address is specified in datasheet
  Wire.write(byte(0x00));            // sends instruction byte  
  Wire.write(val);             // sends potentiometer value byte  
  Wire.endTransmission();     // stop transmitting

  val++;        // increment value
  if(val == 64) // if reached 64th position (max)
  {
    val = 0;    // start over from lowest value
  }
  delay(500);
}

Datasheet potenziometro digitale

https://ww1.microchip.com/downloads/en/DeviceDoc/22096b.pdf

https://datasheet.lcsc.com/szlcsc/Microchip-Tech-MCP4018T-503E-LT_C145561.pdf

https://datasheet.lcsc.com/szlcsc/Microchip-Tech-MCP4011-503E-SN_C185531.pdf

https://www.tme.eu/en/Document/1c6d79496035ee640a410c41b872fd71/AD8400AR10-Analog-Devices.pdf

L'articolo Arduino come potenziometro digitale sembra essere il primo su Sciamanna Lucio.

I’m going to show what happen when you use Arduino C programming language on a STM32F401RE Nucleo board.

In the Arduino IDE are built in simple examples like:

• change the state of a GPIO pin (BLINK a LED)
• measure the voltage on a Digital input pin (BUTTON)
• measure a voltage by internal ADC converter
• send an information trough a Serial port
• show some data on a LCD display

You can find that programs example on:

• FILE -> EXAMPLES -> BASICS -> Blink
• FILE -> EXAMPLES -> BASICS -> DigitalReadSerial
• FILE -> EXAMPLES -> BASICS -> AnalogReadSerial
• FILE -> EXAMPLES -> LiquidCrystal -> HelloWorld

Installing STM32 Core devices on Arduino IDE

Before to use STM32 Core microcontroller by Arduino IDE editing and programming platform, you have to upload as a new Device the STM32 Core Devices.

To perform this task follow link: STM32Duino getting started

Pin compatibility to Nucleo STM32F401RE

The image below assign some STM32 Nucleo F401RE version board pin as used on Arduino UNO board (Green coloured labels). More info on Nucleo development board following link:

STM32 Nucleo-64 development board with STM32F401RE MCU, supports Arduino

Blink example

By powering On and Off alternatively one Arduino D13 aka Nucleo PA5 pin, you should see Green LED2 blinking (I noticed a labeling error on the official image above. LD1 is not attached to PA5/D13 pin, instead LD2).

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

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

How fast is the pure blinking (no delay added). I measured 2us per high + low transition as in the image below.

The speed of Arduino UNO pin is 7us per high + low transition as in the image below.

DigitalReadSerial example

Nucleo board read pin PC13 attached to “user B1” button. While button B1 is pressed LED2 is lit.

#define pushButton PC13  // digital pin Nucleo STM32F401RE
#define LED2 PA5              // digital pin Nucleo STM32F401RE

// the setup routine runs once when you press reset:
void setup() {
// initialize serial communication at 9600 bits per second:
Serial.begin(9600);
// make the pushbutton’s pin an input:
pinMode(pushButton, INPUT);
// make the LED2’s pin an output:
pinMode(LED2, OUTPUT);
}

// the loop routine runs over and over again forever:
void loop() {
// read the input pin:
int buttonState = digitalRead(pushButton);
// light the LED2 if button pressed
if(buttonState) digitalWrite(LED2, LOW);
else digitalWrite(LED2, HIGH);
// print out the state of the button:
Serial.println(buttonState);
delay(1); // delay in between reads for stability
}

If I try to use Serial monitor, Arduino IDE prompt an error. No communication is established. In my case could be due to:

• I’m using a Mac OS computer
• Nucleo board STLink is not updated
• some setting error

I spent some hours around this communication problem and I’m embarrassed to say I was not able to fix it.

AnalogReadSerial example

The ADC converter work fine as expected, but the resolution is limited to 1023 point as Arduino UNO AD converter.  Whole 12 bit ADC native resolution of STM32F401RE microcontroller it seem not to be used. Full scale input voltage is 3.3 V instead of 5 V.

In accordance with STM32F401RE datasheet there are 16 ADC inputs wired on pins (from my test only 11 ADC pin are usable):

• ADC_0 pin  –> PA0 OK  –> Arduino A0 (same reading showed on PA3)
• ADC_1 pin  –> PA1  OK –> Arduino A1  (same reading showed on PA2)
• ADC_2 pin  –> PA2 NA (no reading because connected to Serial Tx ???)
• ADC_3 pin  –> PA3 NA (no reading because connected to Serial Rx ???)
• ADC_4 pin  –> PA4  OK –> Arduino A2
• ADC_5 pin  –> PA5 NA (no reading ???)
• ADC_6 pin  –> PA6 NA (no reading ???)
• ADC_7 pin  –> PA7 NA (no reading ???)
• ADC_8 pin  –> PB0 OK  –> Arduino A3
• ADC_9 pin  –> PB1 OK (same reading showed on PA7)
• ADC_10 pin –> PC0  OK –> Arduino A5
• ADC_11 pin –> PC1  OK –> Arduino A4
• ADC_12 pin –> PC2 OK
• ADC_13 pin –> PC3 OK
• ADC_14 pin –> PC4 OK
• ADC_15 pin –> PC5 OK

All this pins are accessible by morpho connector, the twin double raw pin connectors located at the far left and right of Nucleo board.

Program used on this example Follow (I used Adafruit library because U8g2 library has not correctly showed characters):

/*********************************************************************
This is an example for our Monochrome OLEDs based on SSD1306 drivers

  Pick one up today in the adafruit shop!
  ------> https://www.adafruit.com/category/63_98

This example is for a 128x64 size display using I2C to communicate
3 pins are required to interface (2 I2C and one reset)

Adafruit invests time and resources providing this open source code, 
please support Adafruit and open-source hardware by purchasing 
products from Adafruit!

Written by Limor Fried/Ladyada  for Adafruit Industries.  
BSD license, check license.txt for more information
All text above, and the splash screen must be included in any redistribution
*********************************************************************/

#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);

unsigned int getAnalog (unsigned int port){
  pinMode(port, INPUT);
  return analogRead(port); 
}

void setup()   {                
  // by default, we'll generate the high voltage from the 3.3v line internally! (neat!)
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  // initialize with the I2C addr 0x3D (for the 128x64)
  // init done
}

void loop() {
  display.clearDisplay();
  
  display.setTextSize(2);
  display.setTextColor(WHITE);
  display.setCursor(0,0);
  display.print("ADCs test");
  
  display.setCursor(0,16);
  display.setTextSize(1);
  display.print("A0:"); display.print(getAnalog (PA0));
  display.print(" A1:");display.print(getAnalog (PA1));
  display.print(" A2:");display.println(getAnalog (PA2)); 
  display.print("A3:");display.print(getAnalog (PA3));
  display.print(" A4:");display.print(getAnalog (PA4));
  display.print(" A5:");display.println(getAnalog (PA5));
  display.print("A6:");display.print(getAnalog (PA6)); 
  display.print(" A7:");display.print(getAnalog (PA7));
  display.print(" B0:");display.println(getAnalog (PB0));
  display.print("B1:");display.print(getAnalog (PB1));
  display.print(" C0:");display.print(getAnalog (PC0)); 
  display.print(" C1:");display.println(getAnalog (PC1));
  display.print("C2:");display.print(getAnalog (PC2));
  display.print(" C3:");display.print(getAnalog (PC3));
  display.print(" C4:");display.println(getAnalog (PC4)); 
  display.print("C5:");display.print(getAnalog (PC5));   

  display.display();
  delay(200);
}

HelloWorld example

I hooked up a common LCD to my Nucleo board as in accordance with LCD Arduino tutorial.

I used an OLED SSD1306 display too. My display was an I2C data communication version, 128×64 pixel wide.  You can find info, example and library at Adafruit link: OLED SSD1306 getting started. I used adafruit Arduino library and U8g2 Arduino library too. You can add this library directly from Arduino IDE.

This example program worked fine with U8g2 library .

#include <Arduino.h>
#include <U8x8lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif

// Please UNCOMMENT one of the contructor lines below
// U8x8 Contructor List 
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8x8setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8X8_NULL u8x8;	// null device, a 8x8 pixel display which does nothing
//U8X8_SSD1306_128X64_NONAME_4W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1306_128X64_NONAME_4W_HW_SPI u8x8(/* cs=*/ 6, /* dc=*/ 4, /* reset=*/ 12);	// Arduboy (DevKit)
//U8X8_SSD1306_128X64_NONAME_4W_HW_SPI u8x8(/* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6);	// Arduboy 10 (Production, Kickstarter Edition)
//U8X8_SSD1306_128X64_NONAME_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8X8_SSD1306_128X64_NONAME_3W_SW_SPI u8x8(/* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
U8X8_SSD1306_128X64_NONAME_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE); 	      
//U8X8_SSD1306_128X64_ALT0_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE); 	      // same as the NONAME variant, but may solve the "every 2nd line skipped" problem
//U8X8_SSD1306_128X64_NONAME_SW_I2C u8x8(/* clock=*/ 2, /* data=*/ 0, /* reset=*/ U8X8_PIN_NONE); 	      // Digispark ATTiny85
//U8X8_SSD1306_128X64_NONAME_SW_I2C u8x8(/* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // OLEDs without Reset of the Display
//U8X8_SSD1306_128X64_VCOMH0_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but maximizes setContrast() range
//U8X8_SSD1306_128X64_ALT0_4W_HW_SPI u8x8(/* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but may solve the "every 2nd line skipped" problem
//U8X8_SSD1306_128X32_UNIVISION_SW_I2C u8x8(/* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8X8_SSD1306_128X32_UNIVISION_SW_I2C u8x8(/* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8X8_SSD1306_128X32_UNIVISION_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);   // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8X8_SSD1306_128X32_UNIVISION_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8X8_SSD1306_64X48_ER_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);   // EastRising 0.66" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8X8_SSD1306_48X64_WINSTAR_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);
//U8X8_SSD1306_64X32_NONAME_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);  
//U8X8_SSD1306_64X32_1F_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);  
//U8X8_SSD1306_96X16_ER_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);   // EastRising 0.69"
//U8X8_SSD1306_128X64_NONAME_6800 u8x8(13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8X8_SSD1306_128X64_NONAME_8080 u8x8(13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);

// End of constructor list

void setup(void)
{  
  u8x8.begin();
  u8x8.setPowerSave(0);    
}

void loop(void)
{
  u8x8.setFont(u8x8_font_chroma48medium8_r);
  u8x8.drawString(0,0,"--Hello World!--");
  u8x8.drawString(0,1,"0123456789ABCDEF");
  u8x8.drawString(0,2,"AaBbCcDcEeFfIiLl");
  u8x8.drawString(0,3,"MmNnOoPpQqRrSsTt");
  u8x8.drawString(0,4,"--Hello World!--");
  u8x8.drawString(0,5,"0123456789ABCDEF");
  u8x8.drawString(0,6,"AaBbCcDcEeFfIiLl");
  u8x8.drawString(0,7,"MmNnOoPpQqRrSsTt");
  u8x8.refreshDisplay();		// only required for SSD1606/7  
  delay(2000);
}

L'articolo How portable is Arduino C on STM32 Core ? sembra essere il primo su Sciamanna Lucio.

Arduino UNO and STM32 Nucleo

microprocessor board ?

Starting from the architecture of the microprocessor:

• Arduino UNO use the ATMEL ATMega328P microprocessor, an 8 bit BUS core with AVR advanced RISC architecture able to perform 1 MIPS per MHz (see wikipedia about MIPS).
• STM32 Nucleo F401 (this board will be used on future posts and investigations) use the ARM Cortex architecture, an 32 bit BUS core able to perform 1.25 DMIPS per MHz.

The STM32F401 ARM architecture perform better than ATMega328P compared to the same oscillator frequency.

Differences in price per quantity between microcontroller (at the time of this post):

• ATMEL AVR ATMega328P = 1.23$ per 5’000 pieces
• STM32F401RE = 3$ per 10’000 pieces

The ATMega328P is near 1/3 less expensive than STM32F401

Numbers of I/O pin:

• ATMEL AVR ATMega328P = 23 Pins
• STM32F401RE = from 36 up to 81 Pins (all 5V tolerant)

The STM32F401 has near 3 times pins than ATMega328P

Main program memory

• ATMEL AVR ATMega328P = 32 kbytes Flash
• STM32F401RE = 512 kbytes Flash

The STM32F401 has near 16 times more program memory capacity than ATMega328P

RAM memory

• ATMEL AVR ATMega328P = 2 kbytes SRAM
• STM32F401RE = 96 kbytes SRAM

The STM32F401 has near 48 times more RAM memory capacity than ATMega328P

Numbers of  AD converter pins:

• ATMEL AVR ATMega328P = up to 6 to 8 channels
• STM32F401RE =up to 16 channels

The STM32F401 has near 2 times ADC channels than ATMega328P

AD converter resolution:

• ATMEL AVR ATMega328P = 10 bit (1024 points of resolution)
• STM32F401RE =12 bit (4096 points of resolution)

The STM32F401 has near 4 times analog to digital converter resolution than ATMega328P

Power supply voltage:

• ATMEL AVR ATMega328P = 1.8 to 5.5 Volt
• STM32F401RE = 1.7 to 3.6 Volt

The STM32F401 need a lower power voltage than ATMega328P

Compatibilty with Arduino IDE programming suite:

• ATMEL AVR ATMega328P = NATIVE 100% compatible
• STM32F401RE = an STM32 CORE must be added to the IDE programming suite

The STM32F401 is less Arduino IDE compatible than ATMega328P

Numbers of USART ports:

• ATMEL AVR ATMega328P = 1
• STM32F401RE = up to 3

The STM32F401 has near 3 times USART ports than ATMega328P

L'articolo Arduino UNO & STM32 Nucleo: which differences ? sembra essere il primo su Sciamanna Lucio.

Al momento non sono riuscito a trovare la STM32 Core tra le schede supportate per la programmazione tramite la IDE di Arduino.

Pro e contro alla web IDE di Arduino

Al di là che devi iscriverti, la contropartita è che i tuoi file sono di proprietà del sito internet e del cloud dove vengono custoditi i file che hai creato. Questo non è un problema per l’hobbista, ma per un azienda può diventarlo. La piattaforma ti permette di scaricare e salvare sul tuo computer i programmi/sketch da te creati (questo è positivo). Poi per riutilizzarli avrai bisogno di un programma installato sul tuo computer, oppure dovrai di nuovo utilizzare la piattaforma Web. Questo meccanismo potrebbe portare a problemi di portatilità.

Come è già successo con idee del genere, ad un certo punto se l’operazione ha successo incominceranno a chiederti in cambio qualche contributo in denaro. Al peggio se non sarà un successo chiuderanno l’applicazione, con la possibilità di perdere i tuoi lavori.

Facilità di utilizzo

Entra nella videata iniziale cliccando su getting started. Il browser consigliato è Google Chrome, ma vengono citati anche gli altri maggiori browser conosciuti.

Al momento della stesura di questo post funziona con i seguenti sistemi operativi:

• Windows 10
• Mac OS High Sierra
• Ubuntu last LTS release
• Chrome Os

Per cui è necessario un sistema operativo di ultima generazione (al momento della stesura di questo post).

C’è un video che velocemente fa vedere come si usa la piattaforma di programmazione Arduino web IDE.

Devi iscriverti alla piattaforma tramite il link iscrizione. Dopo l’accesso entri in questa schermata che trovi nel sito www.arduino.cc in -> Software -> Online Tools.

Dovrai scaricare ed installare, come amministratore, il/i programmi per far in modo che il computer riconosca la scheda elettronica e trasmetta i dati, tramite HTTP, al cloud/server dove è in funzione il programma IDE Web. Diciamo che devi installare dei driver.

Se riesci ad installare i driver correttamente, puoi iniziare ad utilizzare la applicazione per programmare le tue schede Arduino.

Arduino Web Editor

Ci sono 6 icone da cui puoi cliccare sul Arduino Web Editor, che equivale alla IDE di Arduino.

Appare la videata che vedi nell’immagine sotto.

Cliccando sulla icona, come nell’immagine sotto, hai accesso a tutti gli esempi che trovi nella IDE di Arduino.

Cliccando su Basics(6) -> Blink, come in figura, si carica il programma nella finestra di editing.

Finestra di editing riempita con il programma Blink.

Adesso selezionate la scheda su cui volete programmare il vostro software, cliccate sulla freccia -> e se tutto va bene la vostra scheda Arduino funzionerà come voluto.

L'articolo Arduino Web IDE STM32 Core sembra essere il primo su Sciamanna Lucio.

Cos’è la RoboCup Junior ?

La RoboCup è una competizione a squadre che utilizzano robot autocostruiti. I robot della versione Junior devono risolvere 3 tipologie di problemi descritti dalle categorie:

• rescue: trovare e salvare vite umane. I robot localizzano le vittime in un scenario da disastro. le difficoltà variano dal seguire una linea su una superficie piana, a evitare ostacoli su terreni accidentati.
• soccer: i robot giocano a calcio. Due squadre formate da due robot si sfidano in una partita di calcio.
• onStage (former dancer): uno o più robot insieme a persone, si muovono in modo creativo, collaborativo e interagiscono tra loro.

l’intento di questa competizione è l’introduzione del mondo dei robot, e della programmazione di intelligenza artificiale, nelle scuole primarie e secondarie. Vengono enfatizzati gli aspetti di cooperazione, risoluzione dei problemi (problem solving), e completamento degli obiettivi.

Chi può partecipare ?

Il progetto RoboCup ha come scopo avvicinare i ragazzi alla tecnologia. L’eta minima dei partecipanti alle gare internazionali è di 11 anni, quella massima è 19 anni. Il 1 Luglio è il giorno del passaggio dell’età anagrafica.

I partecipanti alle gare, oltre alla specialità scelta tra rescue, soccer e onstage, vengono divisi per categorie di età. La categoria primary comprende ragazzi fino a 14 anni di età. La categoria secondary è per i ragazzi con età maggiore di 14 anni.

La competizione vuole avvicinare gli studenti alla tecnologia, ed in particolare all’elettronica ed alla programmazione software legata ai robot. Lo scopo è anche creare dei gruppi di lavoro che appassioni e aumenti l’interesse e le competenze dei giovani.

Le principali regole ?

Ogni categoria ha le sue specifiche regole per accedere e partecipare alla competizione.

Rescue

I robot identificano le vittime all’interno di uno scenario di disastro ricreato artificialmente.  Devono seguire percorsi guidati da linee su un terreno piano (line follower), o evitare ostacoli su terreni accidentati.

• dimensione della squadra (team): minimo 2 massimo 5 ragazzi. Non possono essere prestati ad altri gruppi ne membri del gruppo, ne robot.
• ruolo dei membri della squadra: ogni membro della squadra deve avere un preciso ruolo tecnico.  Per esempio: progettazione e costruzione del robot, attuatori e sensori, programmazione. I ruoli devono essere identificati all’atto della registrazione della squadra. Ogni membro della squadra deve essere in grado di spiegare la sua funzione tecnica ai giudici della gara.
• comunicazione tra robot: i robot possono comunicare informazioni solo tra robot. Sono autorizzati ad utilizzare la tecnologia Bluetooth classe 2 e 3 (distanza massima di trasmissione 20 metri) o ZigBee. La squadra è responsabile del corretto uso delle comunicazioni.

La categoria “rescue” è divisa in specialità che sono:

• rescue line rules
• rescue line SuperTeam rules
• rescue Maze (labirinto) rules
• rescue Maze SuperTeam rules
• CoSpace rescue rules
• CoSpace rescue interview sheet

Specialità “Rescue line rules”

Il robot deve seguire una linea superando differenti difficoltà. Sotto è riportato un esempio di campo di gara.

Il campo di gara è composto da un minimo di 8 quadrati di 30 x 30 cm (tile) con disegnata una linea nera su sfondo bianco. La linea può essere continua oppure interrotta da buchi (gap) o incroci (intersection). Di seguito sono riportati le varie tipologie di “tile”.

LINE GAP = 10 punti

Una linea dritta può essere interrotta (gap) fino ad una lunghezza massima di 20 cm. La lunghezza minima di una linea dritta è di 5 cm. Ogni volta che il robot supera, e ritrova, la linea interrotta guadagna 10 punti. I punti vengono assegnati per ogni “tile”.

difficoltà	punteggio
	10 punti

INTERSECTION = 15 punti

Per ogni “tile” superato e dotato di intersezioni vengono assegnati 15 punti.

SOBBALZI/BUMPS = 5 punti

massima altezza dei sobbalzi = 1 centimetro. Possono essere posizionati in modo inclinato rispetto alla linea nera.

difficoltà	punteggio
	5 punti

OSTACOLI = 10 punti

Gli ostacoli posso essere costituiti da mattoni, blocchi, pesi e oggetti pesanti. La minima altezza degli ostacoli = 15 centimetri. Ne può essere messo solo 1 per “tile”. L’ostacolo non occupa più di una linea. Ci si aspetta che il robot aggiri l’ostacolo. In caso il robot sia i grado di spostare l’ostacolo, questo viene lasciato nella sua nuova sede anche se intralcia il percorso.

difficoltà	punteggio
	10 punti

CHECK POINT superato = 3 punti per tile

Al raggiungimento di ogni checkpoint (pallino rosso) si calcolano 3 punti per ogni tile superato. Ogni volta che si fa ripartire il robot, il valore di ogni tile è diminuito di una unità.

VITTIME SOCCORSE = 40 punti 

Ogni vittima soccorsa (equivalente ad una pallina aggiunta nell’area di evacuazione dal bordo nero) da diritto a 40 punti.

Soccer

OnStage

 
Pubblicità

Riferimenti e Link

Il migliore riferimento è il sito dell’associazione RoboCup dove si trovano le regole per partecipare alla competizione.

Papert – Mindstorm: imparare la geometria costruendo qualcosa di significativo per il bambino.

Howard Gardner – Frames of mind: teoria delle intelligenze multiple.

L'articolo RoboCup Junior: le regole della competizione sembra essere il primo su Sciamanna Lucio.

Come usare un

sensore di colore

RGB con Arduino

Come si formano i colori

Quando hai l’esigenza di “leggere” o discriminare un colore devi usare uno speciale sensore chiamato, per l’appunto, sensore di colore. Questa occasione può essere tra le più disparate. Nel mio caso mi sono trovato a dover discriminare il verde, dal bianco e dal nero, per fare un percorso di RoboCup Rescue.

Interfacciare un sensore di colore alla scheda Arduino è un po’ come interfacciare un sensore ad un microprocessore. Avremo bisogno di “misurare” una intensità di segnale che dipende dal colore che “incontra” il sensore che abbiamo scelto.

Ci facciamo aiutare dalla fisica per richiamare il concetto di colore: è una “frequenza di energia luminosa”. L’arcobaleno è il risultato della scomposizione della luce bianca nelle sue componenti di frequenza di colore (spettro luminoso).

Quando illumino un oggetto con luce bianca, l’oggetto assorbe le frequenze luminose in base alla sua particolare forma o materiale. L’oggetto riflette il resto delle frequenze luminose, ed il risultato è il colore che viene percepito dal nostro occhio, che per inciso mischia automaticamente le frequenze luminose e crea la percezione di un unico colore.

I colori RGB

E’ importante comprendere come si forma il colore per capire come funziona questo sensore. Nei computer esiste un formato, chiamato RGB, che definisce un colore con tre numeri che misurano l’intensità dei tre colori principali Red-Green-Blue (in italiano Rosso-Verde-Blu).  Mischiando questi tre colori, con proporzioni variabili, si ottengono i vari colori intermedi. L’intensità di ogni colore principale viene suddivisa con una scala di 256 livelli. Questo si trasforma in un numero che varia tra 0 e 255 (in esadecimale da 0x00 a 0xFF).

Un singolo colore viene definito da tre coppie di numeri esadecimali che variano tra 0x000000 (nessun colore = Nero) e 0xFFFFFF (tutti i colori che mischiati formano il Bianco). Per Arduino questo si traduce in un numero che varia tra 0 e 16’777’215.

Sfruttando questo concetto usiamo tre differenti LED in modalità di generatori attivi, e misuriamo l’uscita elettrica degli stessi quando investiti dalla luce riflessa dall’oggetto di cui ci interessa rilevare il colore.

I tre LED saranno di colore Rosso, Verde e Blu e verranno interfacciati con un amplificatore operazionale di modo che la poca corrente che generano viene trasformata in tensione proporzionale alla luce che li colpisce.

Sensore di colore analogico

Abbiamo stabilito che un led di colore definito è sensibile alla frequenza di luce corrispondente. Il LED viene normalmente utilizzato per generare luce, ma può essere utilizzato al contrario, cioè misurare l’intensità di luce che lo colpisce.

La corrente generata da un LED colpito dalla luce è molto bassa e dipende dalla superficie totale utilizzata per produrre il semiconduttore (LED chip). Nella misura effettuata con multimetro sono risultati 29 uA.

Realizzato con semplici LED e fototransistor

I fototransistor sono dotati di un amplificatore interno che aumenta questa corrente. I normali diodi LED devono essere amplificati. Il circuito è semplicemente un amplificatore operazionale utilizzato come amplificatore di corrente. L’amplificatore deve avere la possibilità di funzionare con una tensione singola di 5 Volt, così può essere alimentato con la tensione della scheda Arduino ed essere direttamente compatibile con gli ingressi analogici.  Un amplificatore integrato adatto a questo circuito è il LT1006.

La resistenza R1 determina il fattore di amplificazione della corrente generata dal LED usato come sensore di colore. Questo valore dipende da quanta corrente genera il LED ad una determinata intensità di luce. Dovrai provare partendo dal valore indicato. Aumentando il valore della resistenza aumenti la sensibilità del sensore, cioè misuri luci più deboli.

Circuito elettrico sensore di colore analogico

Con una resistenza R1 di valore 1 MΩ si ha un fattore di amplificazione Av = 1’000’000 (la banda passante, cioè la velocità di lettura della luce, dipende dall’amplificatore usato). Se, come nella misura precedente, il LED genera 29 uA (che corrispondono a 0,000029 A) la tensione di uscita dall’amplificatore operazionale sarà di  1’000’000 x 0,000029 = 29 Volt.

Spettro cromatico e sensibilità ai colori

Ogni LED ha la sua sensibilità al colore. Dovrai provare alcuni LED in modo da verificare se vanno bene per la tua applicazione. I LED con il corpo trasparente sono consigliabili in quanto non sono dotati di filtro di colore.

Ogni LED ha un angolo di maggiore sensibilità, che può variare tra i 8° e i 120°. I LED con angolo di illuminazione stretto (Narrow angle Beam) a parità di corrente di alimentazione illuminano più lontano.

Ci sono altri modi di misurare il colore per esempio usando i led RGB (cioè che hanno tutti e tre i LED Rosso, Verde e Blu integrati in un chip) e un sensore di luce a fotoresistenza. La fotoresistenza non ha bisogno di esser amplificata e può essere utilizzata direttamente come partitore di tensione. Ci sono chip integrati come il S9702 della Hamamatsu che sono dotati di LED RGB con una grande area di esposizione alla luce.

Circuito elettrico con fotoresistore

La fotoresistenza ha una sensibilità su un ampio spettro luminoso e questo ci obbliga ad usare LED colorati per generare la luce con il cromatismo/colore desiderato. E’ un metodo che necessita di una taratura preventiva (pesatura) della luce ambiente.

Ha il vantaggio di usare un numero molto limitato di componenti elettronici. Come funziona? Si accende un LED di colore diverso ed ogni volta si misura il valore della fotoresistenza, tramite l’ingresso Analog In di Arduino. Si può realizzare una variazione utilizzando un fototransistor al posto del fotoresistore. Questo sistema migliora sensibilmente quando accoppiato ad una schermatura nera che “intuba” la luce riflessa dall’oggetto.

Sensore di colore digitale

I sensori di colore digitali usano lo stesso principio descritto in precedenza, ma forniscono una informazione pronta all’uso e non necessitano di circuiti analogici. L’informazione viene letta per esempio attraverso la comunicazione I2C.

Puoi trovare molte schede già pronte per essere utilizzate con Arduino o altri microprocessori.

Questi circuiti si basano su Chip integrati: TSC3200, TCS34725, ISL29125.

TSC3200

è un chip che contiene 16 LED in parallelo per ogni colore RGB + il bianco. La misura del colore viene trasmetta tramite un segnale PWM a frequenza proporzionale alla intensità luminosa. I LED devono essere selezionati tramite i pin S2 e S3. Funziona con una tensione da 2,7 a 5,5 Volt. Usando un divisore di frequenza integrato, e attivato tramite i pin S0 e S1, la intensità di luce viene convertita in una frequenza di fondo scala che varia tra 12 kHz fino ai 600 kHz.

La sensibilità ed il fondo scala variano dai 35 ai 47 uW/cm2 (dagli 0,35 ai 0,47 W/m2). Dal grafico della risposta spettrale noto che c’è una debole differenza nel riconoscimento del blu e del verde. La scheda integra anche 4 LED bianchi per l’illuminamento dell’oggetto da misurare. Arduino dovrà essere programmato per “leggere” la frequenza in uscita da questo chip con la funzione “pulseIn(pin, polarità);”. Questa funzione ritorna la durata dell’impulso cioè mezzo periodo della frequenza da misurare. Per conoscere la frequenza si deve applicare la formula 1/(Ton+Toff), da cui 1/(2*pulseIn).

TCS34725

è una scheda pronta all’uso per Arduino. E’ dotata di un sensore RGB con una sensibilità di contrasto di 3’800’000 : 1. I LED sono filtrati per non misurare la luce IR. La alimentazione varia dai 3,3 ai 5 Volt. Può essere usata sia on microprocessori con bus da 3,3V che 5V. Ha un LED bianco neutro che può essere usato per illuminare l’oggetto da misurare. La trasmissione dei dati avviene tramite la comunicazione I2C. Qui un tutorial su questo sensore RGB. Grazie alla sua alta sensibilità può essere utilizzato dietro vetri scuri. E’ dotato di un uscita interrupt che può essere utilizzata per comunicare velocemente al microprocessore quando è attivo un livello di luce prestabilito. E’ dotato di una libreria direttamente utilizzabile con Arduino.

ISL29125

Questo integrato è simile al TCS34725 in quanto ha delle caratteristiche simili e trasmette i dati con il protocollo I2C. Lavora con tensione a 3,3V, per cui servirà un traslatori di segnale per le comunicazioni a 5 Volt. La scheda non è dotata di LED bianco di illuminazione dell’oggetto.

Programma Arduino per sensore di colore

Al momento ti rimando ai produttori delle schede già pronte. Nella prossima puntata realizzerò il circuito analogico più semplice e valuterò le caratteristiche e le prestazioni che si possono ottenere.

Pubblicità

Credits

https://makezine.com/projects/make-36-boards/how-to-use-leds-to-detect-light/

https://forrestmims.org

LT1006 datasheet

Link al metodo di misura con fotoresistenza

ISL29125 datasheet

color phototransistor S9702 datasheet

TCS3200 datasheet

MTCSiCS datasheet

S9702 datasheet

TSC34725 datasheet

L'articolo Arduino sensore di colore sembra essere il primo su Sciamanna Lucio.

Quando ti serve trasmettere dei dati o accendere e spegnere degli apparati elettrici (apri cancelli, prese elettriche radio comandate, radio comandi RC, stazioni meteo, sonde di temperatura/umidità) puoi utilizzare Arduino abbinato a dei trasmettitori wireless. I trasmettitori Wireless utilizzano una frequenza portante, che può essere a 315-433 Mhz per modulare un segnale ad onda quadra.

Nel segnale ad onda quadra viene “scritto” il dato da trasmettere. Questi trasmettitori e ricevitori hanno un prezzo basso, ma per essere utilizzati necessitano di una interpretazione dei bit/dati trasmessi.Gli apparati a basso costo utilizzano dei chip integrati che servono a trasmettere un dato (Encoder) o a ricevere un dato (Decoder) quali per esempio: SC5262 / SC5272, HX2262 / HX2272, PT2262 / PT2272, EV1527, RT1527, FP1527 or HS1527 chipset.

Interpretare questi dati non è semplice e si devono utilizzare dei microprocessori. E’ per questo che vanno abbinati, per esempio, ad una scheda a microprocessore come quella della famiglia Arduino.

Ho parlato di famiglia perchè Arduino è il nome generico dato ad una serie di schede a microprocessore quali la UNO, la MEGA2560, la DUE e altre. Le schede hanno tutte un grado di compatibilità perchè utilizzano la stessa IDE (il software dove si scrive il programma di Arduino), e lo stesso linguaggio di programmazione semplificato per Arduino (linguaggio C++). Per il resto hanno forme, dimensioni e microprocessore diversi e partono dalla piccola e meno potente Arduino UNO, alla MEGA che ha molti più connessioni/pin della UNO e la DUE che è dotata di un microprocessore ARM a 32 bit.

Trasmettitori e Ricevitori wireless 315-433Mhz

Il trasmettitore di radio frequenza (onde radio) è dotato di almeno 3 pin/connessioni elettriche. Due servono ad alimentare la trasmittente radio. Il terzo è l’ingresso dei dati. Ogni trasmettitore deve avere un’antenna che propaga il segnale radio per le trasmissioni a distanza. La portata di un trasmettitore è la distanza massima raggiunta dal segnale radio e ricevuto correttamente dal ricevitore.

L’antenna ANT è un semplice filo elettrico con una lunghezza proporzionale alla frequenza di trasmissione. Un trasmettitore a 315 Mhz ha un antenna più lunga di un trasmettitore a 433 Mhz. Nel trasmettitore della immagine sopra deve essere collegata ancora l’antenna che va saldata nel foro vicino alla scritta ANT. Una semplice antenna per un trasmettitore a 433 Mhz (stessa cosa vale per il ricevitore) è un filo in rame diametro 1mm e lungo 16,5 cm.

Puoi trovare un interessante trattato sulle antenne qui. Ricordati che l’antenna del trasmettitore e del ricevitore devono essere inclinate nello stesso identico modo. La cosa migliore è posizionarle in verticale.

Il ricevitore è un modulo più complesso/ingombrante e di solito ha almeno 4 pin di collegamento elettrico. 2 per l’alimentazione, 1 per l’antenna ricevente e uno per l’uscita dei dati. Nell’immagine sotto un ricevitore della ditta Aurel con le funzioni dei pin spiegate in dettaglio. Questo ricevitore è dotato di un uscita che misura la intensità del segnale radio ricevuto (Pin 13 Test Point).

Collegare Arduino al ricevitore/trasmettitore radio

Prima di collegare i moduli radio alla tensione di uscita 5V della scheda Arduino verificare/essere sicuri che i moduli hanno una tensione di alimentazione di 5V (e non di 3,3V o altra tensione). La libreria che decodifica i dati trasmessi/ricevuti funziona con uno speciale pin di Arduino chiamato “interrupt”. Per cui il segnale dei dati va collegato solo ad alcuni pin chiamati INT  seguiti da un numero, che per le schede Arduino UNO può essere INT0 e INT1.

I pin della alimentazione positiva dei moduli radio vengono chiamati Vcc/V+ e vanno collegati al pin della scheda Arduino chiamato 5V. I pin Ground/GND vanno collegati al pin GND (polo negativo di alimentazione). Il pin DATA/Data OUT va collegato ad un pin della scheda Arduino avente la funzione interrupt (DIGITAL Pin) per il ricevitore radio e ad un qualunque Digital Pin per il trasmettitore.

Libreria Arduino RC Switch

Questa libreria non è standard, per cui dovrete installarla nella directory della IDE di Arduino. Con questa libreria puoi inviare un dato codificato al modulo radio trasmettitore, o ricevere un dato e decodificarlo. Può gestire più protocolli di comunicazione/codifica dei dati in modo automatico. In basso vedi la forma d’onda (come varia la tensione sul pin della scheda Arduino) del segnale/dato codificato. Dopo un segnale di sincronismo (dopo un impulso positivo la tensione rimane a zero Volt per un certo tempo) il segnale diventa positivo 5V per un lasso di tempo e negativo 0 Volt per altro tempo.

Nel caso di questa libreria il segnale di sincronismo appare alla fine della trasmissione dei dati. Il rapporto che esiste tra il tempo del segnale positivo e quello negativo determina se è stato inviato un dato/bit a livello logico 1 oppure 0. La libreria misura la durata dei segnali e stabilisce se sono bit 1 oppure 0 ed impacchetta tutta la sequenza in modo da formare un numero per noi comprensibile. Qui il link al blog dell’autore di questa libreria SUI77.

Questa libreria è stata creata per accendere o spegnere a piacere delle prese elettriche radio comandate. Con un pò di prove si può adattare ad altri utilizzi, ad esempio per ricevere dati da una stazione meteo. Si usa con protocolli dei chip set SC5262 / SC5272, HX2262 / HX2272, PT2262 / PT2272, EV1527, RT1527, FP1527 or HS1527, e le prese radio comandate “Intertechno”.

Questa libreria può essere utilizzata in modo generico per trasmettere e ricevere dati per un massimo di 24 bit.

Ho provato la libreria, ma a me non funzionava la ricezione dei dati. Dopo aver “letto” tutto il codice che forma la libreria ho apportato alcune piccole modifiche e sono riuscito a vedere funzionare correttamente il mio progetto.

Programma per inviare un dato

/*
 Esempio di trasmissione dati (accende e spegne una presa comandata)
 
 https://code.google.com/p/rc-switch/
 
 www.sciamannalucio.it 

*/

#include <RCSwitch.h>

RCSwitch mySwitch = RCSwitch();

void setup() {

 Serial.begin(115200);
 
 // Il trasmettitore radio è connesso al DIGITAL Pin #13
 // il Pin è a tua scelta dal 4 al 13 
 mySwitch.enableTransmit(13);

 // Optional set pulse length.
 // mySwitch.setPulseLength(320);
 
 // Optional set protocol (default is 1, will work for most outlets)
 // mySwitch.setProtocol(2);
 
 // Numero di ripetizioni del dato trasmesso (minimo 4).
 mySwitch.setRepeatTransmit(4);
 
}

void loop() {

 // Per le prese radio comandate il primo numero
 // individua il gruppo di prese, mentre il secondo
 // individua la presa. Si possono avere da 1 a 4 gruppi
 // per un massimo di 4 prese radio comandate per gruppo
 /* See Example: TypeA_WithDIPSwitches */
 mySwitch.switchOn(1, 1);
 delay(1000);
 mySwitch.switchOff(1, 1);

 delay(5000);
}

Programma per ricevere un dato

/*
 Semplice esempio di ricezione dei dati
 
 https://code.google.com/p/rc-switch/
 
 www.sciamannalucio.it

*/

#include <RCSwitch.h>

RCSwitch mySwitch = RCSwitch();

int RX_Pin = 2; // DIGITAL Pin 2 da collegare alla ricevente radio

void setup() {
 Serial.begin(115200); // imposta il baud del monitor seriale a 115200
 // Il ricevitore radio è connesso al DIGITAL Pin #2
 // il Pin è a tua scelta tra 2 e 3 
 mySwitch.enableReceive(RX_Pin); // collega il Pin con funzione interrupt
}

void loop() {
 // Se è arrivato un dato
 if (mySwitch.available()) {
 // memorizza il dato
 int value = mySwitch.getReceivedValue();
 // Se il dato vale zero
 if (value == 0) {
 Serial.print("Unknown encoding");
 // altrimenti
 } else {
 Serial.print("Received ");
 Serial.print( mySwitch.getReceivedValue() ); // stampa il dato ricevuto
 Serial.print(" / ");
 Serial.print( mySwitch.getReceivedBitlength() ); // stampa il numero di bit 
 Serial.print("bit ");
 Serial.print("Protocol: ");
 Serial.println( mySwitch.getReceivedProtocol() ); // stampa il protocollo
 }
 // ri-arma la ricezione dei dati
 mySwitch.resetAvailable();
 }
}

Per verificare  sia la trasmissione che la ricezione dei dati ho utilizzato due schede Arduino UNO. Una scheda è programmata per la trasmissione, mentre la seconda per la ricezione. Ho collegato il DIGITAL Pin 13 della scheda programmata per la trasmissione, al DIGITAL Pin 2 della scheda programmata per la ricezione. Quando tutto funziona vedrai il dato trasmesso nel riquadro del monitor seriale. Il numero ricevuto a destra della scritta “Received” è quello che è stato trasmesso.

Per conoscere questi comandi, sotto forma di numero, devi mettere in ricezione una scheda e accendere/spegnere le prese comandate (la scheda deve essere collegata alla ricevente radio via il DIGITAL Pin 2). Così facendo “sniffi” il comando e lo memorizzi nel tuo programma.

Ho provato ad utilizzare una sola scheda che fungeva sia da trasmissione che di ricezione, ma non ha funzionato. Probabilmente, per come è costruita la routine di trasmissione (con l’uso di delay), si allungano i tempi del bit trasmesso e questo non permette il corretto riconoscimento dei bit.

Impostazioni delle prese radiocomandate

Alcune prese radio comandate offrono la possibilità di impostare sia il gruppo che il numero a cui sono assegnate. In basso un esempio. A sinistra il telecomando ha la possibilità di impostare il gruppo (attraverso il dip switch) tra 1 e 5. A destra la presa comandata ha la possibilità di essere inserita nel gruppo 1 fino al 6. Poi va abbinato il tasto A, B, C, D. Il tutto viene impostato spostando i piccoli interruttori bianchi del dip switch.

Link utili, informazioni e crediti

• download della libreria gratuita Arduino IDE open source RCSwitch
• tutorial su come utilizzare i moduli di trasmissione wireless con Arduino
• come utilizzare gli interrupt delle schede Arduino
• descrizione approfondita sull’uso degli interrupts delle schede Arduino
• codifica Manchester
• RC wireless + WiFi + Ethernet (credits immagine)
• Decoder-Encoder SC5262 datasheet
• progetto stazione meteo wireless + Arduino
• datasheet decoder-encoder Texas Instrument TRC1300
• datasheet decoder-encoder Holtek HT12

L'articolo Arduino e radio comandi RC wireless sembra essere il primo su Sciamanna Lucio.