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