lunedì 11 marzo 2024

Standard 7090: STM32F103

Nell'ambito dello sviluppo del sistema Standard 7090, che state seguendo su questo blog da alcuni post, oggi integriamo anche una scheda con microcontrollore STM32F103. Si tratta di un microcontrollore basato su ARM Cortex-M3 con clock da 72MHz. Tale micro ha guadagnato successo anche attraverso la sua versione low-cost proposta sotto forma di scheda Bluepill (si tratta generalmente di un micro CKS).

Scheda Standard 7090 con programmatore ST Link V2

Alcuni test preliminari, ci hanno consentito di sviluppare del codice con l'IDE STM32Cube, oppure con l'IDE Arduino (STM32duino) e hanno dato esito positivo. Pertanto abbiamo qui deciso di integrare anche questo microcontrollore nello Standard 7090, sia per il basso costo sia per le prestazioni molto interessanti.

Schermata della comunicazione UART

Non mi resta che augurarVi una buona sperimentazione con questa piattaforma, ricordandovi che potete contattarmi personalmente per eventuali sviluppi professionali.

Un caro saluto e a presto :)

domenica 10 marzo 2024

ESP32: effetto Wow!

 Ero alla ricerca di un titolo per questo Post. Pensavo ESP 32 ...da brividi!

Fig. 1 - ESP32. Piastra di assieme prototipale


In effetti se realizzerete una piastra prototipale come quella in Figura 1, alcuni brividi potrebbero occorrere nel corso dei vostri sviluppi (...se non altro per l'utilizzo di così tante connessioni precarie come quelle dei cavetti di collegamento rapido.).

Cosa abbiamo inserito questa volta sulla nostra piastra prototipale? Ecco l'elenco:

  1. Audio I2S con altoparlante
  2. Display OLED
  3. Sensore di pressione BMP180
  4. Sensore di umidità e temperatura DHT11
  5. Orologio datario DS3231
  6. microSD card con File System
  7. Rele di potenza
  8. Led PWM
  9. Encoder rotativo
  10. Web Server con visualizzazione dati e comandi remoti

L'effetto Wow è che il tutto è stato provato con un programma compatibile con l'IDE Arduino.

Se siete interessati a ricevere gratuitamente il codice sorgente, contattatemi personalmente.

Per il resto Vi auguro una buona sperimentazione con ESP 32 e a presto :)


sabato 9 marzo 2024

Standard 7090: Raspberry Pi Zero W - Parte 1

Nel nostro laboratorio non vivono solo schede Arduino, ESP8266, ESP32, STM32, ma c'è ampio spazio per le applicazioni Linux Embedded. Oggi è la volta di Raspberri Pi - un noto progetto multiboard che offre prestazioni di tutto rispetto.


La scheda Raspberry Pi Zero W con interfaccia UART su scheda 70x90


In questo post integreremo la scheda Raspberry Pi Zero W (...wireless) con il Bus 7090 e inizieremo a configurare la porta seriale per comunicare con il Display TFT e con le altre eventuali schede.

Dopo aver configurato il file system con l'imager appropriato (ho utilizzato una microSD da 64 Giga per poter provare un'ampia varietà di applicazioni), configuriamo anche la console UART, in modo da poter avere un doppio accesso al sistema sia da SSH sia da porta seriale.

Per la configurazione della console utilizzare anche l'utility raspi-config. In particolare occorre assicurarsi che la console seriale sia abilitata nella sezione interfacce.

Verificare le opzioni con il comando: sudo raspi-config


Con l'utility PuTTY ho effettuato tutti i test seguenti:

Configurare SSH e IP address della scheda Raspberry per connettersi

Configurare ttyS0 con il comando: sudo stty -F /dev/ttyS0 9600

Aprire una sessione seriale su COMx alla velocità di 9600 bps

Connettersi con l'adattatore seriale USB su COMx

Al termine di questo esperimento avremo configurato la porta UART ttyS0 alla velocità di 9600 bps e potremo utilizzarla per comunicare con le altre schede del sistema Standard 7090.

Vi auguro una buona sperimentazione con Raspberry e a pesto.


Standard 7090: Arduino Nano 328 + nRF24L01

