Bare Metal C64 con Raspberry 3D Case

Sto giocando con BMC64 e, non volendo sacrificare un case di C64 funzionante, mi sono adattato con questo caso stampato in 3D

I colori sono quelli del VIC 20 ma va benissimo cosi'

Regolatori di tensione per Arduino

Per provare un pannello solare con una batteria ho preso un regolatore di tensione (il pannello solare esce a circa 19 V mentre la batteria e' da 12 V

 https://www.amazon.it/gp/product/B01EL9IG6K/ref=oh_aui_search_asin_title?ie=UTF8&psc=1

Per prova ho testato un LM317, un regolatore di tensione lineare. Il componente ha una Vdroput di 3V per cui se si applica una tensione di Vin di 12 V non potremo ottenere piu' di 9 V dal Vout

Per pilotare il componente si usano 2 resistenze

Per il calcolo della Vout si usa la formula

R2 = [(Vin/1.25)-1]* R1

Per esempio se si vuole ottenere una Vout di 5v data un R1 di 220 Ohm si dovra' impostare una R2 di 660 Ohm

Questi componenti non sono molto efficienti e dissipano la corrente in eccedenza come calore.
Prendendo una Arduino ed una sorgente di una batteria di 9V si ha che la potenza dissipata e' data da

W = (9-5)V*0.04A = 0.16W

E' necessario usare un dissipatore termico per valori superiori a 0.25W
usando il rapporto di 19°C/W si ha che l'integrato si riscalda di circa 3°C

Regolatore tensione Arduino Uno

Ma ha senso usare un regolatore di tensione esterno su Arduino Uno??
La Arduino Uno usa un regolatore di tensione LDO NCP1117ST50T3G che eroga una tensione fissa di 5V con un dropout di soli 1.2V ed una tensione di Vin di 20 V.
Il pannello solare eroga in piena insolazione 19.7 V.....e' molto al limite forse troppo (le tensioni consigliate per il regolatore di tensione sono 7-12V max 19V) ma in ogni caso e' integrato un circuito di protezione

Filtro Kalman e tempo di campionamento

Stavo continuando a provare questa libreria del filtro Kalman per MPU quanto, per risparmiare spazio su disco, ho provato a modificare il tempo di campionamento da 20 ms ad 1 secondo ed ' accaduto qualcosa che non mi aspettavo

Tempo di campionamento 1 sec

Nr campioni : 5085
Media : -0.35
Range : 7.44
Std : 0.21
Varianza : 0.044
Skewness : -14.8

Tempo di campionamento 0.02 sec

Nr campioni : 67889
Media : -0.35
Range : 0.33
Std : 0.0.37
Varianza : 0.0014
Skewness : -0.011

Come si vede il valore medio e' comparabile ma la standard deviation e' decisamente peggiore con il tempo di campioanmento di 1 secondo

Google Car Agosto 2018

Ad agosto avevo avvistato la Google Car a giro per Firenze

ed adesso mi sono ritrovato (macchina arancione) in Google Street View...anche se non e' la prima volta

MPU 6050 con filtro Kalman ed Arduino Uno

Ho trovato questa comoda libreria per interfacciare MPU6050 (un accelerometro-giroscopio triassiale) con Arduino e processare i dati con il filtro di Kalman in tempo reale

(Per un articolo di data fusion sui dati di accelerometro e giroscopio si puo' andare a questo link applicato ai filtri Kalman)

La connesione tra MPU 6050 (anche chiamato GY 521) avviene sul canale I2C. E' quindi collegare Vcc a 3,3V, GND e SDA su pin Arduino A4 ed SCL su pin Arduino A5

Ho acquisito un po' di misure e le ho poi processate con Octave. Si vede chiaramente che il valore medio dell'angolo di roll e' comparabile tra le misure con e senza filtro di Kalman...il dato che varia in modo sensibile e' la standard deviation (le misure sono state effettuate a sensore fermo e spengendo e riaccendendo il sensore per evitare un eventuale drift del giroscopio)

Le misure sono angoli di roll espressi in gradi decimali

Set senza filtro Kalman
Nr misure : 7572
Media : -6.76
Range : 2.15
Stdev : 0.2
Varianza : 0.041
Skewness : 0.054



Set 1 con fil tro Kalman
Nr misure : 28013
Media : -6.71
Range : 0.46
Stdev : 0.05
Varianza : 0.003
Skewness : -0.051


Set 2 con fil tro Kalman
Nr misure  : 11844
Media : -6.71
Range : 0.46
Stdev : 0.05
Varianza : 0.003
Skewness : -0.12



Set 3 con fil tro Kalman
Nr misure : 5545
Media : -6.76
Range : 0.35
Stdev : 0.05
Varianza : 0.0025
Skewness : 0.14

Internet Yellow Pages

Un reperto del passato, un libro in cui sono elencati e descritti siti Web ...e direi che Google e prima ancora Altavista erano gia' disponibili

AStable NE555

Stavo giocando con la generazione di suoni con una Arduino ed un altoparlante (metto sotto il semplice progettino) quando mi e' venuto in mente....perche' non farlo senza microcontrollore ma con la sola elettronica analogica e quindi con un NE555

Circuito NE555 Astable

Fonte Wikipedia

Accrescere il valore del condensatore C  al di sotto del potenziometro riduce la frequenza aumentando il periodo.

Accrescere il valore della parte superiore R1 della resistenza variabile (parte superiore guardando il grafico sopra) aumenta il periodo di segnale alto (ma non modifica il periodo di segnale basso

Accrescere il valore della parte inferiore R2 della resistenza variabile aumenta il periodo di segnale basso e decrementa il duty cycle (ovvero il rapporto tra stato alto e stato basso fino ad un minimo del 50%)

il tempo di stato 1 sara' pari a T_alto = 0.693(R1+R2)*C
il tempo di stato 0 sara' pari a T_alto = 0.693*R2*C

per avere un periodo alto uguale al periodo basso R1 deve essere posto a zero

La frequenza e' calcolata come f=1.4/((R1+2R2)*C)

https://dlb.sa.edu.au/rehsmoodle/file.php/466/kpsec.freeuk.com/555timer.htm

per avere una frequenza di 440 Hz si deve porre di circa 164 nF (questo il calcolatore)

Ovviamente al posto del voltmetro va messo un altoparlante

Il consumo di NE555 e' di circa 15 mA

E se si volesse scendere con duty cyle inferiori al 50%??? (ovvero se invece di generare un suono volessi un interruttore che si apre ad determinati intervalli per un breve periodo di tempo)

Si devono inserire due diodi attorno al potenziometro

Circuito NE555 Astable con duty cycle inferiore al 50%

Un sostituto a basso consumo di NE555 e' ICM7555 che funziona anche a 1.5 V con un consumo di 60 microA

Configurazione Astable di ICM7555

Se si vuole generare un suono con Arduino basta lo script sottostante e collegare il jack audio al GND ed al PIN 11 per avere una nota di 250 Hz

---------------------------------------------------
void setup() {
  pinMode(11, OUTPUT);
}
void loop() {
  digitalWrite(11, HIGH);  
  delay(2);                       
  digitalWrite(11, LOW);     
 delay(2);                  
}
---------------------------------------------------

Ma come fare ad avefe note piu' acute con periodo inferiore al microsecondo. Si possono usare le librerie Mozzi e Tone che, giocando sui timer TCRR0A eTCRR0B permettono di ottenere variazioni piu' brevi dello stato delle porte digitali (a 16 MHz il limite teorico di un clock del processore e' di 62.5 nanosecondi)

Oscilloscopio DSO150 Shell ed Arduino Uno

Ho preso un oscilloscopio portatile DSO150 per una trentina di euro (gia' montato ad esclusione del case)

Premendo i primi due pulsanti (V/Div e Sec/Div) ed agendo su Adj si puo' modificare le divisioni sull'asse verticale da 5mv/Div a 20V/Div e sull'asse orizzontale da 10 us/Div a 500 s/Div.
Agendo su Trigger si puo' avere l'impostazione Automatica, Normale e Single (L'icona piu' a destra del Trigger indica se il trigger avviene in fase ascendente o discendente)
Premendo il tasto OK si manda in Hold il dispositivo

Se si preme due volte il pulsante Sec/Div il cursore nella parte alta diventa blu e con ADJ si puo' spostare a destra e sinistra il grafico

Attenzione : il valore V picco-picco risulta essere di 0.5 V mentre la Arduino ha una tensione sul pin di 5 V. Tale differenza di valori e' dovuta al fatto che la sonda ha una attenuazione di un fattore 10

Usando il solo comando ADJ si trasla verso l'alto e verso il basso tutto il grafico

Se si usa lo script sotto stante su Arduino e si collega la sonda al pin 11 e si collega il GND dell'Arduino al GND a coccodrillo della sonda si ottiene il risultato della foto soprastante
------------------------------------------------------------
void setup() {
  pinMode(11, OUTPUT);
}

void loop() {
  digitalWrite(11, HIGH);   
  delay(10);                      
  digitalWrite(11, LOW);    
  delay(10);                       

}
------------------------------------------------------------

A sinistra il coccodrillo GND della sonda ed in grigio la sonda

Il dispositivo viene venduto anche con due coccodrilli al posto della sonda P6020 con attacco BNC ma meglio spendere qualche euro in piu'

L'alimentazione e' a 9 Volt con pin centrale positivo. Il consumo del dispositivo e' modesto ed oltre che da alimentatore di rete puo' essere utilizzata anche una comune batteria da 9V

Aggacciando la sonda all'anello accanto al BNC c'e' un segnale di test pari a 1KHz

Si vede come la parte superiore dello schermo sia popolata da molti indicatori...cio' rende un po' difficile la lettura del segnale (Duty cicle e' il rapporto, in un'onda quadra, tra il valore del tempo trascorso sullo stato alto rispetto a quello basso. Vengono inoltre riportata la frequenza, il periodo, il Max, Min voltaggio, il voltaggio medio, il valore di voltaggio picco-picco ed il voltaggio RMS ovvero il valore medio quadratico dell'onda))...in pratica e' il valore Vpp per l'inverso della radice quadrata di 2. La modalita' GND serve a centrare l'asse delle y sullo zero

Nella parte alta c'e' un ulteriore switch AC DC e GND. In modo DC la sonda e' direttamente collegata al dispositivo e si misurano le correnti continue, in modalita' AC viene frapposto un condensatore tra la sonda ed il misuratore in modo da eliminare la parte in corrente continua (ed e' quindi la modalita' idonea a misurare segnali variabili nel tempo

Zilog Z80

Dentro un apparato audio e' stato trovato questo Zilog Z80, in particolare un Z0806000PSC

Toshiba TMP4320AP

Oggi si e' aggiunto alla mia collezione un TPM4320AP della Toshiba,  un microprocessore (per altri un microcontroller) a 4 bit della prima meta' del 1980 (qui il il link al manuale) della seria TLCS-43 in tecnologia NMOS con 2K di memoria Rom e 128 byte di Ram e 35 istruzioni

Qualcuno nel mio ufficio confonde oramai da anni il contenitore per lo smaltimento delle batterie con quello dei RAEE ed ogni tanto ci si trovano delle perle come questi due strumenti

Qui l'"unboxing" dello strumento

Oltre il microprocessore si trova un TD62501p (array di transistor NPN)

Un TC4066BP (uno switch multiplo), un CA3162E (il driver per il display a led rossi)

ed infine un CA3160E, un amplificatore operazionale

Differenza FreeRTOs su Arduino AVR e SAMD21 e ESP-Wroom-32

La principale differenza nell'implementazione di FreeRTOs in ESP32 ed in Arduino Uno (ovvero AVR ATMega328) e' il fatto che Esp32 e' un processore dual core. FreeRTOs riesce a distribuire il carico del lavoro tra i core. Nell'esempio sottostante (ripreso da qui), fatto girare su Esp-Wroom-32, si vede che il main loop ed il task vengono eseguiti su due core differente in modo parallelo

Viene creato un task generico che fa un solo loop e poi si autodistrugge (vTaskDelete(NULL)) mentre il loop principale continua a rimanere in esecuzione.
-------------------------------------------------------------------------
void setup() {

  Serial.begin(9600);
  delay(1000);

  Serial.print("Setup: Executing on core ");
  Serial.println(xPortGetCoreID());

  xTaskCreate(
                    genericTask,       /* Task function. */
                    "genericTask",     /* String with name of task. */
                    10000,             /* Stack size in words. */
                    NULL,              /* Parameter passed as input of the task */
                    2,                 /* Priority of the task. */
                    NULL);             /* Task handle. */
 delay(2000); 

}

void loop() {
  Serial.print("Main Loop: Executing on core ");
  Serial.println(xPortGetCoreID());
  delay(1000);
}

void genericTask( void * parameter ){
    Serial.print("Created task: Executing on core ");
    Serial.println(xPortGetCoreID());
    vTaskDelete(NULL);
}

-----------------------------------------------------------------------------------------
Setup: Executing on core 1
Created task: Executing on core 0
Main Loop: Executing on core 1
Main Loop: Executing on core 1

Main Loop: Executing on core 1


 Se si usa #include <Arduino_FreeRTOS.h> si vedra' che non esiste nemmeno la funzione xprtoGetCoreID perche' ATMega328 e' un processore single core...i task vengono eseguiti su un unico core dividendo i tick del processore tra i vari task come un time sharing

Le cose non cambiano con la serie Arduino MKR che montano SAM D21 Cortex M0-+ (solo alcuni  Cortex di fascia alta sono multi core) 

Blink con FreeRTOs

Questo e' il classico di Blink del pin 13 pero' compilato usando un task di FreeRTOS.
Questa configurazione permette di lanciare il task e poi di addormentare il processore.
Il classico esempio blink "consuma" circa 45 mA mentre con questo codice circa 20 mA

Un altro aspetto non trascurabile e' si puo' impostare il tempo di lampeggio sopra gli 8 secondi

Con il codice normale di Arduino l'unico metodo di risvegliare il processore e' quello derivante da un interrupt derivante dal watchdog (impostabile al massimo ad 8 secondi) oppure si deve utilizzare un interrupt esterno derivante da un RTC esterno

--------------------------------------------------------------------------------------
#include <Arduino_FreeRTOS.h>
#include <avr/sleep.h>  
#include <avr/power.h>  



void TaskBlink( void *pvParameters );

void setup() {
  xTaskCreate(TaskBlink,(const portCHAR *)"Blink",128 ,NULL,2,NULL);
}

void loop()
{
power_adc_disable(); //ADC
power_spi_disable(); //SPI
power_twi_disable(); //I2C


//set_sleep_mode( SLEEP_MODE_PWR_DOWN ); 
set_sleep_mode( SLEEP_MODE_EXT_STANDBY); 

portENTER_CRITICAL();
sleep_enable();

#if defined(BODS) && defined(BODSE)
sleep_bod_disable();
#endif

portEXIT_CRITICAL();

sleep_cpu(); 

sleep_reset();
}

void TaskBlink(void *pvParameters)  // This is a task.
{
  (void) pvParameters;

  pinMode(LED_BUILTIN, OUTPUT);

  for (;;) 
  {
    digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)
    vTaskDelay( 1000 / portTICK_PERIOD_MS ); // wait for one second
    digitalWrite(LED_BUILTIN, LOW);    // turn the LED off by making the voltage LOW
    vTaskDelay( 7000 / portTICK_PERIOD_MS ); // wait for one second
  }
}

Queue con FreeRTOS su Arduino Uno

Le Queue, code, di FreeRTOs sono metodi per scambiare dati tra due task. In questo esempio una coda monodirezionale (un task invia dati e l'altro li riceve)


-----------------------------------------------------------------
#include <Arduino_FreeRTOS.h>
#include <queue.h>  

QueueHandle_t coda;
int codasize = 10;

void sender( void *pvParameters );
void receiver( void *pvParameters );

void setup() {

  Serial.begin(9600);
  coda = xQueueCreate(codasize,sizeof(int));
  
  if ( coda == NULL )   {
     Serial.println("Errore nella creazione");
  }

  xTaskCreate(sender,(const portCHAR *)"Sender",128,NULL,3,NULL);
  xTaskCreate(receiver,(const portCHAR *)"Receiver",128,NULL,2,NULL);

}

void loop()
{
}



void sender( void *pvParameters __attribute__((unused)) )  // This is a Task.
{
  for (;;)
  {
    for (int t=0;t<5;t++){
      xQueueSend(coda,&t,portMAX_DELAY);
    }
    vTaskDelay( 1000 / portTICK_PERIOD_MS );

  }
}


void receiver( void *pvParameters __attribute__((unused)) )  
{
  int elemento;
  for (;;)
  {
    for (int t=0;t<codasize;t++){
      xQueueReceive(coda,&elemento,portMAX_DELAY);
      Serial.print(elemento);
      Serial.print("|");
    }
    Serial.println();

    vTaskDelay( 1000 / portTICK_PERIOD_MS );
  }
}

Semafori binari in FreeRTOS con Arduino

I semafori binari (o Mutex) sono metodi per stabilire per un task per capire se una risorsa condivisa e' occupata da un altro task (e quindi non utilizzabile) oppure e' disponibile

In questo esempio sono creati due task che ogni 5 secondi si sovrappongono e cercano entrambi di scrivere sulla porta seriale.
----------------------------------------------------------------------------------

#include <Arduino_FreeRTOS.h>
#include <semphr.h>  
SemaphoreHandle_t semaforo;

void blink_even( void *pvParameters );
void blink_odd( void *pvParameters );

void setup() {

  Serial.begin(9600);


  if ( semaforo == NULL )   {
    semaforo = xSemaphoreCreateMutex();  
    if ((semaforo) != NULL)
      xSemaphoreGive((semaforo));  
  }

// crea i due task
  xTaskCreate(blink_even,(const portCHAR *)"BlinkEven",128,NULL,3,NULL);
  xTaskCreate(blink_odd,(const portCHAR *)"BlinkOdd",128,NULL,2,NULL);

}

void loop()
{
}



void blink_even( void *pvParameters __attribute__((unused)) )  
{
  for (;;)
  {// qui viene testato se il semaforo e' settato, se la risorsa e'occupata riprova per 5 tick ..in caso la risorsa
   // rimanga occupata abbandona
    if (xSemaphoreTake(semaforo, ( TickType_t ) 5 ) == pdTRUE )
    {
      Serial.println("Even");
      xSemaphoreGive(semaforo);
    }
    vTaskDelay( 5000 / portTICK_PERIOD_MS );

  }
}


void blink_odd( void *pvParameters __attribute__((unused)) )  
{
  for (;;)
  {
    if (xSemaphoreTake(semaforo, ( TickType_t ) 5 ) == pdTRUE )
    {
      Serial.println("Odd");
      xSemaphoreGive(semaforo);
    }
    vTaskDelay( 1000 / portTICK_PERIOD_MS );
  }
}

Diventare amministratore della macchinetta del caffe'

Per motivi non meglio spiegati (sarebbe interessante scoprire il metodo) la macchinetta del caffe' dell'ufficio e' andata in crisi lasciando aperta una bella shell di amministrazione ...ops menu' di configurazione con cui poter fare qualunque cosa

Per interagire con il menu si possono usare Zucchero - e Zucchero + per andare indietro ed avanti, Caffe' e cioccolato per selezionare (Ok) e Caffe' al gingseng per andare indietro nel menu (i pusalnti sono illuminati in modalita' di amministrazione) 

Si puo' fare di tutto, dal cambiare il prezzo delle varie bevande ad avere le statistiche. Peraltro sembra che la macchinetta possa trasmettere i dati in remoto (non credo invece che possa essere controllata in remoto altrimenti sarebbe gia' stata resettata)

.....e no, non ne ho approfittato..nemmeno un caffe'

Mongoose OS ed ESP-Wroom-32

Un paio di indicazioni:
1) Mongoose OS non e' legato a MongoDB e Node.JS...maledetta fantasia nel mettere i nomi
2) in estrema sintesi Mongoose OS e' molto simile al cloud di Particle con la differenza che quest'ultimo e' legato a doppio filo con l'hardware di Particle (Electron, Photon) mentre Mongoose OS puo' essere usato con hardware ESP32 ed STM32

Per inziare ho scaricato il pacchetto generico per Linux

curl -fsSL https://mongoose-os.com/downloads/mos/install.sh | /bin/bash mos

e si lancia il programma in $HOME/.mos/bin/mos

si aprira' il browser di default all'indirizzo http://127.0.0.1:1992/

Le istruzioni dicono di premere CTRL+N per creare una nuova app ma su Chrome per Linux questa combinazione apre una nuova scheda del browser. Si puo' pero' usare la barra in basso allo schermo (vicino all'icona arancione che si trova nell'angolo in basso a destra) per digitare 

mos clone https://github.com/mongoose-os-apps/demo-js app1

a seguire (la compilazione avviente completamente sul cloud...i risultati saranno nella sottodirectory build)

mos build

mos flash 

Per avere la possibilita' di interagire in remoto ed effettuare anche degli OTA update (Over the air) si puo' configurare la connessione con l'access point con 

mos wifi WIFI_NETWORK_NAME WIFI_PASSWORD

Una volta ottenuta la connessione si rete si puo' impostare la connessione al cloud.Ci si collega a  https://dash.mongoose-os.com/ e si crea un nuovo dispositivo (con il profilo gratuito se ne possono creare fino a 3)

si copia il token (basta andare sopra al token) e da http://127.0.0.1:1992/ si digita

mos config-set dash.enable=true dash.token=xxxxxxxxdc08

se tutto e' andato bene il dispositivo comparira' on line nel cloud
Dall'interfaccia Web si puo' impostare il comando remoto tramite Mobile (si tratta di un link)
Si puo' accendere o spengere una porta digitale. Con il modulo ESP-Wroom-32 il pin preimpostato e' il numero 13 (IO13 a destra di GND)

La programmazione successiva puo' avvenire mediante C o Javascript. In generale, leggendo anche il forum, si tratta di un progetto piuttosto immaturo con un supporto ancora scarso con l'hardware (nonostante sia comunque presente la possibilita' di convertire le librerie Arduino nei progetti Mongoose)

Impostazione ProtonVPN su Debian 9

Questo e' un promemoria perche' regolarmente mi scordo come si fa ad impostare ProtonVPN su Debian

per prima si installano i pacchetti per openvpn in Network Manager

apt-get install openvpn network-manager-openvpn network-manager-openvpn-gnome

Si logga quindi su https://account.protonvpn.com/login/

Da Account si copia OpenVPN/IKEv2 Username

e da Download si scaricano i file .ovpn relativi ai server (free nel mio caso) 

Fatto cio' si apre Network Manager/VPN/VPN Settings e si aggiunge il nuovo server importando il file .ovpn ed inserendo come username il precedente OpenVPN/IKEv2 Username e la password

Toolchain per ESP32 su Linux

Post per impostare l'ambiente di sviluppo esp32-idf su Debian 9

si installano i pacchetti

apt-get install gcc git wget make libncurses-dev flex bison gperf python python-pip python-setuptools python-serial python-cryptography python-future python-pyparsing

e successivamente
mkdir esp
cd ~/esp 

git clone -b v3.1.3 --recursive https://github.com/espressif/esp-idf.git

cd esp-idf
export IDF_PATH=~/esp/esp-idf 

si scarica il compilatore e lo si decomprime

tar -xzf ~/Downloads/xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz
si inserisce l'ambiente di sviluppo in Path

export PATH="$HOME/esp/xtensa-esp32-elf/bin:$PATH"

se tutto e' andato bene si puo' andare in $HOME/esp/esp-idf/examples/get-started/hello_world e digitare make per vedere se il progetto si compila (viene generato il bootloader all'indirizzo 0x10000 oltre al programma vero e proprio all'inidirizzo 0x8000). Al termine si puo' digitare

make flash 

per copiarlo sulla scheda (questi i messaggi)

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

Flashing binaries to serial port /dev/ttyUSB0 (app at offset 0x10000 )...

esptool.py v2.6

Serial port /dev/ttyUSB0

Connecting....

Chip is ESP32D0WDQ6 (revision 0)

Features: WiFi, BT, Dual Core, Coding Scheme None

MAC: 24:0a:c4:05:df:5c

Uploading stub...

Running stub...

Stub running...

Configuring flash size...

Auto-detected Flash size: 4MB

Flash params set to 0x0220

Compressed 21184 bytes to 12506...

Wrote 21184 bytes (12506 compressed) at 0x00001000 in 1.1 seconds (effective 153.7 kbit/s)...

Hash of data verified.

Compressed 144080 bytes to 68379...

Wrote 144080 bytes (68379 compressed) at 0x00010000 in 6.0 seconds (effective 190.8 kbit/s)...

Hash of data verified.

Compressed 3072 bytes to 103...

Wrote 3072 bytes (103 compressed) at 0x00008000 in 0.0 seconds (effective 1843.8 kbit/s)...

Hash of data verified.

Leaving...

Hard resetting via RTS pin...

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

Collegandosi con minicom alla /dev/ttyUSB0 si ottengono le seguenti stringhe

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

rst:0xc (SW_CPU_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)                          

configsip: 0, SPIWP:0xee                                                        

clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00         

mode:DIO, clock div:2                                                           

load:0x3fff0018,len:4                                                           

load:0x3fff001c,len:5804                                                        

load:0x40078000,len:9188                                                        

load:0x40080000,len:6084                                                        

entry 0x4008032c                                                                

I (29) boot: ESP-IDF v3.1.3 2nd stage bootloader                                

I (29) boot: compile time 11:25:47                                              

I (29) boot: Enabling RNG early entropy source...                               

I (34) boot: SPI Speed      : 40MHz                                             

I (38) boot: SPI Mode       : DIO                                               

I (42) boot: SPI Flash Size : 4MB                                               

I (46) boot: Partition Table:                                                   

I (49) boot: ## Label            Usage          Type ST Offset   Length         

I (57) boot:  0 nvs              WiFi data        01 02 00009000 00006000       

I (64) boot:  1 phy_init         RF data          01 01 0000f000 00001000       

I (72) boot:  2 factory          factory app      00 00 00010000 00100000       

I (79) boot: End of partition table                                             

I (83) esp_image: segment 0: paddr=0x00010020 vaddr=0x3f400020 size=0x07180 ( 2p

I (102) esp_image: segment 1: paddr=0x000171a8 vaddr=0x3ffb0000 size=0x022a0 ( d

I (106) esp_image: segment 2: paddr=0x00019450 vaddr=0x40080000 size=0x00400 ( d

I (110) esp_image: segment 3: paddr=0x00019858 vaddr=0x40080400 size=0x067b8 ( d

I (130) esp_image: segment 4: paddr=0x00020018 vaddr=0x400d0018 size=0x11150 ( p

I (155) esp_image: segment 5: paddr=0x00031170 vaddr=0x40086bb8 size=0x02130 ( d

I (164) boot: Loaded app from partition at offset 0x10000                       

I (164) boot: Disabling RNG early entropy source...                             

I (166) cpu_start: Pro cpu up.                                                  

I (170) cpu_start: Starting app cpu, entry point is 0x40080e74                  

I (162) cpu_start: App cpu up.                                                  

I (181) heap_init: Initializing. RAM available for dynamic allocation:          

I (187) heap_init: At 3FFAE6E0 len 00001920 (6 KiB): DRAM                       

I (193) heap_init: At 3FFB32F8 len 0002CD08 (179 KiB): DRAM                     

I (200) heap_init: At 3FFE0440 len 00003BC0 (14 KiB): D/IRAM                    

I (206) heap_init: At 3FFE4350 len 0001BCB0 (111 KiB): D/IRAM                   

I (213) heap_init: At 40088CE8 len 00017318 (92 KiB): IRAM                      

I (219) cpu_start: Pro cpu start user code                                      

I (237) cpu_start: Starting scheduler on PRO CPU.                               

I (0) cpu_start: Starting scheduler on APP CPU.                                 

Hello world!                                                                    

This is ESP32 chip with 2 CPU cores, WiFi/BT/BLE, silicon revision 0, 4MB exterh

Restarting in 10 seconds...                                                     

Restarting in 9 seconds...                                                      

Restarting in 8 seconds...                                                      

Restarting in 7 seconds...                                                      

Restarting in 6 seconds...                                                      

Restarting in 5 seconds...                                                      

Restarting in 4 seconds...                                                      

Restarting in 3 seconds...                                                      

Restarting in 2 seconds...                                                      

Restarting in 1 seconds...                                                      

Restarting in 0 seconds...                                                      

Restarting now.

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

Questo comportamento e' coerente con il programma hello_world.c

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

/* Hello World Example

   This example code is in the Public Domain (or CC0 licensed, at your option.)

   Unless required by applicable law or agreed to in writing, this

   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR

   CONDITIONS OF ANY KIND, either express or implied.

*/

#include <stdio.h>

#include "freertos/FreeRTOS.h"

#include "freertos/task.h"

#include "esp_system.h"

#include "esp_spi_flash.h"

void app_main()

{

    printf("Hello world!\n");

    /* Print chip information */

    esp_chip_info_t chip_info;

    esp_chip_info(&chip_info);

    printf("This is ESP32 chip with %d CPU cores, WiFi%s%s, ",

            chip_info.cores,

            (chip_info.features & CHIP_FEATURE_BT) ? "/BT" : "",

            (chip_info.features & CHIP_FEATURE_BLE) ? "/BLE" : "");

    printf("silicon revision %d, ", chip_info.revision);

    printf("%dMB %s flash\n", spi_flash_get_chip_size() / (1024 * 1024),

            (chip_info.features & CHIP_FEATURE_EMB_FLASH) ? "embedded" : "external");

    for (int i = 10; i >= 0; i--) {

        printf("Restarting in %d seconds...\n", i);

        vTaskDelay(1000 / portTICK_PERIOD_MS);

    }

    printf("Restarting now.\n");

    fflush(stdout);

    esp_restart();

}

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

In conclusione l'ambiente di sviluppo e' funzionante

Calcolo durata batteria per mini progetti

Fino ad oggi calcolavo la durata teorica di funzionamento di un utilizzatore (tipicamente una Arduino) connesso ad una batteria LiPo dividendo i mAh della batteria per il consumo in ampere dell'utilizzatore

Per esempio: con una batteria da 2500 mAh ed una Arduino Uno in configurazione base con consumo da 45 mA stimavo il tempo di funzionamento in 2500 mAh/45 mA cioe' circa 55 ora

In realta' il calcolo e' sbagliato perche' si deve tenere conto della potenza in Watt (o meglio si deve tenere in conto della potenza nel caso in cui il voltaggio della batteria e dell'utilizzatore sono identici ....ma questo e' un caso particolare)

Prendendo l'esempio precedente una batteria LiPo da 2500 mAh con un 3.7 ha un potenza di 9.25 Wh, La Arduino Uno ha un consumo di circa 45mA a 5 V pèari a 0.225 W. Dividendo 9.25 Wh per 0.225 h si ottiene che il tempo di funzionamento di circa 41 ore (valore sensibilmente differente dal calcolo, errato, precedente)

AC6 System Workbench per Debian 9

ed alla fine sono riuscito ad avere una IDE per STM32 funzionante su Debian 9

Per l'installazione l'utente deve poter essere nei sudoers

Il problema era piuttosto semplice alla fine e viene dopo l'installazione. Una volta installato System Workbench con l'installer la compilazione del programma funziona in modo corretto ma viene generato un errore da GDB

la soluzione e' installare libncurses e creare un link simbolico tra la versione 6 32bit e la versione 5 (non disponibile nel repository...basta il symlink)

root@debian:/usr/lib/i386-linux-gnu# ln -s libncurses.so.6 libncurses.so.5