Jumping Jack Flash weblog

COVID-19 – Misurare temperatura corporea con accuratezza di +/-0.1°C

Posted in hardware by jumpjack on 15 maggio 2020

Ai tempi del COVID-19, per molte settimane – e speriamo non mesi – ci verrà misurata la temperatura in continuazione: andando a lavoro, entrando nei locali, andando dal barbiere; per ora infatti è l’unico modo istantaneo per verificare, anche se molto a grandi linee, se si è infetti o no.

Potrebbe allora essere comodo potersi misurare da sè la temperatura corporea, senza dover stare ogni volta 5 minuti col termometro sotto l’ascella, o senza spendere 50 euro per un termometro a infrarossi; senza contare che sarebbe molto utile poter avere un grafico dell’andamento della temperatura nella giornata.

Stanno iniziando a comparire sul mercato i primi braccialetti fitness o smartwatch con termometro incorporato, ma per ora solo in spedizione dalla Cina, e comunque nessuno fornisce il grado di accuratezza della misurazione (tranne questo, che dichiara 0.1°C); e considerando, ad esempio, che per esempio che il termometro di una tipica stazione meteo ha un’accuratezza dichiarata di +/-2°C, significa che se usassimo quel termometro per misurarci la febbre, e avessimo 37.5°, quel termometro potrebbe dire un qualunque valore fra 35.5° (in ipotermia) o 39.5° (con le pezze in fronte)…

Serve quindi una misurazione molto più precisa, con uno scarto di pochi decimi di grado.

Ecco allora un elenco di alcuni sensori di temperatura ad alta accuratezza: anche se, usandoli per il fai-da-te, non possono essere usati come presidio medico per decidere se e come curarsi, possono comunque dare un valido indizio per decidere se poi farsi una misurazione seria con uno strumento certificato.

Ecco dunque la lista:

  1. SHT35: +/-0.1°C (Sensirion) (temperatura/umidità)
  2. STS35: +/-0.1°C (Sensirion) (solo temperatura)
  3. SHT85: +/-0.1°C (Sensirion) (temperatura/umidità)
  4. Si7051: +/-0.1°C (Silicon Labs)
  5. MAX30205: +/-0.1°C (Maxim Integrated)
  6. MAX30208: +/-0.1°C (Maxim Integrated)
  7. MCP9808: +/-0.1°C  (Microchip) (solo temperatura)

 

Altri  meno accurati:

 

Sono tutti sensori davvero minuscoli, grandi quanto l’unghia del mignolo, quindi impossibili da gestire con un saldatore classico: servirebbe un fornetto per saldature SMD. Per fortuna però per molti esistono delle versioni già saldate su breadboard; alcune sono molto rare e disponibili solo in ordine dalla cina, ma altre sono piuttosto diffuse e si trovano su ebay Italia o addirittura su Amazon, alcuni persino con spedizione gratuita con Prime da un giorno all’altro.

E’ importante quindi saper distinguere quale è il migliore. I dati di accuratezza  sono espressi come un singolo numero, ma un modo più preciso per definire l’accuratezza è un grafico; nei datasheet di questi oggetti sono presenti grafici come questo, che indicano quant’è il massimo possibile errore di misurazione (asse Y, a sinistra) alle varie temperature (asse X, in basso):

Questo grafico dice ad esempio che per questo specifico componenbte “tipicamente”, per misurazioni tra +20°C e +60°C, lo scarto tra temperatura misurata e reale è di 0.1°C, mentre quello “massimo” è di 0.3°C.

Prendendo i grafici di tutti i vari sensori e raggruppandoli tutti in un’unica figura, ho ottenuto quanto segue:

Si nota chiaramente come tutti i sensori siano più accurati nella zona di interesse, che è quella della temperatura del corpo umano, la quale può variare fra 35 e 43 gradi, dove ovviamente i valori estremi si hanno solo in caso di gravissima malattia: la temperatura tipica di un essere umano in salute è infatti di circa 37°C. “Circa” perchè la temperatura può variare per vari motivi:

In base al punto di misurazione:

In base al momento della misurazione:

Persino in base all’umore:

 

Questa tabella indica alcune temperature di riferimento, da cui si evince perchè bisogna allertarsi, in tempi di pandemia mondiale da coronavirus, se la temperatura sale sopra i 37.5°C:

Scelta del sensore

Qual è il sensore migliore tra quelli elencati prima?

Ovviamente quello che ha deviazione/errore più basso in prossimità dei 37 gradi, quindi quelli della prima lista, con accuratezza di 0.1°C; poi però bisogna trovare:

  1. quello più facilmente reperibile in Italia
  2. il meno costoso
  3. quello più pratico