Ancora una scheda con Arduino ATmega328. Questa volta la integriamo su di una scheda 70x90 e con l'utilizzo di un modulo ricetrasmettitore nRF24L01. Il tutto è stato predisposto per funzionare sul Bus 7090 e potersi collegare al Display TFT, alimentandosi dalla scheda PSU.

Scheda 70x90 con modulo PCB Arduino Nano 328 + nRF24L01

Il ricetrasmettitore nRF24L01 è un modulo molto popolare, da collegare alla porta SPI di Arduino o altri microcontrollori, con ottime caratteristiche di connessione dati fino alla velocità di 2Mbps in banda ISM (2,4 GHz). Esso consente di ricevere i dati dai nostri sensori e comandare i nostri attuatori, con un architettura di rete Punto-Punto oppure Punto-Multipunto. Il modulo RF è molto versatile e si presta nelle varie versioni disponibili per collegamenti dati da poche decine di metri ad alcune centinai di metri.


Test di integrazione con Display TFT, Modulo PSU e Bus 7090


Le librerie software per l'IDE Arduino sono ben fatte e documentate. L'integrazione di un microcontrollore con una rete di sensori/attuatori non risulterà difficile.

Ecco un semplice software di ricezione dati testato con l'IDE Arduino 1.8.19.

/*

READ THIS BEFORE USE:

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS”

AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,

INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;

OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/


////////////////////////////////////////////////////

// SYSTEM-24

// nRF24L01+ Receiver v.1.0 last update 07/03/2024 

// Periferal:

// nRF24L01+

////////////////////////////////////////////////////


#include <SPI.h>

#include <nRF24L01.h>

#include <RF24.h>


//objects

RF24 radio(7, 8); // CE, CSN       


//globals

const byte addressOfSlave [][6] = {"SLV01", "SLV02"};  //Setting the Slave TX Pipe Address

const byte addressOfMaster [][6] = {"MST01", "MST02"};  //Setting the Master RX Pipe Address

String nrf_message = ""; //message received fron NRF24L01

char rx_text[32]; //nRF24L01 rx buffer

int line_count = 0; //display line counter


//system setup

void setup() {

  Serial.begin(9600);


  //time to reset dispay TFT

  delay(5000);


  //nRF24L01+

  radio.begin();                    //start communication

  radio.setPALevel(RF24_PA_HIGH);   //set it as minimum or maximum depending on the distance between the transmitter and receiver.

  radio.setDataRate(RF24_250KBPS);  //minimum

  radio.openReadingPipe(1, addressOfMaster[0]); //Slave rx

  radio.startListening(); //This sets the module as receiver

  Serial.println("$Ready for listening!");

  delay(200);

  line_count++;


  //delete nRF input buffer

  if(radio.available()) {

    radio.read(&rx_text, sizeof(rx_text));    //read data

  }

} //setup


//application loop

void loop() {


  //check nRF24 radio

  if(radio.available()) {


    radio.read(&rx_text, sizeof(rx_text));    //reading data

    nrf_message = String(rx_text);

    Serial.print("$");

    Serial.println(nrf_message);

    line_count++;


    //manage the TFT text page

    if (line_count > 14) {

      Serial.print("$%CLEAR%\r\n");

      delay(500);

      line_count = 0;

    }

  }


} //loop


* - * - * - *

Il trasmettitore, invece utilizza questo codice per trasmettere i dati di alcuni sensori. (Abbinare correttamente ricevitore e trasmettitore per un funzionamento ottimale)

* - * - * - *


/*

READ THIS BEFORE USE:

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS”

AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,

INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;

OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/


/* SYSTEM-24 Package */ 

/* nRF24L01+ Remote Transmitter with DHT, LDR, 18B20 - v.1.5 last update 09/03/2024 */

/* Transmit format 0x:yyyy... */


#include <SPI.h>

#include <nRF24L01.h>

#include <RF24.h>

#include <Wire.h>

#include <DHT.h>

#include <OneWire.h>

#include <DallasTemperature.h>


#define DHTPIN 6        // Digital pin connected to the DHT sensor

#define DHTTYPE DHT11   // DHT 11

#define ONE_WIRE_BUS 4  //pin D4


// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)

OneWire oneWire(ONE_WIRE_BUS);


