Diario elettrico GreenGo Icaro: il CAN-BUS
La centralina della mia Icaro ha il CAN-BUS abilitato (notare che l’abilitazione fa lievitare il costo di 80 euro su 800 al momento dell’ordine), il che significa che è possibile collegarsi con un paio di fili alla centralina per leggere molti dati interessanti.
Pare che dalla KHB72701 sia possibile leggere questi dati:
Pin del connettore J1:
- 5, 7, 13: GND/RTN
- 10: CAN bus high
- 11: CAN bus low
Per leggere i dati tramite una Arduino o simili è sufficiente un apposito shield:
- SeedStudio CAN-BUS Shield V2 – $25
- Elecfreaks CAN-BUS Shield – $12
- Sparkfun CANBUS shield – Robotitaly 713262 (Italia) – €25,00
- CAN BUS Shield For Arduino – Robotitaly 120370 (Italia) – €25,00
- Seedstudio CAN-BUS Shield V2 – Robotitaly 809151 (Italia) – €27,00
- Robotics3d SF-DEV-10039 (Italia) – €38,00
- AptoFun CAN-BUS Shield MCP2515 with TJA1050 – €9,00
In realtà è anche possibile che da qualche parte sia nascosto un connettore standard OBD, devo cercare bene sotto il cruscotto prima di avventurarmi nell’impresa.
Appunti ESP8266 – Come risolvere problemi di stabilità
Sembra che l’ESP8266 sia famoso per la sua instabilità, cioè la facilità con cui perde la connessione WiFi si resetta; queste ottime pagine spiegano come ovviare al problema: link1, link2.
Riassumendo:
- Il comando “delay()” resetta il WatchDog Timer (WD o WT); si tratta di un contatore che, se raggiunge un valore troppo alto (maggiore di 5 secondi e non modificabile), fa riavviare il dispositivo; è un sistema di sicurezza per evitare che il sistema, se si blocca, resti bloccato indefinitamente: in “sottofondo” è infatti sempre attivo un controllo hardware sul watchdog, anche quando uno sketch si blocca; se rimane bloccato per troppo tempo, il processore va in autoreset e quindi lo sketch si riavvia; quindi lo sketch deve essere predisposto per potersi riavviare da solo senza l’intervento dell’utente.
- Forse anche il comando wdt_feed() resetta il watchdog, ma probabilmente è un comando dell’SDK di ESP, quindi per utenti evoluti.
- Utilizzando l’ESP8266 come access point (ossia come router o come sever), bisogna evitare di gestire l’attesa dei comandi web durante alla funzione standard loop(), perchè sembra che la loop() interferisca con i meccanismi del wifi; bisogna invece implementare una funzione di callback che viene chiamata quando il client connesso all’ESP gli invia un comando (sketch di esempio: link).
- La connessione WiFi può spesso cadere senza motivo, quindi uno sketch deve sempre prevedere nella funzione loop() un monitoraggio della connessione, per ristabilirla se cade.
Queste righe servono a verificare se è attiva la connessione tra l’ESP e un router, non tra un dispositivo e l’ESP:
while (WiFi.status() != WL_CONNECTED) {
Serial.print(“.”);
delay(500);
}
Quindi vanno dopo la riga:
WiFi.begin(ssid, password);
Dove “ssid” è il nome del router.
Invece, per rilevare la connessione di un dispositivo bisogna usare questo codice:
#include <ESP8266WiFi.h>
WiFi.disconnect(true); // Più che disconnettere, cancella dalla PROM i parametri di connessione usati finora;
WiFi.persistent(false); // Evita che tali parametri vengano poi memorizzati
WiFi.mode(WIFI_AP); // Imposta la modalità di connessione su Access Point
WiFi.softAP(ssid); // Imposta il nome della rete e accende l’access point (senza password)
delay(1000); // Ritardo per azzerare il watchdog
WiFi.onEvent(WiFiEvent); // Rileva tutti gli eventi WiFi nella funzione “WiFiEvent(WiFiEvent_t event); - Quando usa il WiFi, l’ESP8266 ha bisogno di molta più corrente dei 500 mA che può fornire la porta USB di un PC, quindi va alimentato con un trasformatore.
- Anche utilizzare un adattatore USB/seriale può causare interferenze nel WiFi e perdita di connessione, quindi una volta terminate le prove, usare sempre un alimentatore per alimentare l’ESP.
- Ad ogni richiesta http GET proveniente da un client, l’ESP “perde un po’ di memoria (heap)”, per liberarla solo “dopo un po’ “, quindi non si può inondare l’ESP di richieste http GET, bisogna aspettare almeno due minuti tra l’una e l’altra (fonte).
- Un “bug noto” impedisce a SoftAP() di funzionare (cioè di impostare l’ESP come accesspoint) se l’ESP non è anche connesso a un router.
Esiste anche una libreria WiFi specifica che effettua la riconnessione automatica in caso di disconnessione, ma è per una Arduino collegata a un ESP:
https://github.com/ekstrand/ESP8266wifi
Programmare l’ESP8266 con Arduino IDE
Brevissimo tutorial su come rendere il NodeMCU Amica con ESP8266 ESP12 a bordo programmabile tramite IDE Arduino.
- Scaricare esp8266_flasher.exe.
- Scaricare i file del firmware ESP_Easy (*).
- Collegare il NodeMCU (ad esempio Amica o Lolin) al PC tramite USB
- Avviare l’IDE arduino per verificare quale porta sia stata associata al dispositivo (menu Strumenti –> Porta)
- Aprire il monitor seriale di Arduino
- Premere e rilasciare il tasto reset sul NodeMCU per verificare se effettivamente il dispositivo comunica con l’IDE attraverso quella porta
- Chiudere l’IDE
- Avviare esp8266_flasher.exe
- Impostare il numero di porta
- Caricare il file .bin corretto, che dipende dalle dimensioni della flash a bordo del dispositivo (4MB o 4096 kbyte sull’ESP12, montato su Huzzah Adafruit, NodeMCU Lolin, NodeMCU Amica)
- Tenere premuto il tasto FLASH sul dispositivo, premere il tasto reset, rilasciare reset e rilasciare il tasto FLASH: in questo modo il dispositivo si predispone per la riprogrammazione (re-flashing)
- Cliccare DOWNLOAD: in realtà non verrà scaricato un file DA internet, ma inviato il firmware al dispositivo
- Attendere il completamento dell’operazione.
- Riaprire l’IDE di Arduino
- Ripetere il punto 11
- Caricare sul dispositivo uno sketch di esempio che stampi qualcosa sul monitor seriale
Metodo alternativo:
Per flashare il firmware è possibile usare direttamente anche il file eseguibile presente nel pacchetto ESP_Easy (*), che però è un po’ meno intuitivo. Una volta nota la porta a cui è collegato il dispositivo (v. punto 4 sopra) e la memoria disponibile (v. punto 10 sopra), mettere il dispositivo in modalità FLASH (punto 11 sopra), avviare esptool e indicare in sequenza il numero di porta, la dimensione della flash e la versione del fimware, cioè il numero dopo la “R” nel nome del file; ad esempio, ESPEasy_R108_4096.bin è la versione 108 per l’ESP da 4096 kbyte.
Nota: per scoprire quant’è grande la Flash RAM sul dispositivo si potrebbe usare questo comando:
esptool.py flash_id
Ma la cosa richiede di preinstallare e configurare un interprete python, che è una noia e una rogna, sto cercando un modo più semplice e alla portata di tutti.
(*) Il file .zip contiene vari file .bin, che sono firmware adatti a moduli ESP con Flash RAM di dimensioni diverse: 512 kbyte, 1924 kbyte, 4096 kbyte; ad esempio, il file ESPEasy_R108_1024.bin è per un ESP da 1024 kbyte (1Mbit); R108 è il numero di “build”, cioè di versione.
Collegamento di un CellLog8S/8m ad Arduino o a ESP8266
L’utente pa.hioficr sul forum https://endless-sphere.com/forums/viewtopic.php?f=14&t=20142 ha scoperto che è possibile leggere in tempo reale i dati di log di un CellLog (sia 8S con memoria che 8S senza memoria) semplicemente “agganciandosi” al pin TX dell’Atmel montato sul CellLog.
Questo significa che invece di spendere 40-50 euro per comprare un CellLog8S con memoria e infilarlo nel sottosella per poi aspettare di arrivare a casa per scaricare i dati letti, è in linea di principio possibile collegare al CellLog8M da 15 euro un ESP8266 da 8 euro che tramite Wifi invia dati a uno smartphone che li mostra in tempo reale sullo schermo durante la marcia; probabilmente è anche possibile scrivere un SW che legge i dati da più di un celllog contemporaneamente, sfruttando l’emulatore di porte seriali.
Questo è lo schema elettrico originale dell’autore:
Questa è una sua successiva modifica per implementare anche avvio del logging e reset del CellLog:
Di seguito la spiegazione del funzionamento che ho dedotto io dallo schema, inserita anche nella seconda edizione del mio libro “Guida alla costruzione di una batteria al litio per mezzi elettrici”, di imminente pubblicazione:
R1 = R4 = R6 = R7 = 220 ohm
R2 = R5 = 330 ohm
R3 = 4700 ohm
U1 = U2 = optocoupler/fotoaccoppiatore a 2 canali, 5V, 8 pin, uscita a fototransistor di tipo NPN (es. Vishay ILD615, Fairchild MCT61, Isocom ISP827,… )
Figura 127 – Rilevamento accensione
2. Passerà una corrente nel fotodiodo 1-2
3. Si accenderà il fototransistor 7-8
Il “cervello” del CellLog, un microcontrollore ATMEL, è dotato di un piedino di reset, che possiamo controllare tramite il nostro microcontrollore esterno; per farlo, al pin di reset colleghiamo il collettore del fototransistor 5-6 del secondo fotoaccoppiatore (pin 5); controlliamo questo fototransistor tramite il rispettivo fotodiodo 3-4, collegato al pin MCU_CL8.1_RESET del nostro microcontrollore esterno; basterà quindi mettere alto questo pin per mettere in conduzione il fotodiodo e il fototransistor e quindi resettare il CellLog.
Per far partire il logging è necessario premere per 3 secondi il pulsante 2 del CellLog (SW2); possiamo farlo fare al nostro microcontrollore esterno collegando l’interruttore in parallelo a un’uscita del secondo fotoaccoppiatore: quando sull’ingresso ci sarà una tensione di 5V (impostata via software), il fototransistor di uscita entrerà in conduzione chiudendo l’interruttore e avviando così il logging.
Datalogger per regolatori di carica EPSolar Tracer MPPT
Mi appunto un paio di link interessanti su come costruire o dove comprare cavi/interfacce per collegare un regolatore di carica EPSolar a un PC o a un logger standalone, invece che semplicemente al display “istantaneo” fornito di serie, che non memorizza niente:
monitoraggio mppt ep solar 40A
Datalogger Arduino per regolatore EP Solar
Questo sarebbe interessante se vendessero anche la sola interfaccia seriale:
GWL/Power Solar Controller Monitor for Tracer series (RS-232/USB)
Così si potrebbe collegare alla nuovissima versione (marzo 2014) di Ardulog, che ora oltre ad avere la SD Card incorporata ha anche l’RTC incorporato:
http://www.hobbytronics.co.uk/ardulog-rtc
Da notare che, nonostante serva un cavo di rete per collegare display e regolatore, NON è un interfaccia di rete ma un’interfaccia seriale a 12V, e collegare il cavo al regolatore e al PC significherebbe probabilmente bruciare la scheda di rete, che lavora a 3 o 5 V e con tutt’altro protocollo!
Ecco “Displog”, il DISPlay che LOGga!
Una volta domato il bastardo Ardulog, crearci nuove applicazioni è solo questione di fantasia!
Ecco quindi nascere DISPLOG, il primo display con logger incorporato, o logger con display incorporato, fate vobis:
DISPLOG – DISPLAY + LOGGER on SD card
La faccenda è molto semplice: il display grafico/alfanumerico 3110/5110 (aka Philips PCD8544) può essere pilotato tramite 5 soli pin (addirittura 4 in casi particolari), e su Ardulog ci sono 4 pin analogici disponibili (A1, A3, A4 e A5), più RX e TX (D0 e D1); quindi si tratta solo di giocherellare un po’ con le impostazioni di un banale sorgente di esempio sul playground, fare 5 saldature, ed ecco ottenuto un display che supporta le micro SD card!
Tutto quello che cè da fare è modificare le prime linee di codice in questo modo:
#define PIN_SCE 0
#define PIN_RESET 1
#define PIN_DC A3
#define PIN_SDIN A4
#define PIN_SCLK A5
Manca un PIN libero per accendere la retroilluminazione, ma Hobbytronics ha previdentemente predisposto due piazzole libere vicino ai due LED, quindi si può facilmente utilizzare il pin 5 o 13 per comandare la retroilluminazione.
Il pin analogico A1 rimane disponibile per collegare un qualunque sensore analogico.
Prima uscita pubblica per PowerDuino standalone ad Arduino day 2013
Oggi c’e’ stata la presentazione ufficiale al pubblico del progetto PowerDuino Standalone. Nato dopo lunghe vicissitudini durate addirittura un anno, e’ diventato possibile grazie a un Arduino Uno originale (al posto del clone Luigino usato per le innumerevoli prove fallite) e ad un Ardulog, successore dell’OpenLog. I numerosi visitatori, dapprima solo un po’ incuriositi, poi decisamente colpiti, hanno mostrato la validita’ dell’idea di un cosino largo 2 ceentimetri in grado di monitorare I consumi di tutta casa senza bisogno di nessuna conoscenza di elettronica: basta un rotolo di nastro adesivo, e PowerDuino Standalone e’ operativo! Il nastro serve ad attaccare la fotoresistenza al led presente sui normali contatori elettronici; 30 secondi per effettuare la calibrazione (da farsi solo la prima volta, poi verra’ mantenuta anche staccando la batteria), e poi il logger inizia a registrare. Presto I sorgenti saranno disponibili sul blog per chiunque desideri costruire l’apparecchio in proprio. Per chi non ama il fai da te, il modello standalone costera’ 30 euro e il modello da quadro 65.
Appunti su OpenLog – il file di configurazione config.txt
La documentazione di questo pur utile, minuscolo cosino in grado di registrare miliardi di dati in 4 cm2 lascia molto a desiderare a causa delle molteplici versioni succedutesi nel tempo.
Ecco quindi una breve spiegazione del file di configurazione di OpenLog:
- si deve chiamare CONFIG.TXT (tutto maiuscolo)
- il file deve contenere un’unica riga, non sono ammesse righe di commento
- la riga contiene numeri separati da virgole, senza nessun identificativo; è cioè un file di configurazione POSIZIONALE
Parametri ammessi:
Versione 1:
- baudrate (max 230400), carattere di escape, numero di ripetizioni necessarie del carattere di escape, tipo di logging
Esempio:
- 115200,103,14,0 = 115200 bps, escape char of ASCII(103), 14 times, new log mode
Versione 2:
- Come versione 1 (ma baud max=115200)
Versione 3:
- baudrate (max=115200), carattere di escape, numero di ripetizioni necessarie del carattere di escape, tipo di logging, modalità prolissa on/off, echo on/off
Esempio:
- 115200,103,14,0,1,1 = 115200 bps, escape char of ASCII(103), 14 times, new log mode, verbose on, echo on.
Spiegazione parametri:
- 9600: The communication baud rate. 9600bps is default. Acceptable values are 2400, 4800, 9600, 19200, 38400, 57600, 115200.
- 26: The ASCII value (in decimal form) for the escape character. 26 is ctrl+z and is default. 36 is ‘$’ and is a commonly used escape character.
- 3: The number of escape characters required. By default it is three so you must hit ctrl+z three time to drop to command mode.
- 0: System mode. OpenLog starts in newlog mode (0) by default. Acceptable values are 0 = New Log, 1 = Sequential Log, or 2 = Command mode.
- 1: Verbose mode. Extended (verbose) error messages are turned on by default. Setting this to 1 turns on verbose error messages such as unknown command: remove !. Setting this to 0 turns off verbose errors but will respond with a ‘!’ if there is an error. Turning off verbose mode is handy if you are trying to handle errors from an embedded system.
- 1: Echo mode. While in command prompt characters are echoed by default. Setting this to 0 turns off character echo. Turning off echo is handy if you are trying to handle errors and don’t want to have the sent commands echoing back to the sender.
Nota: nessuna versione di firmware consente al momento di registrare letture dei PIN piuttosto che dei dati seriali, sebbene TX e RX possano teoricamente essere configurati come input digitali; non sono presenti pin analogici sulla board, sebbene A0, A1, A3, A4 e A5 siano disponibili sul chip (A2 non è disponibile).
Nota2: su ArduLog, una variante di OpenLog, sono presenti anche 4 piedini analogici, ma poichè usa lo stesso firmware di OpenLog, non è comunque possibile registrare nessun input!
Nota3: SDLogger, altra variante di OpenLog, utilizza versioni leggermente modificate del firmware di OpenLog, e utilizza SD Card grandi invece che mircoSD. Ha 4 pin analogici (oltre a una porta seriale aggiuntiva), ma non può comunque registrare dati letti dai pin.
Appunti su OpenLog (e ArduLog)
Tempo fa ho acqustato un Openlog della Sparkfun, un logger seriale arduino-based.
Non sono mai riuscito a farlo funzionare, però nel frattempo tanta gente ci si è rotta la testa trovando un sacco di problemi, e risolvendoli alcuni; le soluzioni sono sparse nellalunghissima pagina dell’openlog, provo a riassumerle qui sotto; nel frattempo, ho ordinato invece un ARDUlog, che essendo un successore sembra un po’ migliore: ha dei fori per avvitarlo a un supporto, e ha vari pin analogici di ingresso, quindi è predisposto a livello hardware per diventare un logger standalone, anche se ancora non esiste un firmware adatto.
Openlog:
Ardulog 1.0:
Ardulog 2.0 (notare l’inversione di TX e RX per coincidere con la board FTDI):
PROBLEMA 1 – Condensatori di disaccoppiamento sull’alimentazione:
Member #124829 | about 3 months ago 1
I am using the open log to log weather and cosmic ray data once a minute. I have an Atmega 328 connected on the bread board to the open log for data logging, and to a FTDI header for programming. The open log log’s data fine when I have the FTDI adaptor (DEV-09716) attached, but doesn’t log anything when It isn’t attached. I assume I have a hardware failure, and I forgot to connect something to the open log that the FTDI is connecting for me, but I checked and the TX and RX pins are connected properly, and so are GND and VCC. Right now my only guess is that the FTDI is putting more capacitance on the power supply that causes it to start working, but I haven’t tested it yet. However when I measured the voltage W/ the FTDI adaptor both the TX and RX lines sat at 4.7 to 4.9V and W/O it was 3.3 for both of them. Can I please get some help?
I fixed the problem, there wasn’t enough capacitance and the bypass caps on the FTDI were making the open log work. Make sure you have bypass caps on your power supply, I added a 10uf about 10cm of wire away and a 0.1uf right on the header of the open log and it started working perfectly.
PROBLEMA 2 – Livelli a 5V o 3,3 V?
tsm | about a month ago * 1
I’m getting a stream of 1s back from the data logger over serial.
I’m using a 5V Arduino, powering the OpenLog off of its 5V pin, and sending serial over to it and getting serial back. When the TX from the Arduino is not connected to the RX on the OpenLog, the OpenLog reports “12<”. However, when I connect the Arduino’s TX pin to the OpenLog’s RXI pin, I only getting “11111111….”
While the datasheet says that the RXI pin can take up to 6V, I notice that the schematic shows regulation of VCC down to 3.3V, while the RXI pin undergoes no translation and is connected directly to the ATMEGA. This makes me think that in fact a 5V TTL signal from the Arduino is too high and is causing the ATMEGA to result. Just a guess though.
Has anyone else seen this? The closest thing I found was unanswered (https://github.com/sparkfun/OpenLog/issues/138).
For reference, everything works correctly when I use a 3.3V FTDI.
I just soldered up a TTL logic level shifter (the Sparkfun one), taking my 5V TTL on the Arduino side down to 3.3V on the OpenLog side, and now it’s working. It looks like the 5V serial signal in fact is unacceptable to the ATMEGA, despite that the datasheet suggests it can accept 6V. Big debugging nightmare! Does anyone k
PROBLEMA 3 – Malfunzionamento a batterie
This is working when using USB power, but not battery power. Setup:
5V Arduino’s TX –> logic level shifter –> OpenLog’s RX
OpenLog’s TX –> resistor –> Arduino RX
Arduino’s reset pin –> logic level shifter –> OpenLog’s reset pin
I had a high-current device on the same bus. Interestingly, a separate mistake was drawing the 3.3V bus to 5V, but when the high-current device was on the line, it was pulling too much current and bringing the bus back down closer to 3.3V. When I used the battery, which delivered more current, this didn’t happen, and so the OpenLog would reset. Nasty problem. Fixed with a separate bus for that current-hungry component.
PROBLEMA 4 – flashing firmware con AVRDUDE:
I’m using a FTDI 3.3v (DEV-09717) cable connected to my OpenLog. Using teraterm on COM10 I can make a connection to the device. all is good.
to upgrade the firmware I’m using the follow cmd:
avrdude.exe -p atmega328p -P COM10 -c stk500v1 -b 57600 -Cavrdude.conf -U flash:w:main.hex
and get this response:
avrdude.exe: ser_open(): can’t open device “COM10”: The system cannot find the file specified.
I have put libusb0.dll in the system32 directory.
is the problem that arvdude can’t handle high number com ports?
thank you
gek
I did a little hacking with regedt32 and changed the comport from 10 to 3. I can now update the firmware.
see:
http://www.ftdichip.com/Documents/AppNotes/AN_132_Re-Assigning_COM_Port_Numbers_Using_Registry.pdf
The registry remembers all FTDI converters that have been used. The driver does not reassign unused comport numbers. In some cases that a good thing. It would be nice to be able to “reserve” a set of comport numbers to be reused as devices are used and removed.
PROBLEMA 5 – flashing firmware
Hi,
Anyone encountered this problem while flashing the firmware? Thanks!
C:\openlog>avrdude.exe -p atmega328p -P COM6 -c stk500v1 -b 57600 -Cavrdude.conf
-U flash:w:main.hex
avrdude.exe: stk500_getsync(): not in sync: resp=0x00
avrdude.exe: stk500_disable(): protocol error, expect=0x14, resp=0x51
-
ok..solved. you need to connect all pins of FTDI Basic board and openLog. Not just TX/RX/5V/GND won’t be able to download.
https://github.com/nseidle/OpenLog/wiki/Datasheet
Under this topic
How do I attach a FTDI Basic board to OpenLog for configuring and bootloading?PROBLEMA 6 – output 1, no prompt, no logging
Lubin | about a year ago * 1
Hello,
I get an OpenLog with firmware v1.51 as I remmeber. I have a standard FTDI cable.
I downloaded newer firmware through the git repository. I can upgrade sucessfully to any firmware version. I Only have Rx-Tx wires with Vcc-GND. I power up openlog whild pressing enter with: avrdude -p atmega328p -P COM2 -c stk500v1 -b 57600 -Cavrdude.conf -U flash:w:main.hex
It’s programming without error. However, open log is only showint one 1 at hyperterm when starting. I do not have anymore 12>.
What’s going on ? any ideas ?
-
Find out : the computer corrupted the Sd card. reformating the card make its working with latet firmware.
-
CONSIGLIO 1
Just got it working! Very nice.
Couple of hints for others.
—Default baud is 9600 8n1.
—Make sure your card is formated as fat16.
—If you hook it directly up to FTDI Basic don’t forget to cross the rx and tx lines.
CONSIGLIO 2:
to format FAT16 with dos in xp:
c:>format e: /fs:fat
INFO:
STAT1 LED is the LED right of the word OpenLog and is sitting on PD5 (Arduino D5). This LED toggles on/off every time a new character is received. This LED helps troubleshoot and indicate serial communication is working.
STAT2 LED is the LED left of the word OpenLog and is sitting on PB5 (Arduino D13). This LED is attached to the SPI Serial Clock line. You will see this LED flash rarely. It only turns on when the SPI interface is active and this is rare as the OpenLog buffers 512 bytes at a time before recording to the SD card. Recording 512 bytes is very fast so the LED is on for very little.
OpenLog expects TTL voltage levels. RS232 will not work and could (maybe) harm the OpenLog (probably not though). You’ll need a MAX3232 or a shifter circuit.
UPLOAD FIRMWARE SENZA AVRDUDE:
If you want to upgrade the firmware on this board with the latest version, you don’t have to go through the hassle of installing a custom version of Arduino as suggested. The compiled hex file is included in the download. There is a great little program called XLoader (http://xloader.russemotto.com/) which you can use to download the firmware into the openlog. (No avrdude knowledge required)
Controllare display 5110 mediante scheda Pinguino PIC32 MICRO
Nuovo, piccolo passo verso il completamento del logger di energia per scooter e pannelli fotovoltaici: finalmente il listato dimostrativo per Arduino di utilizzo del display 5110 funziona!
Adesso posso aggiungere finalmente al mio logger la visualizzazione in tempo reale dei dati registrati, in modo da poterlo tarare facilmente.
// LCD_5110_test for Pinguino PIC32 MICRO.
// Sample program to drive 5110 LCD display (Philips PCD8544 based).
// Display works at 3,3V, so no need for voltage regulators on Pinguino PIC32 Micro.
// Directly copied from Arduino site: http://playground.arduino.cc/Code/PCD8544
// Added shift_out procedure (copied from Arduino IDE source).
//
// Jumpjack march 2013
#define PIN_SCE 13 // CON2-03
#define PIN_RESET 12 // CON2-04
#define PIN_DC 11 // CON2-05
#define PIN_SDIN 10 // CON2-06
#define PIN_SCLK 9 // CON2-07
#define PIN_LED 8 // CON2-08 (Backlight, optional)
#define LCD_C LOW
#define LCD_D HIGH
#define LCD_X 84
#define LCD_Y 48
#define LSBFIRST 0
#define MSBFIRST 1
static const byte ASCII[][5] =
{
{0x00, 0x00, 0x00, 0x00, 0x00} // 20
,{0x00, 0x00, 0x5f, 0x00, 0x00} // 21 !
,{0x00, 0x07, 0x00, 0x07, 0x00} // 22 "
,{0x14, 0x7f, 0x14, 0x7f, 0x14} // 23 #
,{0x24, 0x2a, 0x7f, 0x2a, 0x12} // 24 $
,{0x23, 0x13, 0x08, 0x64, 0x62} // 25 %
,{0x36, 0x49, 0x55, 0x22, 0x50} // 26 &
,{0x00, 0x05, 0x03, 0x00, 0x00} // 27 '
,{0x00, 0x1c, 0x22, 0x41, 0x00} // 28 (
,{0x00, 0x41, 0x22, 0x1c, 0x00} // 29 )
,{0x14, 0x08, 0x3e, 0x08, 0x14} // 2a *
,{0x08, 0x08, 0x3e, 0x08, 0x08} // 2b +
,{0x00, 0x50, 0x30, 0x00, 0x00} // 2c ,
,{0x08, 0x08, 0x08, 0x08, 0x08} // 2d -
,{0x00, 0x60, 0x60, 0x00, 0x00} // 2e .
,{0x20, 0x10, 0x08, 0x04, 0x02} // 2f /
,{0x3e, 0x51, 0x49, 0x45, 0x3e} // 30 0
,{0x00, 0x42, 0x7f, 0x40, 0x00} // 31 1
,{0x42, 0x61, 0x51, 0x49, 0x46} // 32 2
,{0x21, 0x41, 0x45, 0x4b, 0x31} // 33 3
,{0x18, 0x14, 0x12, 0x7f, 0x10} // 34 4
,{0x27, 0x45, 0x45, 0x45, 0x39} // 35 5
,{0x3c, 0x4a, 0x49, 0x49, 0x30} // 36 6
,{0x01, 0x71, 0x09, 0x05, 0x03} // 37 7
,{0x36, 0x49, 0x49, 0x49, 0x36} // 38 8
,{0x06, 0x49, 0x49, 0x29, 0x1e} // 39 9
,{0x00, 0x36, 0x36, 0x00, 0x00} // 3a :
,{0x00, 0x56, 0x36, 0x00, 0x00} // 3b ;
,{0x08, 0x14, 0x22, 0x41, 0x00} // 3c
,{0x02, 0x01, 0x51, 0x09, 0x06} // 3f ?
,{0x32, 0x49, 0x79, 0x41, 0x3e} // 40 @
,{0x7e, 0x11, 0x11, 0x11, 0x7e} // 41 A
,{0x7f, 0x49, 0x49, 0x49, 0x36} // 42 B
,{0x3e, 0x41, 0x41, 0x41, 0x22} // 43 C
,{0x7f, 0x41, 0x41, 0x22, 0x1c} // 44 D
,{0x7f, 0x49, 0x49, 0x49, 0x41} // 45 E
,{0x7f, 0x09, 0x09, 0x09, 0x01} // 46 F
,{0x3e, 0x41, 0x49, 0x49, 0x7a} // 47 G
,{0x7f, 0x08, 0x08, 0x08, 0x7f} // 48 H
,{0x00, 0x41, 0x7f, 0x41, 0x00} // 49 I
,{0x20, 0x40, 0x41, 0x3f, 0x01} // 4a J
,{0x7f, 0x08, 0x14, 0x22, 0x41} // 4b K
,{0x7f, 0x40, 0x40, 0x40, 0x40} // 4c L
,{0x7f, 0x02, 0x0c, 0x02, 0x7f} // 4d M
,{0x7f, 0x04, 0x08, 0x10, 0x7f} // 4e N
,{0x3e, 0x41, 0x41, 0x41, 0x3e} // 4f O
,{0x7f, 0x09, 0x09, 0x09, 0x06} // 50 P
,{0x3e, 0x41, 0x51, 0x21, 0x5e} // 51 Q
,{0x7f, 0x09, 0x19, 0x29, 0x46} // 52 R
,{0x46, 0x49, 0x49, 0x49, 0x31} // 53 S
,{0x01, 0x01, 0x7f, 0x01, 0x01} // 54 T
,{0x3f, 0x40, 0x40, 0x40, 0x3f} // 55 U
,{0x1f, 0x20, 0x40, 0x20, 0x1f} // 56 V
,{0x3f, 0x40, 0x38, 0x40, 0x3f} // 57 W
,{0x63, 0x14, 0x08, 0x14, 0x63} // 58 X
,{0x07, 0x08, 0x70, 0x08, 0x07} // 59 Y
,{0x61, 0x51, 0x49, 0x45, 0x43} // 5a Z
,{0x00, 0x7f, 0x41, 0x41, 0x00} // 5b [
,{0x02, 0x04, 0x08, 0x10, 0x20} // 5c ¥
,{0x00, 0x41, 0x41, 0x7f, 0x00} // 5d ]
,{0x04, 0x02, 0x01, 0x02, 0x04} // 5e ^
,{0x40, 0x40, 0x40, 0x40, 0x40} // 5f _
,{0x00, 0x01, 0x02, 0x04, 0x00} // 60 `
,{0x20, 0x54, 0x54, 0x54, 0x78} // 61 a
,{0x7f, 0x48, 0x44, 0x44, 0x38} // 62 b
,{0x38, 0x44, 0x44, 0x44, 0x20} // 63 c
,{0x38, 0x44, 0x44, 0x48, 0x7f} // 64 d
,{0x38, 0x54, 0x54, 0x54, 0x18} // 65 e
,{0x08, 0x7e, 0x09, 0x01, 0x02} // 66 f
,{0x0c, 0x52, 0x52, 0x52, 0x3e} // 67 g
,{0x7f, 0x08, 0x04, 0x04, 0x78} // 68 h
,{0x00, 0x44, 0x7d, 0x40, 0x00} // 69 i
,{0x20, 0x40, 0x44, 0x3d, 0x00} // 6a j
,{0x7f, 0x10, 0x28, 0x44, 0x00} // 6b k
,{0x00, 0x41, 0x7f, 0x40, 0x00} // 6c l
,{0x7c, 0x04, 0x18, 0x04, 0x78} // 6d m
,{0x7c, 0x08, 0x04, 0x04, 0x78} // 6e n
,{0x38, 0x44, 0x44, 0x44, 0x38} // 6f o
,{0x7c, 0x14, 0x14, 0x14, 0x08} // 70 p
,{0x08, 0x14, 0x14, 0x18, 0x7c} // 71 q
,{0x7c, 0x08, 0x04, 0x04, 0x08} // 72 r
,{0x48, 0x54, 0x54, 0x54, 0x20} // 73 s
,{0x04, 0x3f, 0x44, 0x40, 0x20} // 74 t
,{0x3c, 0x40, 0x40, 0x20, 0x7c} // 75 u
,{0x1c, 0x20, 0x40, 0x20, 0x1c} // 76 v
,{0x3c, 0x40, 0x30, 0x40, 0x3c} // 77 w
,{0x44, 0x28, 0x10, 0x28, 0x44} // 78 x
,{0x0c, 0x50, 0x50, 0x50, 0x3c} // 79 y
,{0x44, 0x64, 0x54, 0x4c, 0x44} // 7a z
,{0x00, 0x08, 0x36, 0x41, 0x00} // 7b {
,{0x00, 0x00, 0x7f, 0x00, 0x00} // 7c |
,{0x00, 0x41, 0x36, 0x08, 0x00} // 7d }
,{0x10, 0x08, 0x08, 0x10, 0x08} // 7e ←
,{0x78, 0x46, 0x41, 0x46, 0x78} // 7f →
};
void LcdCharacter(char character)
{
int index=0;
LcdWrite(LCD_D, 0x00);
for ( index = 0; index < 5; index++)
{
LcdWrite(LCD_D, ASCII[character - 0x20][index]);
}
LcdWrite(LCD_D, 0x00);
}
void LcdClear(void)
{
int index=0;
for ( index = 0; index < LCD_X * LCD_Y / 8; index++)
{
LcdWrite(LCD_D, 0x00);
}
}
void LcdInitialise(void)
{
pinMode(PIN_SCE, OUTPUT);
pinMode(PIN_RESET, OUTPUT);
pinMode(PIN_DC, OUTPUT);
pinMode(PIN_SDIN, OUTPUT);
pinMode(PIN_SCLK, OUTPUT);
pinMode(8,OUTPUT); //backlight
digitalWrite(PIN_RESET, LOW);
digitalWrite(PIN_RESET, HIGH);
LcdWrite(LCD_C, 0x21 ); // LCD Extended Commands.
LcdWrite(LCD_C, 0xB1 ); // Set LCD Vop (Contrast).
LcdWrite(LCD_C, 0x04 ); // Set Temp coefficent. //0x04
LcdWrite(LCD_C, 0x14 ); // LCD bias mode 1:48. //0x13
LcdWrite(LCD_C, 0x0C ); // LCD in normal mode.
LcdWrite(LCD_C, 0x20 );
LcdWrite(LCD_C, 0x0C );
}
void LcdString(char *characters)
{
while (*characters)
{
LcdCharacter(*characters++);
}
}
void LcdWrite(byte dc, byte data)
{
digitalWrite(PIN_DC, dc);
digitalWrite(PIN_SCE, LOW);
shiftOut(PIN_SDIN, PIN_SCLK, MSBFIRST, data);
digitalWrite(PIN_SCE, HIGH);
}
void setup(void)
{
LcdInitialise();
LcdClear();
LcdString("Hello World!");
delay(1000);
digitalWrite(8,LOW);
}
void loop(void)
{
toggle(PIN_LED);
delay(1000);
}
void shiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t val)
{
uint8_t i;
for (i = 0; i < 8; i++) {
if (bitOrder == LSBFIRST)
digitalWrite(dataPin, !!(val & (1 << i)));
else
digitalWrite(dataPin, !!(val & (1 << (7 - i))));
digitalWrite(clockPin, HIGH);
digitalWrite(clockPin, LOW);
}
}
Sempre parlando di logger, ho scoperto che esistono semplici contatori di kWh per la corrente di casa, da installare nel quadro elettrico, che fanno lampeggiare un led ogni tot kWh (come il contatore ufficiale ENEL), e che costano 20 euro invece che 200 come quelli che conoscevo io…
Questo significa che costruire un logger Arduino/Pinguino per la corrente dicasa diventa un po’ più semplice, perchè non serve più un sensore di corrente, ma basta una fotoresistenza, più un partitore 1:100 per la tensione (comunque necessario solo per misure molto precise della potenza e/o per misurare anche il cosFi).
Appena mi danno l’indirizzo lo compro e inizio a fare le prove.
leave a comment