Per il punto 1: scartiamo quindi quelli su Aliexpress e simili, che probabilmente, ordinati a maggio 2020, arriverebbero dopo che sarà stato inventato il vaccino… Orientiamoci quindi su siti italiani, su Ebay con spedizione dall’Europa, e su Amazon.

Per il punto 2: se c’è su Amazon, vediamo se è disponibile con spedizione gratuita.

Per il punto 3: verifichiamo se ci sono già librerie disponibili per Arduino, o addirittura kit di test già pronti.

 

Per quanto riguarda Amazon Prime, la scelta è molto limitata: ci sono solo SHT35 e Si7051. Su Ebay la scelta è un po’ più ampia: SHT35, SHT85, Si7051,  MAX30205.

Per quanto riguarda le librerie Arduino, ce ne sono per i Sensirion SHT3x e per i Silicon Labs Si7051 dalla Adafruit (o anche per i Silicon Labs Si7013, Si7020 e Si7021, che però hanno accuratezza troppo bassa (+/-0.5°C)).

Schede preassemblate

SHT31 Smart Gadget

Il Sensirion SHT35 ha un punto a suo favore in più: esiste un modulo già assemblato dotato di batteria tampone, circuito di lettura del sensore e schermo LCD, cose che altrimenti dovremmo aggiungere noi a mano, assemblare e testare: si chiama SHT31 Smart Gadget:

Clicca qui per una foto a risoluzione esagerata: link

Lo Smart Gadget è disponibile su:

Come è facile intuire dal nome, non è basato sull’SHT35 da +/-0.1°C ma sull’SHT31 da +/-0.2°C: ci si può accontentare di 0.2, oppure si può pensare di sostituire il sensore SHT31 con un altro: la scheda infatti espone i 4 pin a cui è collegato il sensore tramite protocollo I2C (Vcc, GND, SDA, SCL), che quindi può essere staccato e facilmente sostituito, a livello di hardware; per quanto riguarda la compatibilità SW, dal momento che le librerie arduino sono dichiarate come compatibili per tutti i modelli SHT3x, è ipotizzabile che anche questa scheda già pronta sia compatibile con tutti gli SHT3x. Naturalmente per esserne sicuri al 100%, anche qui bisognerebbe leggere in dettaglio nel datasheet i registri e i protocolli.

Importante anche l’indirizzo I2C assegnato: per certe board che montano SHT31 può essere impostato su 0x44 (default) o 0x45 a seconda di come è connesso il pin ADR (ADDRESS). Altre board hanno indirizzo fisso non modificabile, quindi non sono adatte:

Sullo smart gadget l’SHT31 ha il pin ADDR collegato all’alimentazione, quindi, da datasheet, l‘indirizzo è impostato su 0x45.

Lo Smart gadget è dotato di memoria onboard e capacità di logging, e sono disponibili due app della Sensirion stessa per scaricare i dati e mostrarli sul cellulare Android o iOS (qui l’app Android precedente e ormai abbandonata).

Il sensore esterno SHT35 si trova già montato su basetta con connettore GROVE, preimpostata su indirizzo 0x45, quindi direttamente collegabile al gadget.

L’immagine che segue mostra il retro di una schedaGrove SHT35, evidenziando le piazzole utilizzabili per modificare l’indirizzo dal default 0x45 a 0x44:

Affinchè una scheda SHT35 funzioni su uno Smart Gadget SHT31, deve essere impostata sullo stesso indirizzo che l’SHT31 ha sulla scheda (0x45); in caso di errore non si rompe niente, ma il sensore non verrà visto dalla scheda.

E’ disponibile, tra parentesi, anche una libreria Arduino per il sensore STS35, sempre della Sensirion, sempre da +/-0.1°C, ma solo sensore di temperatura (mentre l’SHT35 contiene anche un sensore di umidità ambientale, in realtà inutile per la nostra applicazione).

Sempre su RS è disponibile anche una board in formato “Grove” contenente il sensore SHT35 (disponibile da giugno) a 15,00 euro o su robot-domestici a 26,00 euro.

Questo è il manuale dello Smart Gadget, questa la pagina ufficiale

Esaminando i file gerber dello SmartGadget, è spossibile individuare come e a cosa sono connessi i vari pin, e scoprire che dal lato opposto della batteria c’è proprio una predisposizione per collegare un sensore esterno:

 