// Pass our oneWire reference to Dallas Temperature. 

DallasTemperature sensors(&oneWire);


RF24 radio(7, 8); // CE, CSN  (ex 9, 10)

DHT dht(DHTPIN, DHTTYPE);


const byte address [][6] = {"MST01", "SLV01"};  //Setting the two addresses. One for transmitting and one for receiving

char pck_signal[32];

int led_pin = 3;

char str[4];


void setup() {


  //ldr

  pinMode(5, OUTPUT); //ldr power

  digitalWrite(5,HIGH); //power on LDR


  //serial

  Serial.begin(9600);


  //radio

  radio.begin();

  radio.openWritingPipe(address[0]); //Setting the address where we will send the data

  radio.openReadingPipe(1, address[1]); //Setting the address where we will receive the data

  radio.setPALevel(RF24_PA_HIGH);       //You can set this as minimum or maximum depending on the distance between the transmitter and receiver.

  radio.setDataRate(RF24_250KBPS); //minimum


  //DHT

  dht.begin();

  digitalWrite(5,HIGH); //power on LDR

  Serial.println("Remote DHT, LDR, 18B20");


  //DS18B20

  sensors.begin(); // IC Default 9 bit  

}


void loop() {


  String temp = "";

  float t;

  float h;

    

  // DHT11 - Read temperature as Celsius (the default)

  t = dht.readTemperature();

  temp = "00"; //node '0'

  temp.concat(":");

  temp.concat(String(t,1));

  temp.toCharArray(pck_signal,temp.length());


  //DHT11 - Read humidity

  h = dht.readHumidity();

  temp.concat(",");

  temp.concat(String(h,1));

  temp.toCharArray(pck_signal,temp.length());


  //LDR

  temp.concat(",");

  sprintf(str, "%04d", 1023 - analogRead(A7));

  temp.concat(str);

  temp.toCharArray(pck_signal,temp.length());

  

  //DS18B20

  sensors.requestTemperatures(); // Send the command to get temperatures

  temp.concat(",");

  temp.concat(String(sensors.getTempCByIndex(0),1)); //Index 0

  temp.concat(0x00); 

  temp.toCharArray(pck_signal,temp.length());


  //transmit packet

  Serial.println(pck_signal);

  radio.write(&pck_signal, sizeof(pck_signal));

  

  //loop every second

  delay(1000);


} //loop

Buon lavoro di interconnessione dati. A presto.


Standard 7090: Esperimenti con ESP8266 - Parte 1

Come visto nei precedenti post, in questo blog stiamo proponendo una serie di schede prototipali in formato 70x90, con varie architetture a microcontrollore. Standard 7090 è un formato proprietario utilizzato per l'interconnessione di blocchi funzionali altrimenti non compatibili tra loro sia meccanicamente sia elettricamente.


Scheda 70x90 con modulo ESP8266 e nRF24L01 + PA/LNA

In questo esperimento abbiamo interconnesso un modulo ESP8266 con il display TFT 320x240, basato su Arduino R3 ed il modulo alimentatore PSU. 

ESP8266 nei test di integrazione in laboratorio

Da un punto di vista elettrico la scheda ESP8266 si connette al bus 5V - GND (Vin del modulo 8266), mentre il modulo nRF24L01 si connette al bus 3V3 - GND. L'uscita seriale (TX1 - Pin D4) è alla tensione 3,3 Volt e può essere compatibile con l'ingresso RX del display. La velocità è impostata su 9600 bps, per un semplice monitor di funzionamento.

Ecco un frammento di codice per i primi test, compilato con l'IDE Arduino 1.8 e successive versioni. La particolarità di questo codice è che utilizza sia la porta seriale di default su USB e sia la metà della porta seriale 1, disponibile solo in TX. Notare che per la Serial 1 vengono inviate le sequenze di controllo del Display TFT.


/*

READ THIS BEFORE USE:

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS”

AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,

INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;

OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/


/*

  ESP8266 NodeMCU - HelloTFT

  Tx Data on Serial1 (UART1 TX pin D4) 9600, n, 8, 1

  ver.1.0 last update 06/03/2024

*/


