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 );
  }
}