Basta quindi tagliare le piste di rame vicino al sensore, saldare il nuovo sensore alle piazzole libere, e ottenere quindi (in teoria) uno Smart gadget con accuratezza di +/-0.1°C anzichè 0.3°C; la rimozione dell’SHT31 è in ogni caso necessaria perchè è montato dalla parte del display, mentre è necessario che sia attaccato al polso per leggere correttamente la temperatura, ma una volta rimosso potrebbe risultare difficile, se non impossibile, risaldare i fili ai vicinissimi terminali del sensore, o ai forellini sul PCB per cui passano le piste di rame.

Scheda M5stickC

Una possibile alternativa quasi-già-pronta, essendo disponibili le librerie arduino, è l’utilizzo di una board M5StickC (da non confondere con M5Stack):

Anche se non dispone di un sensore di temperatura integrato, questo dispositivo è dotato di:

  • Microcontrollore ESP32 dualcore a 240 MHz con 4 Mbyte di RAM
  • Bluetooth
  • Wifi
  • Schermo OLED
  • Connettore GROVE (adatto per sensore esterno Grove SHT35)
  • Pulsanti
  • Accelerometro
  • Giroscopio
  • Trasmettitore IR
  • Segnalatore acustico
  • Predisposizione per attacco a cinturino
  • Batteria da 95 mAh
  • Connettore USB

La quantità di progetti realizzabili con un simile dispositivo è enorme, per cui, una volta terminata la necessità di misurarsi la temperatura tutto il giorno, può essere riciclato per altri usi.

E’ disponibile su Amazon Prime (B07QRQ4MP8) a 25 euro inclusivo di cinturino:

Naturalmente in questo caso il SW sarà tutto da scrivere, ma essendo l’ESP32 programmabile tramite Arduino, si tratta solo di usare le già citate librerie Arduino adatte per il proprio sensore e trovare un sorgente di esempio da cui partire.

Per quanto riguarda il cinturino, se si possiede già un M5tickC senza cinturino, o si vuole comprarlo senza per risparmare, usando un vecchio cinturino, qui c’è il modello 3d dell’involucro dell’M5stickC, su cui lavorare per crearsi manualmente l’aggancio in plastica per il cinturino:

 

Fai da te: Arduino/ESP8266/ESP32

Librerie

Sorgenti di esempio:

Questo sorgente di esempio si limita a stampare la temperatura sul monitor seriale; chiaramente l’applicativo finale dovrà invece stamparlo su un display:

#include <Arduino.h>
#include <Wire.h>
#include "Adafruit_SHT31.h"

Adafruit_SHT31 sht31 = Adafruit_SHT31();

void setup() {
  Serial.begin(9600);
  if (! sht31.begin(0x44)) { // Qui c'è l'indirizzo I2C del sensore; per alcuni è fisso a 0x40, per altri si può modificare tra 0x44 e 0x45
    Serial.println("*ERR01* Sensore non presente a indirizzo 0x44");
    while (1) delay(1);
  }
}

void loop() {
  float t = sht31.readTemperature();

  if (! isnan(t)) {
    Serial.print("Temp *C = "); Serial.println(t);
  } else {
     Serial.println("*ERR02* Lettura errata");
  }

  Serial.println();
  delay(1000);
}

 

 

Sensori su breadboard

Per SmartGadget (serve indirizzo 0x45):

 

Hacking Icaro – centralina GSM – il logger seriale

Posted in minicar elettriche by jumpjack on 13 giugno 2019

Questo primo sketch di prova utilizza una board ESP32 per leggere i dati scambiati tra il microcontrollore e il modem della scheda GSM/GPS della Icaro: vengono letti contemporaneamente i due canali in modo da mantenere la sincronia tra messaggi inviati e ricevuti, e poter meglio ricostruire il dialogo.

Al momento la “registrazione” viene effettuata solo inviando l’output al serial monitor dell’Arduino IDE; una successiva versione memorizzerà i dati o in una SD card, o su un server remoto, in modo che il logger possa essere montato direttamente sul veicolo senza necessità di un PC.

Trattandosi di un generico logger seriale a due canali, può in realtà essere usato per “sniffare” qualunque altra comunicazione seriale tra due dispositivi, o anche per loggare un singolo dispositivo.

Il numero a inizio linea identifica il canale cui si riferisce la linea stessa.