void setup() {


  Serial.begin(9600);

  Serial1.begin(9600);


  delay(5000); //leave time to TFT Init

  Serial.println("I'm ESP8266");

  Serial.println("Transmitting on D4 TX1");


  Serial1.print("$%CLEAR%\r\n"); //Reset display

  delay(500);

  Serial1.print("$Hello TFT\r\n");

  delay(200);

  Serial1.print("$I'm ESP8266.\r\n");

  delay(200);

  Serial1.print("$%GREEN%\r\n");

  delay(200);

  Serial1.print("$See You soon!\r\n");

  delay(200);

  Serial1.print("$%CYAN%\r\n");

  delay(200);

  Serial1.print("$This is a simple sketch.\r\n");

  delay(200);

  Serial1.print("$%LARGE%\r\n");

  delay(200);

  Serial1.print("$Bye\r\n");

  delay(200);


}


void loop() {

  Serial.print("ESP8266 is running\r\n");

  delay(1000);

}


Buona sperimentazione e a presto.


venerdì 1 marzo 2024

Standard 7090: Nano 33 BLE - Parte 1

In questo post descriverò una nuova scheda prototipale basata sullo Standard 7090 che su questo blog stiamo implementando per facilitare il riutilizzo di blocchi funzionali.

La scheda in questione utilizza un famoso modulo a microcontrollore della serie Arduino Nano. In particolare si tratta del modulo Nano 33 BLE Sense.

Pinout Nano 33 BLE Sense - Fonte arduino.cc

Basato sul microcontrollore ARM Cortex M4 con FPU, sottosistema RF BLE e clock 64MHz, prodotto dalla NORDIC Semiconductor con la sigla nRF52840, questo modulo rappresenta un vero e proprio gioiellino.

Infatti, al suo interno, ospita non solo un potente Core, ma una moltitudine di sensori che ne ampliano notevolmente il campo di applicazione. Tra questi notiamo un LSM9DS1 (Accelerometro, Giroscopio e Magnetometro Triassiali), un sensore di Temperatura, Umidità e Pressione, un microfono MEMS, un sensore di colori e luminosità. Il tutto nel formato Arduino Nano con tensioni di I/O a 3,3 Volt (Attenzione non è compatibile con segnali a 5,0 Volt).


Scheda 7090 Nano 33 BLE Sense + GPS + microSD

Come visibile dalla foto, sulla scheda è presente anche un ricevitore GPS basato sul Modulo uBlox Serie 7 e uno slot microSD.

* - * - * - *

Nella nostra prima applicazione utilizzeremo solo la porta UART 1 (Serial1) per comunicare con il Display TFT 320x240 precedentemente presentato su questo blog.

Assieme Standard 7090 con PSU, Display e Scheda BLE Sense

Il codice di test per dialogare con il display è il seguente:


/*

READ THIS BEFORE USE:

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS”

AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,

INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;

OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/


/*

  Nano 33 BLE Sense - Hello TFT

  Tx  Data on Serial1 (UART pin) 9600, n, 8, 1

  ver.1.0 last update 28/02/2024

*/


//Setup

void setup() {

  //debug only

  //Serial.begin(9600);

  //while(!Serial);

  //Serial.print("Nano BLE Sense ready. Tx=Serial1");


  Serial1.begin(9600); //UART 1 Tx --> Display Rx


  delay(5000); //leave time to TFT Init

  Serial1.print("$%CLEAR%\r\n"); //Reset display

  delay(500);

  Serial1.print("$Hello TFT\r\n");

  delay(200);

  Serial1.print("$I'm Nano 33 BLE Sense.\r\n");

  delay(200);

  Serial1.print("$%GREEN%\r\n");

  delay(200);

  Serial1.print("$Many sensors to test!\r\n");

  delay(200);

  Serial1.print("$%CYAN%\r\n");

  delay(200);

  Serial1.print("$This is a simple sketch.\r\n");

  delay(200);

  Serial1.print("$%LARGE%\r\n");

  delay(200);

  Serial1.print("$Bye\r\n");

  delay(200);

  Serial1.print("$%SMALL%\r\n");

  delay(200);

  Serial1.print("$%YELLOW%\r\n");

  delay(200);

  Serial1.print("$See You soon :)\r\n");

  delay(200); 

} //setup


// Main loop

void loop() {

  //do nothing    

} //loop


