Arduino logger low power

Aggiornamento:

ho interrotto l'esperimento prima della fine effettiva della batteria

L'Arduino e' rimasta attiva dalle 8:37 del 1/11/2024 alle 8:50 del 15/12/2024 partendo da circa 4.3 V per terminare a 3.91 V ed ha effettuato 31424 misure dal sensore di torbidita'

Al di sotto il grafico di scarica

================================================

 

Alla fine ci sono riuscito

La arduino MKR zero e' ormai da un mese che e' rimasta accesa sul tavolo...o meglio si attiva ogni minuto, legge il pin 0, legge lo stato della carica della batteria, scrive sulla Sd card e si addormenta in deep sleep

la batteria da 6600 mAh e' costituita da 18650

 

 

 

#include "ArduinoLowPower.h"
#include <SD.h>
#include <RTCZero.h>

RTCZero rtc;

/* Change these values to set the current initial time */
const byte seconds = 00;
const byte minutes = 05;
const byte hours = 14;

/* Change these values to set the current initial date */
const byte day = 01;
const byte month = 11;
const byte year = 24;


const int chipSelect = SDCARD_SS_PIN;
int i;

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  delay(1000);
  SD.begin(chipSelect);

  rtc.begin(); // initialize RTC
  rtc.setHours(hours);
  rtc.setMinutes(minutes);
  rtc.setSeconds(seconds);
  rtc.setDay(day);
  rtc.setMonth(month);
  rtc.setYear(year);

}

void loop() {
  if (i == 60) {
              digitalWrite(LED_BUILTIN, HIGH);
              delay(500);
              digitalWrite(LED_BUILTIN, LOW);
              delay(500);

              int batteria = analogRead(ADC_BATTERY);
              float voltage = batteria * (4.3 / 1023.0);
              if (voltage < 3.9)
                {
                 for (i=1;i<10;i++)
                 {
                  digitalWrite(LED_BUILTIN, HIGH);
                  delay(50);
                  digitalWrite(LED_BUILTIN, LOW);
                  delay(50);
                }
              }
            
              File dataFile = SD.open("data.txt", FILE_WRITE);

              int sensor = analogRead(0);
              String anno = String(rtc.getYear());
              String mese = String(rtc.getMonth());
              String giorno = String(rtc.getDay());
              String ora = String(rtc.getHours());
              String minuto = String(rtc.getMinutes());
              String secondo = String(rtc.getSeconds());

              if (mese.length() == 1) {mese = "0"+ mese;}
              if (giorno.length() == 1) {giorno = "0"+ giorno;}
              if (ora.length() == 1) {ora = "0"+ ora;}
              if (minuto.length() == 1) {minuto = "0"+ minuto;}
              if (secondo.length() == 1) {secondo = "0"+ secondo;}
             
              if (dataFile) {
                dataFile.println(anno+"/"+mese+"/"+giorno+"-"+ora+":"+minuto+":"+secondo+";"+String(sensor)+";"+String(voltage));
                dataFile.close();
                }
              i = 0;
              }
  i++;
  LowPower.sleep(1000);
}

Misuratore di torbidita' TS-300B

Gia' siamo partiti male....ordinato su Aliexpress (costato 1/3 rispetto ad Amazon) ed il cavo di collegamento ha 3 pin....

 

 mentre il connettore sulla scheda ha 4 pin (ed ovviamente il cavo non entra)

 

Il problema e' dal lato scheda ... sulla scheda i pin sono nominati ADVG (dall'alto verso il basso) per l'ingresso del TS-300B e GTV per il lato di connessione verso Arduino

 

incrociando le informazioni con altre schede simili il pinout e'

A = analog input

D = soglia digitale level output

V = Power Positive

G = GND

mentre per il lato arduino

G = GND

T = segnale

