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

 

Regressione per illite su suoli naturali

Il dataset visto nel precedente post e' fornito anche da determinazione mineralogiche come la speciazione delle argille. Ho provato a vedere se la regressione con la rete neurale riusciva a fare previsioni dove il metodo della profondita' di picco normalizzata non mi ha mai funzionato nel dottorato 

Lo spettro e' stato associato quindi al contenuto in illite e fatto girare il medesimo script del post precedete

Grafico Loss

Dataset di validazione

Dataset di test

i risultati seppure non eccezionali sono molto migliori di quelli che ho mai ottenuto in dottorato

Regressione con tensorflow su dati di carbonati in suoli naturali

 Dopo aver trovato questo esempio sulla regressione con Tensorflow/Keras ho ritirato fuori un set di misure iperspettrali di laboratorio effettuato con FieldSpec in laboratorio per vedere se il metodo poteva essere utilizzato per la regressione della concentrazione di carbonati in campioni di terreno naturali

I campioni analizzati erano stati tutti setacciati a 0.075 mm ed erano stati passati in forno per eliminare l'umidita'. Di seguito gli spettri

Tutti i campioni sono stati analizzati in laboratorio per la determinazione chimica del contenuto in carbonato di calcio

Gli spettri sono stati letti dai file originali in .asd e convertiti in un csv mediante la libreria Python SpecDal 

L'ultima colonna e' il dato di laboratorio mentre le altre colonne corrispondono alla riflettanza alle differenti lunghezze d'onda e costituiscono le features

Ho provato a non effettuare la rimozione del continuum perche' le misure sono fatte in condizioni controllate su materiale preparato (con parita' di granulometria ed umidita')

Mediante lo script sottostante e' stata effettuata la regressione fino a 100 epochs (non si avevano vantaggi per numeri superiori). Il dataset originario di 40 misure e' stato diviso an 80% di addestramento (di cui 20% di validazione) e 20% di test

Dataset di validazione

Dataset di test

Durante il dottorato, su una serie differente ed usando la profondita' di picco normalizzata a 2345 nm, avevo avuto una regressione migliore utilizzando anche una matematica piu' semplice

L'aspetto interessante di questo approccio e' che non e' necessario conoscere a priori la lunghezza d'onda di assorbimento desiderato. L'algoritmo pur non conoscendolo esplicitamente lo invidua nelle features in modo autonomo

-*- coding: utf-8 -*-

import matplotlib.pyplot as plt

import numpy as np

import pandas as pd

np.set_printoptions(precision=3, suppress=True)

import tensorflow as tf

from tensorflow import keras

from tensorflow.keras import layers

from google.colab import drive

drive.mount('/content/drive')

raw_dataset = pd.read_csv("/content/drive/MyDrive/calcite_vol_75.csv", sep=',')

dataset = raw_dataset.copy()

train_dataset = dataset.sample(frac=0.8, random_state=1)

test_dataset = dataset.drop(train_dataset.index)

print(train_dataset)

train_features = train_dataset.copy()

test_features = test_dataset.copy()

train_labels = train_features.pop('Calcite')

test_labels = test_features.pop('Calcite')

normalizer = tf.keras.layers.Normalization(axis=-1)

normalizer.adapt(np.array(train_features))

def build_and_compile_model(norm):

  model = keras.Sequential([

      norm,

      layers.Dense(64, activation='relu'),

      layers.Dense(64, activation='relu'),

      layers.Dense(1)

  ])

  model.compile(loss='mean_absolute_error',

                optimizer=tf.keras.optimizers.Adam(0.001))

  return model

def plot_loss(history):

  plt.plot(history.history['loss'], label='loss')

  plt.plot(history.history['val_loss'], label='val_loss')

  plt.ylim([0, 10])

  plt.xlabel('Epoch')

  plt.ylabel('Error')

  plt.legend()

  plt.grid(True)

dnn_model = build_and_compile_model(normalizer)

dnn_model.summary()

plot_loss(history)

test_predictions = dnn_model.predict(test_features).flatten()

a = plt.axes(aspect='equal')

plt.scatter(test_labels, test_predictions)

plt.xlabel('True Values')