Buon divertimento e a presto.


martedì 27 febbraio 2024

Standard 7090: Display TFT 320x240

Come abbiamo visto nei precedenti post, stiamo adottando uno standard proprietario per il riutilizzo di moduli e blocchi funzionali per il nostro laboratorio.

Oggi aggiungiamo un Display grafico a colori da 2,8 pollici, montato su una scheda millefori 70x90 che ha anche funzione di backplane ovvero ci fornirà le connessioni per il Bus 7090.

Il display prescelto è un componente compatibile con lo standard Arduino R3 e verrà ospitato proprio da una scheda Arduino UNO R3. Entrambi i componenti vengono forniti da Elegoo e sono facilmente reperibili in commercio e completi di librerie firmware scaricabili o fornite a corredo su CDROM.

Poiché la scheda Elegoo Arduino UNO R3 compatibile provvederà a gestire tutti i segnali del bus parallelo del display, basato su controller ILI9341, non resteranno altri pin se non RX e TX da assegnare al programma di bordo.

In questa applicazione useremo l'assieme come Monitor "intelligente" con un semplice protocollo seriale per configurare il monitor (...qualcosa che ricorda un po' gli home computer anni '80 su cui ho iniziato a programmare).


Display TFT 320x240

Bene, il display funziona e ha caratteristiche piuttosto interessanti se pensiamo che viene pilotato da un microcontrollore a 8 bit quale l'ATMEGA328 con risorse piuttosto limitate.
Adesso vediamo il codice C++

/*


READ THIS BEFORE USE:

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS”

AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,

INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;

OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


*/


//TFT_Terminal for SYSTEM-24

//v.1.0 last update 26/02/2024

//Use Arduino UNO R3, Elegoo shield 2.8 inch, Serial port

//String format = "$ABCDEF\r\n"


#include <Elegoo_GFX.h>    // Core graphics library

#include <Elegoo_TFTLCD.h> // Hardware-specific library


// The control pins for the LCD can be assigned to any digital or

// analog pins...but we'll use the analog pins as this allows us to

// double up the pins with the touch screen (see the TFT paint example).

#define LCD_CS A3 // Chip Select goes to Analog 3

#define LCD_CD A2 // Command/Data goes to Analog 2

#define LCD_WR A1 // LCD Write goes to Analog 1

#define LCD_RD A0 // LCD Read goes to Analog 0


#define LCD_RESET A4 // Can alternately just connect to Arduino's reset pin


// Assign human-readable names to some common 16-bit color values:

#define BLACK   0x0000

#define BLUE    0x001F

#define RED     0xF800

#define GREEN   0x07E0

#define CYAN    0x07FF

#define MAGENTA 0xF81F

#define YELLOW  0xFFE0

#define WHITE   0xFFFF


Elegoo_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);

String message = ""; //message received from UART


void setup(void) {

  

  Serial.begin(9600);

  Serial.println(F("TFT Terminal for System-24"));

  Serial.print("TFT size is ");

  Serial.print(tft.height());

  Serial.print("x");

  Serial.println(tft.width());


  tft.reset();


   uint16_t identifier = tft.readID();

   if(identifier == 0x9325) {

    Serial.println(F("Found ILI9325 LCD driver"));

  } else if(identifier == 0x9328) {

    Serial.println(F("Found ILI9328 LCD driver"));

  } else if(identifier == 0x4535) {

    Serial.println(F("Found LGDP4535 LCD driver"));

  }else if(identifier == 0x7575) {

    Serial.println(F("Found HX8347G LCD driver"));

  } else if(identifier == 0x9341) {

    Serial.println(F("Found ILI9341 LCD driver"));

  } else if(identifier == 0x8357) {

    Serial.println(F("Found HX8357D LCD driver"));

  } else if(identifier==0x0101)

  {     

      identifier=0x9341;

      Serial.println(F("Found 0x9341 LCD driver"));

  }

  else if(identifier==0x1111)

  {     

      identifier=0x9328;

      Serial.println(F("Found 0x9328 LCD driver"));

  }

  else {

    Serial.print(F("Unknown LCD driver chip: "));

    Serial.println(identifier, HEX);

    Serial.println(F("If using the Elegoo 2.8\" TFT Arduino shield, the line:"));

    Serial.println(F("  #define USE_Elegoo_SHIELD_PINOUT"));

    Serial.println(F("should appear in the library header (Elegoo_TFT.h)."));

    Serial.println(F("If using the breakout board, it should NOT be #defined!"));

    Serial.println(F("Also if using the breakout, double-check that all wiring"));

    Serial.println(F("matches the tutorial."));

    identifier=0x9328;

  

  }


  tft.begin(identifier);

  tft.setRotation(1); //0,2=vertical 1,3=Horizontal

  tft.setTextColor(RED, BLACK);

  tft.setTextSize(3); //17 char per line

  tft.fillScreen(BLACK);

  tft.println();

  tft.println("    SYSTEM-24    ");

  delay(3000);


  tft.setTextColor(WHITE, BLACK);

  tft.setTextSize(2); //26 char per line

  tft.fillScreen(BLACK);

  tft.setCursor(0, 0);


}