// Greengo/Zhidou/Xindayang GSM logger
// Read data from GSM/GPS logger, from both MCU and MODEM outputs and same time
// using ESP32 board.
// V. 0.1.0 - First working version; logs only to USB/serial port (PC needed).
String tempVal = "";
String row0 = "";
String row1 = "";
int MAXLEN = 50;
void setup() {
// initialize serial:
// Recommendation: use Serial0 and 1 for your duplex devices and serial2 for your debug messages.
// https://github.com/espressif/arduino-esp32/issues/1314
//
// Standard serial pinouts:
// https://circuits4you.com/2018/12/31/esp32-hardware-serial2-example/
// UART RX TX CTS RTS
// UART0 GPIO3 GPIO1 N/A N/A
// UART1 GPIO9 GPIO10 GPIO6 GPIO11
// UART2 GPIO16 GPIO17 GPIO8 GPIO7
// But all 3 HW UARTs can be remapped to any pin.

Serial.begin(9600,SERIAL_8N1, 16, 17); // Input 1 (16 = RX)
Serial1.begin(9600,SERIAL_8N1, 4, 2); // Input 2 (4 = RX)
Serial2.begin(9600,SERIAL_8N1, 3,1); // Standard USB-serial port

Serial2.println("Free heap:");
Serial.println(ESP.getFreeHeap());
Serial2.println("--------------------");

}
void loop() {
// read from port 0, send to port 2:
if (Serial.available()) {
int inByte = Serial.read();
/*
Serial2.print("\t0\t0x");
Serial2.print(inByte,HEX);
Serial2.print("\t");
Serial2.print(inByte,DEC);
if (inByte>31) {
Serial2.print("\t");
Serial2.write(inByte);
}
Serial2.println();
*/
tempVal = String(inByte);
row0 += "\t" + tempVal;
if (row0.length() > MAXLEN) {
Serial2.print("0\t");
Serial2.println(row0);
row0="";
}
}
// read from port 1, send to port 2:
if (Serial1.available()) {
int inByte = Serial1.read();
/*
Serial2.print("\t1\t0x");
Serial2.print(inByte,HEX);
Serial2.print("\t");
Serial2.print(inByte,DEC);
if (inByte>31) {
Serial2.print("\t");
Serial2.write(inByte);
}
Serial2.println();
*/
tempVal = String(inByte);
row1 += "\t" + tempVal;
if (row1.length() > MAXLEN) {
Serial2.print("1\t");
Serial2.println(row1);
row1="";
}
}

}
Tagged with: , , , , , ,

Trovato BMS personalizzabile non cinese

Posted in auto elettriche, hardware, scooter elettrici by jumpjack on 28 novembre 2016

Per una volta ecco un BMS che non sia fabbricato e venduto in Cina:

 

product_template_16-jpeg

Energus Tiny BMS s516

Ha diverse grosse particolarità:

  • ha firmware aggiornabile
  • supporta un numero a piacere di celle tra 5 e 16, con qualunque chimica
  • ha la connessione bluetooth
  • effettua il log delle celle
  • esiste in varianti da 30, 150 e 750 Ampere

 

I prezzi partono da 135 euro, con spedizione dall’Europa.

 

 

 

Diario Elettrico Ecojumbo – puntata 2 – 6 agosto 2014 – Log completo batterie al litio

Posted in auto elettriche, Diario elettrico Ecojumbo 5000, scooter elettrici by jumpjack on 6 agosto 2014

Grafici batteria al litio 20S1P Headway 40152 per percorso completo 8+8 km casa-lavoro-casa, partendo da batteria appena scollegata dal CB:

Prime 8 celle, andata
8celle-andata

Celle 9-10, andata:

8celle2-andata

Celle 1-8, ritorno:
8celle-ritorno

Celle 9-10, ritorno:
8celle2-ritorno

Si nota come all’inizio le celle siano in “sovratensione da appena caricate”, cioè a 3,6V invece dei 3,4 a cui poi si stabilizzano, per cui da quel valore scendono rapidamente, mentre a ritorno, quando si sono stabilizzate per 8 ore, la discesa è molto più piatta:

Celle 1-8:
8celle-ritorno-detail

Celle 9-10:
8celle2-ritorno-detail

A parte i picchi/valli che sembrano più falsi contatti del logger dovuti alle buche che altro, si vede che la variazine di tensione in 8 km è di appena 30-40 mV.

Una cella sembra un po’ “fiacca”, ma trattandosi di 10 mV non mi preoccupa troppo.

Dispositivi di monitoraggio batterie al litio

Posted in arduino, batterie, scooter elettrici by jumpjack on 6 giugno 2014

Alternative possibili al celllog8s:

BVM-8S (però non logga) – 14$ su Amazon

Frsky voltage sensor – 21$ (richiede anche convertitore seriale da 18$, totale 39$). 10$ su hobbyking? 10 sterline in inghilterra (anche qui). Non logga, ma avendo l’uscita seriale si può loggare con Arduino.

Xtrema Lithium Balancer – 20 euro – non logga, ma fornisce in uscita le singole tensioni,ed esiste un cavo USB per collegarlo al PC;esce con protocollo i2c, per il quale arduino è già predisposto:

The protocol to the Xtrema Lithium Balancer is public by request. You have requested to here it is at this link http://tmenet.com/pdf/Xtrema%20Balancer%20I2C%20Commands.pdf

It is an I2C protocol and is perfect for an Arduino. Full pin out and command specifications are included in the document. Please keep in touch with your progress and if possible please place your application on our forum when you get logged in. 

 

Venditori vari EU:

http://robotbirds.co.uk/catalog/product_info.php?products_id=8227

http://www.brchobbies.co.uk/catalog/index.php?cPath=8_121

http://www.giantshark.co.uk/product/169346/cell-log-cell-voltage-monitor-2-8s-lipo

http://www.hobbyking.com/hobbyking/store/uh_viewItem.asp?idProduct=36288

Diario elettrico Zem Star 45 – Jun-Si CellLog8S e batteria disastrata

Posted in ambiente, auto elettriche, batterie, scooter elettrici by jumpjack on 26 luglio 2013

Dopo “soli” 2 anni e 2 mesi dall’acquisto dello scooter sono riuscito a trovare un dispositivo in grado di registrare momento per momento lo stato di ogni singola cella delle mie batterie, in modo da poter finalmente capire cosa succede dentro quelle valigette nere e scoprire perchè le batterie non vanno più.

Sto ancora cercando di capire bene come funzionano il logger e il relativo programma, LogView, poi mi organizzerò ben bene con log giornalieri.

…ma un primo risultato è veramente sconfortante!

LogB

Adesso capisco perchè il BMS mi spegne completamente la batteria se gli chiedo troppa corrente!

Quella povera cella n.1 arriva all’impossibile tensione di 2,6 volt quand’è messa “sotto pressione”!!!

Sarebbero già pochi i 3,8 da cui parte quando è completamente “carica” (in realtà quando è carica dovrebbe stare a 4,1, ma più di così non si carica), ma la tensione minima di una batteria li-ion che non sia LiFePO4 non deve scendere sotto i 3,0 volt!

Quindi quella cella è completamente andata.

Le altre 8 celle:

LogA

Anche la cella 4 di questo gruppo non sta molto bene, ma comunque non scendea mai sotto i 3,4, ben lontani da 3,0.

Quello che mi preoccupa è la cella 8, che semplicemente “scompare” andando a zero.

Spero si sia staccato un filo…

Comunque sia, la situazione non è drammaticissima: anche se non tutte le celle, a batteria carica, stanno a 4,1 V, solo 3 sono in cattive condizioni, di cui una forse solo “per finta” per via di un filo staccato nel logger, una messa così così, e una da buttare.

Nell’altra batteria ho altre 16 celle, magari 2 o 3 saranno buone, quindi è sperabile che di due batterie disastrate riesca a farne una in buone condizioni.

Prima però devo fare tutti i cablaggi anche in quella (una batteria era già cablata da 6 mesi in attesa di un logger…), e ovviamente anche nella terza, che è quella che si comporta “meglio”, con ben 10km di autonomia…

Ecco “Displog”, il DISPlay che LOGga!

Posted in arduino, hardware by jumpjack on 8 aprile 2013

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

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

Posted in Uncategorized by jumpjack on 6 aprile 2013

image

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.

Controllare display 5110 mediante scheda Pinguino PIC32 MICRO

Posted in hardware by jumpjack on 16 marzo 2013

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.

PinguiLogger – registrazione corrente e tensione con board Pinguino

Posted in hardware, Programmazione by jumpjack on 12 febbraio 2013

Sta per vedere la luce il mio PinguiLogger 🙂 , un aggeggino che permette di registrare correnti fino a 70 A e tensioni fino a 60V su scheda SD, per analizzare cosa combina il mio scooter elettrico.

Al momento il listato C è già pronto e funzionante su scheda Arduino, anche se si limita a registrare i dati senza elaborarli, quindi registra solo valori compresi tra 0 e 1023 da due sensori di corrente e da due partitori di tensione 1:21, creando un file .CSV; poi bisogna importare il file in Excel e fare i dovuti calcoli.

I campi registrati nel file sono:

  • tempo (millisecondi)
  • riferimento 1
  • corrente 1
  • tensione 1
  • riferimento 2
  • corrente 2
  • tensione 2

Il “riferimento” è il pin di riferimento dei sensori di corrente, il cui valore dovrebbe servire, se ho ben capito, a indicare a quale valore del pin di output corrisponde una corrente nulla (perchè immagino che il “punto 0″ dipenda dalla tensione effettiva di alimentazione”, ma devo ancora studiare bene la faccenda…

(more…)