plt.ylabel('Predictions')

lims = [0, 30]

plt.xlim(lims)

plt.ylim(lims)

_ = plt.plot(lims, lims)

error = test_predictions - test_labels

plt.hist(error, bins=25)

plt.xlabel('Prediction Error ')

_ = plt.ylabel('Count')

Ricampionare un segnale con SciPy

Un sistema rapido per ricampionare dati con spaziatura non omogenea  usando una curva di interpolazione

 

Dati originali

 

import matplotlib.pyplot as plt
from scipy import interpolate
import numpy as np

x = np.array([1, 2, 5, 10])
y = np.array([1, 4, 25, 100])
fcubic = interpolate.interp1d(x, y,kind='cubic')

xnew = np.arange(1, 10, 0.25)
ynew = fcubic(xnew)
plt.plot(x, y, 'X', xnew, ynew,'bo')
plt.show()
print(x)
print(y)
print(xnew)
print(ynew)
 

da osservare che l'interpolazione avviene tramite una spline cubica per cui su cuspidi non e' detto che il risultato sia accettabile. SciPy offre altre opzioni per la curva di interpolazione

 

Riparazione volante Logitech G920

Con il tempo la pedaliera del Logitech G920 ha cominciato a fare i capricci in particolare per quanto riguarda l'acceleratore

Ho provato a smontarla per rimediare

Dopo avere tolto le brugole dai pedali si rovescia la pedaliera e si tolgono tutte le viti con testa argentata. Attenzione che due sono poco visibili perche' nascoste sotto al blocco zigrinato per il tappeto

Una volta tolte le viti si separa il guscio della base...c'e' da fare attenzione al blocco del cavo 

La componente elettrica e' molto semplice, un potenziometro per ogni pedale.

Una volta tolta tutta la polvere accumulata e spruzzato il pulisci contatti sui potenziometri la pedaliera e' tornata a funzionare

Si deve fare molta attenzione a richiudere perche' e' molto semplice rompere i fili stringendoli tra i due gusci (ovviamente cosa che ho fatto)

 

 

 

 

 

Eth0 su LuckFox Pico Mini A

 Le schede Luckfox Pico Mini A (a differenza delle sorelle maggiori) non hanno un connettore RJ45 e nonostante i pin da saldare non sembrano poter disporre di connessione di rete Ethernet.

In realta' basta saldare un cavo ethernet come da foto e modificare il kernel per abilitare la rete

I colori del cavo ethernet da collegare sono

 

TXP : verde bianco

TXN : verde

RXP : arancio bianco

RXN : arancio

Per compilare il kernel sono preferito partire dall'SDK 

Ho clonato il repository https://github.com/LuckfoxTECH/luckfox-pico in /home/luca/luckfox ed ho installato il docker

sudo docker run -it --name luckfox -v /home/luca/luckfox:/home luckfoxtech/luckfox_pico:1.0 /bin/bash

A questo punto

cd tools/linux/toolchain/arm-rockchip830-linux-uclibcgnueabihf/
source env_install_toolchain.sh

Per abilitare la ethernet in Pico Mini A si modifica il file rv1103g-luckfox-pico-mini-a.dts che si trova in 

 /home/luca/luckfox-pico/sysdrv/source/kernel/arch/arm/boot/dts

 sostituendo sotto la stringa &gmac lo status in okay

/**********ETH**********/
&gmac {
    status = "okay";
};

/**********USB**********/

 si compila il kernel con ./build.sh lunch (opzione 1) e ./build.sh

Attenzione: per l'immagine Ubuntu non funziona la camera

I file si troveranno nella cartella IMAGE  

Tramite il tool https://files.luckfox.com/wiki/Luckfox-Pico/Software/SocToolKit.zip

ATTENZIONE: VirusTotal segnala presenza di virus (aprire in sandbox)

si crea la scheda SD con i file appena generati

 Tutto funziona camera compresa...attenzione a non usare VLC. Io ho usato il player rtsp integrato in Firefox

 

 

 

 

 

 

Perche' investire su Unix

 Un libro trovato nel libero scambio alla Coop su cio' che poteva essere e non e' stato...interessante la storia su Unix del primo capitolo