void loop(void) {


  rx_message(); //blocking call


  if(message.startsWith("%CLEAR%")) { 

    Serial.println("Clear display"); //debug

    tft.fillScreen(BLACK);

    tft.setCursor(0, 0);

  } else if(message.startsWith("%HOME%")) {

    Serial.println("Home display"); //debug

    tft.setCursor(0, 0);

  } else if(message.startsWith("%BLACK%")) {

    tft.setTextColor(BLACK, 0);

  } else if(message.startsWith("%BLUE%")) {

    tft.setTextColor(BLUE, 0);

  } else if(message.startsWith("%RED%")) {

    tft.setTextColor(RED, 0);

  } else if(message.startsWith("%GREEN%")) {

    tft.setTextColor(GREEN, 0);

  } else if(message.startsWith("%CYAN%")) {

    tft.setTextColor(CYAN, 0);

  } else if(message.startsWith("%MAGENTA%")) {

    tft.setTextColor(MAGENTA, 0);

  } else if(message.startsWith("%YELLOW%")) {

    tft.setTextColor(YELLOW, 0);

  } else if(message.startsWith("%WHITE%")) {

    tft.setTextColor(WHITE, 0);

  } else if(message.startsWith("%SMALL%")) {

    tft.setTextSize(1);

  } else if(message.startsWith("%MEDIUM%")) {

    tft.setTextSize(2);

  } else if(message.startsWith("%LARGE%")) {

    tft.setTextSize(3);

  } else {

    tft.print(message); //debug

  }

    

}


//read serial port

void rx_message(void) {


  int rx_state = 0;

  char c = 0;

 

  // Read formatted message

  while (rx_state <2) {

    switch (rx_state) {

      case 0:

        //whait sync

        if (Serial.available()) {

          c = Serial.read(); //serial read

          if (c == '$') rx_state = 1;

          message = "";

        }

      break;


      case 1:

       //read message

        if (Serial.available()) {

          c = Serial.read();

          message += c;

          if (c == '\n') rx_state = 2;

        }

      break;

    }

  }

  

  return;

}


Nota: per utilizzare il codice copiarlo in uno progetto Arduino IDE, scaricare le librerie incluse e compilare. Il firmware è stato testato con IDE 1.8.19 o successiva.

Sostanzialmente si tratta di un ricevitore su porta seriale di stringhe formattate ($ABCD\r\n) che verranno depurate dai caratteri di sincronismo ("$", "\r") e visualizzate sullo schermo.

Facciamo un esempio:

    $Test message<CR><LF>

Visualizzerà con font di default la scritta "Test message".

Per cambiare font è possibile inviare delle stringhe di controllo.

    $%SMALL%<CR><LF>

Selezionerà il font più piccolo disponibile

Per cambiare il colore delle scritte, usare invece

    $%GREEN%<CR><LF>

Ora tutte le prossime stringhe appariranno di colore verde.

I font disponibili sono tre: SMALL, MEDIUM, LARGE.

I colori disponibili sono otto. Da nero a bianco (vedere codice c++).

Completano le istruzioni due comandi per ripulire il display e per resettare il cursore:

    $%CLEAR%<CR><LF>

    $%HOME%<CR><LF>