V = Vcc  (e' un sensore che deve essere alimentato a 5 V)

Il sensore ha due led L2 che mostra la presenza di alimentazione ed il led L1 che si illumina quando si raggiunge la soglia di tordibita'

Il funzionamento e' semplice...da un lato c'e' un led IR e dall'altro un ricevitore...a seconda di quanta luce arriva al ricevitore viene stimata la torbidita'...visto cio' il sensore e' sensibile alla luce ambientale (deve quindi lavorare al buio ancora meglio dentro ad un tubo)

Leggendo ho trovato che questo tipo di sensori vengono usati in lavastoviglie

 

 

 

 

 

Polarita' Lipo e JST

Ho imparato a mie spese che non tutte le batterie LiPo hanno la polarita' connessa nello stesso modo al connettore JST

Come si vede nella foto sottostante una LiPo e' connessa in modo corretto ad una Arduino MKR (positivo a sinistra) Nella stessa foto si vede il connettore di un'altra batteria con positivo a destra ...e meno male che non si' bruciata la scheda

In ogni caso i connettori JST con un po' di pazienza di possono smontare ed invertire i cavi

Primo spettro di riflettanza con SparkFun Triad Spectroscopy Sensor - AS7265x

 Lo spettro di riflettanza e' stato ottenuto dividendo il valore calibrato della foglia per il valore calibrato nel corrispondente canale dello spectralon

 

 

	spettro	spectralon	foglia
410	0.104046939572376	7631.94	794.08
435	0.100663330010594	1916.09	192.88
460	0.0941060471276098	5496.99	517.3
485	0.0846332588803228	2220.64	187.94
510	0.127077186925102	2647.21	336.4
535	0.209306506039295	3170.9	663.69
560	0.204982889816192	1385.14	283.93
585	0.171727663387711	1473.03	252.96
610	0.0880803424432005	4555.5	401.25
645	0.121946929339632	795.92	97.06
680	0.123669783940664	1054.34	130.39
705	0.278338126099833	232.99	64.85
730	0.766924924721724	295.57	226.68
760	0.718044428259286	219.68	157.74
810	0.575862515972518	539.99	310.96
860	1.02470169644788	2543.55	2606.38
900	0.777308820373417	139.79	108.66
940	0.344453330286759	87.53	30.15

Primi passi con SparkFun Triad Spectroscopy Sensor - AS7265x

 Primi approcci per vedere se il sensore multispettrale e' affidabile per l'uso multispettrale 

In questo prova e' stata verificata la ripetibilita' nel tempo delle misure ponendo il sensore su uno spectralon ed effettuando 350 misure di bianco (il supporto del sensore e' stato ripreso da qui https://github.com/Scottapotamas/AS7265x-triad-ui/tree/master/mechanical)

 

 

Lo script per la misura ha previsto il massimo tempo di integrazione (con valori bassi in IR praticamente non c'era segnale)

sensor.setGain(AS7265X_GAIN_16X);
sensor.setMeasurementMode(AS7265X_MEASUREMENT_MODE_6CHAN_ONE_SHOT);

sensor.setIntegrationCycles(255);

L'errore per ogni canale e' stato stimato prendendo la standard deviation e dividendo per la media

A	0.44%
B	0.49%
C	0.25%
D	0.34%
E	0.05%
F	0.05%
G	0.07%
H	0.07%
R	0.10%
I	0.07%
S	0.09%
J	0.08%
T	0.13%
U	0.00%
V	0.37%
W	0.74%
K	1.55%
L	0.56%

Come si deve l'errore e' piuttosto vario tra i vari canali

 

Plottando la misura di ogni canale nel tempo si osserva una chiara deriva per ogni canale con in alcuni casi l'accenno di un valore asintotivo mentre in altri no 

 

 

 

 

La Dark Current e' stabile (prova su 450 misure)

	A	B	C	D	E	F	G	H	R	I	S	J	T	U	V	W	K	L
St Dev	0.00	0.00	0.00	0.00	0.00	0.00	0.03	0.00	0.00	0.00	0.46	0.00	0.40	0.40	0.27	0.00	0.00	0.00
Media	0.00	0.00	0.00	0.00	0.00	0.00	0.00	0.00	0.00	0.41	1.02	0.00	0.80	0.83	0.84	1.08	0.64	0.00

ESP32-2432S028R e LVGL

La scheda ESP32-2432S028R monta un Esp Dev Module con uno schermo TFT a driver ILI9341 di 320x240 pixels 16 bit colore.Il sito di riferimento e' il seguente https://github.com/witnessmenow/ESP32-Cheap-Yellow-Display (oppure https://github.com/hexeguitar/ESP32_TFT_PIO)

Esempio di TFT_eSPI

Per gli schemi elettrici di tutta la famiglia di dispositivi si cerchi https://github.com/rzeldent/platformio-espressif32-sunton in assets

Si puo' usare tramite Arduino Ide importando le due librerie TFT_eSPI and XPT2046_Touchscreen

Iniziando dallo schermo TFT prima di provare gli esempi della libreria si deve modificare il file User_Setup.h nel folder in Arduino/libraries/TFT_eSPI

 ---------------------------------------------------------------

 //USER DEFINED SETTINGS
#define ILI9341_2_DRIVER    
#define TFT_WIDTH  240
#define TFT_HEIGHT 320
#define TFT_BL   21           
#define TFT_BACKLIGHT_ON HIGH  
#define TFT_MOSI 13
#define TFT_SCLK 14
#define TFT_CS   15  
#define TFT_DC   2  
#define TFT_RST  12  
#define TFT_BL   21
#define TOUCH_CS 33  
#define LOAD_GLCD   
#define LOAD_FONT2  
#define LOAD_FONT4  
#define LOAD_FONT6  
#define LOAD_FONT7  
#define LOAD_FONT8  
#define LOAD_GFXFF  
#define SMOOTH_FONT
#define SPI_FREQUENCY  55000000
#define SPI_READ_FREQUENCY  20000000
//Touch Screen: ?????????ß
#define XPT2046_IRQ 36
#define XPT2046_MOSI 32
#define XPT2046_MISO 39
#define XPT2046_CLK 25
#define XPT2046_CS 33
#define SPI_TOUCH_FREQUENCY  2500000

  ---------------------------------------------------------------

 

Per provare la sola componente TouchScreen  si puo' usare il seguente esempio (quello di default non funziona perche' non sono mappati in modo corretto i pin)

#include <SPI.h>

#include <XPT2046_Touchscreen.h>

#define XPT2046_IRQ 36 // T_IRQ

#define XPT2046_MOSI 32 // T_DIN

#define XPT2046_MISO 39 // T_OUT

#define XPT2046_CLK 25 // T_CLK

#define XPT2046_CS 33 // T_CS

SPIClass touchscreenSPI = SPIClass(VSPI);

XPT2046_Touchscreen touchscreen(XPT2046_CS, XPT2046_IRQ);

int x, y, z;

void printTouchToSerial(int touchX, int touchY, int touchZ) {

Serial.print("X = ");

Serial.print(touchX);

Serial.print(" | Y = ");

Serial.print(touchY);

Serial.print(" | Pressure = ");

Serial.print(touchZ);

Serial.println();

}

void setup() {

Serial.begin(38400);

touchscreenSPI.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);

touchscreen.begin(touchscreenSPI);

touchscreen.setRotation(1);

while (!Serial && (millis() <= 1000));

}

void loop() {

if (touchscreen.tirqTouched() && touchscreen.touched()) {

// Get Touchscreen points

TS_Point p = touchscreen.getPoint();

// Calibrate Touchscreen points with map function to the correct width and height

x = map(p.x, 200, 3700, 1, 320);

y = map(p.y, 240, 3800, 1, 240);

z = p.z;

printTouchToSerial(x, y, z);

}

}

 

Il led RGB e' controllabile tramite questo script

#define PIN_RED 4 // GPIO23

#define PIN_GREEN 16 // GPIO22

#define PIN_BLUE 17 // GPIO21

void setup() {

pinMode(PIN_RED, OUTPUT);

pinMode(PIN_GREEN, OUTPUT);

pinMode(PIN_BLUE, OUTPUT);

}

void loop() {

// color code #00C9CC (R = 0, G = 201, B = 204)

setColor(0, 201, 204);

delay(1000); // keep the color 1 second

// color code #F7788A (R = 247, G = 120, B = 138)

setColor(247, 120, 138);

delay(1000); // keep the color 1 second

// color code #34A853 (R = 52, G = 168, B = 83)

setColor(52, 168, 83);

delay(1000); // keep the color 1 second

}

void setColor(int R, int G, int B) {

analogWrite(PIN_RED, R);

analogWrite(PIN_GREEN, G);

analogWrite(PIN_BLUE, B);

}

Attaccando uno speaker esterno si puo' generare un suono utilizzando un altoparlante esterno collegando ai pin che sono predisposti sul DAC 2 (GPIO 26) 

 

#define DAC_CH2 26

void setup() {

}

void loop() {

for (int deg = 0; deg < 360; deg = deg + 1) {

  dacWrite(DAC_CH2, int(128 + 64 * sin(deg * PI / 180)));

}

}

 

Per usare LVGL ho provato a passare da Arduino IDE ma ho trovato un mondo di problemi. La soluzione piu' semplice e' il progetto PlatformIO (sempre con base codice Arduino)

Si clona il progetto

git clone --recursive https://github.com/rzeldent/esp32-smartdisplay-demo

in seguito si toglie il commento in platformio.ini in corrispondenza della propria scheda (ci sono molti modelli con differenti risoluzione e touch sia capacitivi che resistivi) e si fa il build

[platformio]

#default_envs = esp32-1732S019C

#default_envs = esp32-1732S019N

#default_envs = esp32-2424S012C

#default_envs = esp32-2424S012N

#default_envs = esp32-2432S022N

#default_envs = esp32-2432S022C

#default_envs = esp32-2432S024C

#default_envs = esp32-2432S024N

#default_envs = esp32-2432S024R

default_envs = esp32-2432S028R

#default_envs = esp32-2432S028Rv2

#default_envs = esp32-2432S028Rv3

Per personalizzare l'interfaccia grafica non sono riuscito ad importare il progetto dentro SquareLine Studio, un programma per creare interfacce di LVGL (il programma non e'stabile in nessuna delle versioni ed ha la necessita' di funzionare con sudo sotto Linux per non meglio chiariti motivi)

Per aggirare il problema ho creato un progetto ex novo Arduino in SquareLine

impostante le dimesioni dello schermo a 320x240x16 colori e nominando la prima finestra scrMain

Dopo aver testato l'interfaccia ho esportato la UI ho copiato il folder /scr/ui nel folder ui di esp32-smartdisplay-demo

 

Da Arduino ad Internet tramite Android

Avevo la necessita' di collegare una Arduino Nano 33 BLE ad internet ma non avevo molte idee quando ho pensato di usare come ponte un telefono Android

La Arduino e' contenuta nella scatolina bianca 

Per leggere i dati della porta seriale di Arduino ho collegato un cavo OTG alla USB di Android usando la libreria https://github.com/felHR85/UsbSerial. I dati poi sono stati inviati in HTTP Get tramite OKHttp. Il progetto della applicazione Android si trova sul mio GitHub https://github.com/c1p81/Seriale (si tratta di una modifica dell'esempio della libreria UsbSerial)

Questo e' invece lo skecth Arduino

=========================================================
#include <Arduino_LSM9DS1.h>
#include <Arduino_HTS221.h>
#include <Arduino_LPS22HB.h>
#include <Arduino_APDS9960.h>

int conteggio;

void setup() {
  conteggio = 0;
  Serial.begin(9600);
  while (!Serial);

  if (!IMU.begin()) {
    Serial.println("Failed to initialize IMU!");
    while (1);
  }

  if (!HTS.begin()) {
    Serial.println("Failed to initialize humidity temperature sensor!");
    while (1);
  }

  
  if (!BARO.begin()) {
    Serial.println("Failed to initialize pressure sensor!");
    while (1);
  }

   if (!APDS.begin()) {
    Serial.println("Error initializing APDS9960 sensor.");
  }

}

void loop() {
  float  x, y, z;
  double dx,dy,dz;
  double mx,my,mz;
  double fx,fy,fz;
  double pitch,roll = 0.0;
  double mpitch,mroll = 0.0;
  const float alpha = 0.5;

  float pressure = BARO.readPressure();
  float temperature = HTS.readTemperature();
  float humidity    = HTS.readHumidity();

   while (! APDS.colorAvailable()) {
    delay(5);
  }
  int r, g, b, light_int;

  APDS.readColor(r, g, b, light_int);

  

  if (IMU.accelerationAvailable()) {
    IMU.readAcceleration(x, y, z);
    dx = (double)x;
    dy = (double)y;
    dz = (double)z;
    
    mx = mx + dx;
    my = mx + dy;
    mz = mx + dz;
    
    fx = (dx*alpha) + (fx*(1-alpha));
    fy = (dy*alpha) + (fy*(1-alpha));
    fz = (dz*alpha) + (fz*(1-alpha));

    conteggio++;
  }

  if (conteggio > 10000)
      {
        mx = mx /conteggio;
        my = my /conteggio;        
        mz = mz /conteggio;
        
        roll = atan2(fy,fz)*57.29577;
        pitch = atan2(-fx,sqrt((fy*fy)+(fz*fz)))*57.29577;

        mroll = atan2(my,mz)*57.29577;
        mpitch = atan2(-mx,sqrt((my*my)+(mz*mz)))*57.29577;

        Serial.println(String(mpitch)+";"+String(mroll)+";"+String(pitch)+";"+String(roll)+";"+String(temperature)+";"+String(humidity)+";"+String(pressure)+";"+String(light_int));
        conteggio = 0;
        fx = fy = fz = 0;
        mx = my = mz = 0;
      
      }

  
  delay(10);
  //delay(5000);
}

=========================================================

I dati sono plottati sul server mediante JSCanvas. Gli script si trovano qui https://github.com/c1p81/Seriale/tree/master/app/seriale_html

Tensorflow Lite su Arduino Ble 33

A questo link e' comparso un interessante esempio su come utilizzare i sensori (accelerometro e giroscopio) di una Arduino BLE per addestrare una rete neurale con Tensorflow Lite e poi utilizzare la stessa libreria per classificare le gesture sempre tramite  Arduino

Per prova ho inserito la Arduino sotto ad un guanto (per tenerla bloccata) e poi registrando un centinaio di rotazione del polso verso l'interno e verso l'esterno

L'ultima modifica che ho apportato e' di modificare a 50 il numero di campioni per gesture
Una volta salvata due file csv (uno per movimento) ho utilizzato questo Colab per creare il file model. h

Grafico accelerazione di riferimento

Come si deve dai grafici l'errore del modello in train/validation e' estremamente ridotto

Grafico giroscopi di riferimento

Training and validation loss

Stesso grafico precedente eliminando i primi 100 dati

Risultati validazione

Il risultato del Notebook sono un file di modello di Tensorflow Lite ed un file model.h che deve essere copiato nello sketch ImuClassifier per fare il deploy del modello

Devo ammettere che il sistema funziona ma e' lontano dall'essere perfetto. Devo ancora capire se e' un problema di posizionamento del sensore durante le varie proprie (che per ovvi motivi non e' sempre identico) od un addestramento errato