CLEAR cancella lo schermo e riporta il cursore su 0,0, mentre HOME resetta solo il cursore senza cancellare il contenuto del monitor.

* - * - * - *

Così anche questo modulo è pronto e potremo riutilizzarlo in molteplici occasioni per visualizzare i risultati dei nostri esperimenti con lo Standard 7090 che saranno presentati un futuro su questo blog.

Un anticipazione?

Si! Realizzeremo un sistema modulare multi-cpu. In particolare popoleremo le nostre schede 7090 con Arduino Nano, Arduino Nano 33 IoT, Arduino Nano 33 BLE Sense, STM32F103, ESP8266, ESP32, Raspberry PI Zero W, Onion Omega-2, e forse anche altre CPU.

Aggiungeremo anche molti sensori ed attuatori, ma restate connessi per non perdevi nulla.


...piccola anticipazione...


Buona sperimentazione e a presto :)



domenica 25 febbraio 2024

Standard 7090: Alimentatore 5 Volt e 3.3 Volt

Come descritto nel precedente post, per realizzare dei moduli riutilizzabili è opportuno adottare uno standard personale o ufficialmente riconosciuto da enti normatori o dal mercato.
In questo post Vi presento la soluzione che ho adottato, per creare un alimentatore Switch Mode semplice ed economico, realizzato per moduli (Schema a blocchi in Fig. 1), che utilizzerò per tutte le successive sperimentazioni o prototipi.

Come visibile dalla foto in Figura 2, ho utilizzato dei moduli commerciali, installati su una scheda prototipale 70x90. In particolare la tensione di ingresso afferisce ad un modulo MB102 che provvede a distribuirla ad un voltmetro digitale a tre cifre e a due moduli LM2596, regolati con precisione alle rispettive tensioni di 5,0 Volt e 3,3 Volt. Una volta effettuata la taratura il nostro alimentatore sarà pronto per alimentare gran parte delle schede a microcontrollore che successivamente verranno presentate su questo Blog. Le tensioni di uscita saranno quindi disponibili sui Pin descritti in Figura 3

Buona sperimentazione e a presto.

venerdì 23 febbraio 2024

Alla ricerca di uno Standard (?)

Noi progettisti di una certa epoca eravamo soliti riferirci ai bus standard DIN41612, IEC297 ed altri, ma oggi il mondo elettronico è particolarmente dinamico. Alcuni standard tuttavia emergono nell'ambito della prototipazione rapida: Arduino, ESP8266, ESP32, STM32, Raspberry PI, ecc. Tutti con formati differenti e spesso scarsamente compatibili tra loro, sia nella disposizione dei Pin sia come livelli elettrici dei segnali.


Cortesia Schroff nVent


Se non volete ogni volta ricominciare da zero i vostri progetti e, magari, lavorare per blocchi funzionali, allora adottate uno standard e progettate per moduli sia hardware sia firmware.

Un aspetto fondamentale nella prototipazione rapida è la possibilità di reperire componenti hardware in tempi brevi e a costi accettabili, pertanto bisogna adattarsi all'offerta più facilmente reperibile.

Per trarre profitto dagli innumerevoli esperimenti che si effettuano per scopi professionali o per semplice hobby, ho deciso di adottare alcuni standard personali, al solo scopo di poter riutilizzare i moduli sviluppati nel mio lavoro. In tal caso preferisco adottare uno standard 7090 con schede millefori a singola o doppia faccia.

Su questo tipo di scheda è possibile montare un ampia varietà di moduli, tra cui Arduino R3, Arduino Nano, ESP8266, ESP32, STM32F103, Raspberry PI Zero, ecc.

Per garantire una semplice modularità e quindi interscambiabilità tra i blocchi funzionali, ho provveduto a definire una serie di segnali preferenziali da assegnare ad uno dei due lati di connessione, definendo una tabella di base. Per ciascun progetto sarà necessario compilare il nome della scheda è il campo note:

Pinout preferenziele del Bus

Nei prossimi post Vi presenterò in modo dettagliato alcune applicazioni pratiche, corredate da schemi elettrici, firmware di test e note di montaggio.

Le applicazioni sono praticamente ...infinite :)

Buon lavoro e a presto.


Leopardi in "L'infinito": così tra questa immensità s'annega il mio pensiero.