BLE Write Characteristic da Android

Dopo il precedente tentativo di leggere una caratteristica BLE da Python adesso un tentativo di scrivere una caratteristica (lo so e' una brutta traduzione) da Android su un dispositivo BLE

Lo sketch Arduino e' stato modificato per esporre una caratteristica 2A30 in modalita' lettura/scrittura, settare il valore a 3, leggere il valore e se e' differente da 3 spengere il Led di Arduino

=================================================================
#include <ArduinoBLE.h>

BLEService numero("180F");
BLEUnsignedCharCharacteristic casuale("2A19",BLERead | BLENotify); 
BLEUnsignedCharCharacteristic scrittura("2A30",BLERead | BLEWrite); 


long previousMillis = 0;  
byte test =3 ;

void setup() {
  Serial.begin(9600);  
  while (!Serial);
  pinMode(LED_BUILTIN, OUTPUT); 
  if (!BLE.begin()) {
    while (1);
  }

  BLE.setLocalName("Random");
  BLE.setAdvertisedService(numero); 
  numero.addCharacteristic(casuale);
  numero.addCharacteristic(scrittura);
  
  BLE.addService(numero); 
  casuale.writeValue(0); // set initial value for this characteristic
  scrittura.writeValue(2);
  BLE.advertise();
}

void loop() {
  int i = 0;
  BLEDevice central = BLE.central();
  if (central) {
    while (central.connected()) {
      long currentMillis = millis();
      if (currentMillis - previousMillis >= 20) {
        previousMillis = currentMillis;
        scrittura.readValue(test);
        if(test ==3)
            {
            Serial.println(test);
            digitalWrite(LED_BUILTIN, HIGH);
            }
            else
            {
            Serial.println(test);
            digitalWrite(LED_BUILTIN, LOW);
            }
            
      }
    }
    digitalWrite(LED_BUILTIN, LOW);    
  }
}

=================================================================

Per Android ho usato la libreria a questo indirizzo . Ne esistono di piu' complete ma
in questo caso avevo bisogno di semplicita'
=================================================================

package com.ble.ellamma.ble;
import android.bluetooth.BluetoothDevice;

import android.content.Context;

import android.content.Intent;

import android.os.Bundle;

import android.support.v7.app.AppCompatActivity;

import android.util.Log;
import com.ble.ellamma.bleand.Ble;

import java.util.UUID;

public class MainActivity extends AppCompatActivity {

    private static final String MAC_ADDRESS = "ED:CB:86:2A:68:C1";    private static final UUID BLE_NOTIFY_CHARACTER =  UUID.fromString("00002a19-0000-1000-8000-00805f9b34fb");    //.00002a19-0000-1000-8000-00805f9b34fb--18
    private static final UUID BLE_SERVICE = UUID.fromString("0000180f-0000-1000-8000-00805f9b34fb");
    private static final UUID CLIENT_CCD =  UUID.fromString("00002a30-0000-1000-8000-00805f9b34fb");

    ArrayList<String> getDevicess;    List<BluetoothDevice> getConnectedDevicess;


    @Override    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);        

        setContentView(R.layout.activity_main);
        getDevicess = new ArrayList<>();        

        getConnectedDevicess = new ArrayList<>();
        Ble ble = new Ble(this,getApplicationContext(),".Myreceiver");
        ble.enableBle();        

        //ble.scanLeDevice(true,1000);        

        //ble.getDevices();

        ble.connectBLE(MAC_ADDRESS);        

        byte dati[] = "A".getBytes();        

        ble.writeCharacteristics(dati,BLE_SERVIVE,CLIENT_CCD,true);        

        ble.disConnectBLE();
    }

    public void onReceive(Context context, Intent intent) {
        //String data = intent.getStringExtra("data");        

        //Log.w("Luca", "Request Recieved On MyReciever ::" + data);
    }

}