STM8S : Premier Contact

 

STM8S : Premier Contact

 

Aujourd'hui nous allons essayer de programmer un petit microcontrôleur 8 bits : le STM8S de chez ST Microelectronics.

Pour cela j'ai investi dans une petite carte équipée d'un STM8S105K4T6 :

• fréquence d'horloge : 16MHz
• mémoire FLASH : 16 Kbytes
• mémoire RAM : 2 Kbytes
• mémoire EEPROM : 1 Kbyte
• communication : UART, I2C, SPI
• ADC : 10 bits 
• 30 broches, mais plus large qu'une carte ARDUINO NANO
  

Pour de petits projets d'autres cartes existent :

STM8S103F3P6

• fréquence d'horloge : 16MHz
• mémoire FLASH : 8 Kbytes
• mémoire RAM : 1 Kbyte
• mémoire EEPROM : 640 bytes
• communication : UART, I2C, SPI
• ADC : 10 bits 
• 20 broches, même largeur qu'une carte ARDUINO PRO MINI, et plus courte
  

Il est à noter que ces cartes sont moins chères qu'une carte ARDUINO PRO MINI, spécialement la STM8S103K3T6 : 0.68€.

La quantité de mémoire FLASH est moins importante que sur un ATMEGA328P (32 Kbytes), ce qui n'est pas un handicap pour la majeure partie des projets.

La carte officielle ST (STM8S Discovery) à base de STM8S105C6T6 a une quantité de FLASH de 32Kbytes, comme un ARDUINO, mais son prix est largement supérieur.

Ces cartes peuvent être alimentées entre 2.95V et 5.5V.

Elles possèdent un port µUSB mais apparemment ce connecteur ne peut servir qu'à l'alimentation de la carte. Il faudra donc ajouter un convertisseur USB / série pour bénéficier du terminal (moniteur série), comme sur une carte ARDUINO PRO MINI.

Les cartes STM8S ont une consommation de 10µA en veille. Il existe une série STM8L, ayant des performances plus intéressantes : 0.35 µA en veille ! Je n'ai pas connaissance de cartes STM8L accessibles au grand public. Cela viendra.

1. Le matériel

Pour programmer un STM8S, il est indispensable de se procurer un programmateur STLINK-V2, que l'on trouve pour moins de 2€ sur AliExpress :

4 fils suffisent pour programmer la carte :

• 3.3V
• GND
• RST
• SWIM

Ces 4 broches sont situées en bout de carte.

2. L'IDE ARDUINO

Nous allons utiliser une librairie core nommée SDUINO :

https://tenbaht.github.io/sduino/

Comme dit sur la page d’accueil, il faut d'abord ajouter la ligne suivante à notre liste de cartes supplémentaires :

https://github.com/tenbaht/sduino/raw/master/package_sduino_stm8_index.json

Pour cela il faut ouvrir la boîte de dialogue préférences : menu "Fichier / Préférences", et ajouter l'URL à la ligne "URL Gestionnaire de cartes supplémentaires". Si cette ligne n'est pas vide, utiliser une virgule comme séparateur :

https://dl.espressif.com/dl/package_esp32_index.json,http://arduino.esp8266.com/stable/package_esp8266com_index.json,https://downloads.arduino.cc/packages/package_avr_3.6.0_index.json,https://github.com/tenbaht/sduino/raw/master/package_sduino_stm8_index.json

Ensuite, ouvrir le gestionnaire de cartes : menu "Outils / Type de carte / Gestionnaire de cartes.

Rechercher sduino, choisir une version, et cliquer sur installer.

Personnellement j'ai installé la version 0.4.0 

Les cartes supportées sont les suivantes :

STM8S103F3P6

STM8S Discovery (la carte officielle ST)

STM8S105K4T6

SDUINO UNO

La librairie STM32DUINO possède elle aussi un support STM8, mais uniquement pour les cartes STM8 officielles :

STM8S208RB Nucleo

Le format de ces cartes (UNO) me parait inadapté à la réalisation de projets de dimensions raisonnables.

3. Premier sketch

Après avoir chargé le sketch exemple Blink (menu Fichier / Exemples / 01.Basics / Blink), il suffit de cliquer sur l'icône téléverser :

Le croquis utilise 2622 octets (16%) de l'espace de stockage de programmes. Le maximum est de 16384 octets.
Les variables globales utilisent 70 octets (3%) de mémoire dynamique, ce qui laisse 1978 octets pour les variables locales. Le maximum est de 2048 octets.
/home/riton/.arduino15/packages/sduino/tools/STM8Tools/2018.12.07/linux/stm8flash -cstlinkv2 -pstm8s105?4 -s flash -w /tmp/arduino_build_582971/Blink.ino.hex
Determine FLASH area
Due to its file extension (or lack thereof), "/tmp/arduino_build_582971/Blink.ino.hex" is considered as INTEL HEX format!
2757 bytes at 0x8000... OK
Bytes written: 2757

La LED bleue de la carte clignote.

On peut modifier les temps pour accélérer le clignotement :

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(100);                       // wait for 100ms
  digitalWrite(LED_BUILTIN, LOW);    // turn the LED off by making the voltage LOW
  delay(100);                       // wait for 100ms
}

4. Débloquer la FLASH

Vu sa taille réduite la petite carte bleue STM8S103F3P6 est celle qui m'intéresse le plus. Par contre elle refuse toute programmation et l'IDE affiche un message "Tries exceeded". Après quelques recherches, j'ai trouvé ceci : il faut débloquer la mémoire FLASH.

Télécharger ce petit fichier :

https://github.com/vdudouyt/stm8flash/files/372158/optdefault.bin.txt

Ensuite il faut le charger sur la carte avec stm8flash.

Les chemins cités ci-après peuvent changer en fonction des versions, en particulier la date 2018.12.07.

4.1. Sous Linux

Retirer l'extension .txt et le déplacer dans le répertoire .arduino15/packages/sduino/tools/STM8Tools/2018.12.07/linux, où se trouve l'utilitaire stm8flash.

Ensuite entrer les commandes suivantes dans un terminal :

cd .arduino15/packages/sduino/tools/STM8Tools/2018.12.07/linux
./stm8flash -c stlinkv2 -p stm8s103f3 -s opt -w optdefault.bin

4.2. Sous Windows

Sous Windows ce répertoire sera situé ici :

C:\Users\username\AppData\Local\Arduino15

Retirer l'extension .txt et le déplacer dans le répertoire C:\Users\username\AppData\Local\Arduino15\packages\sduino\tools\STM8Tools\2018.12.07\win, où se trouve l'utilitaire stm8flash.exe

Comme les utilisateurs Windows ont peu l'habitude de la ligne de commande, pour ouvrir un terminal sous Windows, cliquer sur le menu Démarrer et choisissez “Exécuter”. Tapez ensuite le texte cmd :

Ensuite entrer les commandes suivantes dans un terminal :

cd C:\Users\username\AppData\Local\Arduino15\packages\sduino\tools\STM8Tools\2018.12.07\win
stm8flash -c stlinkv2 -p stm8s103f3 -s opt -w optdefault.bin

4.3. Sur Mac

Sur Mac : 

Sur Mac ce répertoire sera situé ici :

/Users/username/Library/Arduino15

Le mode opératoire ressemble à celui de Linux.

4.4. Le résultat

Determine OPT area
Due to its file extension (or lack thereof), "optdefault.bin" is considered as RAW BINARY format!
64 bytes at 0x4800... OK
Bytes written: 64

Ensuite le sketch Blink se téléverse sans problème.

5. Librairies

Un certain nombre de librairies sont livrées avec le package SDUINO :

• EEPROM
• I2C
• LCD_BTHQ21605V
• LiquidCrystal
• LiquidCrystal_I2C
• LiquidCrystal_pcf2119
• Mini_SSD1306
• PCD8544
• Servo
• Stepper
• Wire

6. Conclusion

Voici de petits microcontrôleurs bien sympathiques au premier abord. Bien entendu ce n'est qu'un premier contact, il va falloir leur consacrer un peu de temps pour explorer plus en profondeur.

Cordialement

Henri

Audio : Amplificateur mono TAS5630 classe D 150W

 

Audio : Amplificateur mono TAS5630

classe D 150W

 

Dans un article précédent j'ai décrit la réalisation d'un amplificateur classe D 2.1 à base de circuit TPA3116. J'y évoque également le remplacement futur de la carte ampli 2.1 TPA3116 par un filtre actif Linkwitz-Riley à 24dB / octave, suivi de deux amplificateurs, un STA508 stéréo, et un TAS5630 mono, pour une réalisation plus haut de gamme.

Voici le deuxième ampli : le TAS5630 mono.

1. L'amplificateur TAS5630

Le TAS5630 est un circuit avec lequel on peut réaliser différents amplificateurs de très bonne qualité :

• 4 voies (4x30W)
  
• stéréo (2x125W)
• stéréo + voie grave 2.1 (2x75W + 150W)
  
• mono en pont (150W)

Ces puissances sont celles obtenues avec une charge de 8Ω. Avec une charge de 4Ω elles seront doublées.

L'amplificateur que je compte fabriquer est destiné à alimenter un caisson de basses unique. il sera donc monophonique.

La carte provient de chez AliExpress Shop910726154 Store.

Cette carte est équipée d'un étage de pré-amplification réalisée à l'aide d'un amplificateur opérationnel très performant, l'OPA1632.

1.1. Attention

Certaines de ces cartes, comme celle-ci, spécialement prévues pour alimenter un caisson de basses, sont filtrées à 60Hz et ne conviendront pas à tous les usages. La carte est équipée d'un connecteur d'entrée stéréo. Elle conviendra pour la réalisation d'un caisson de basses dont l'entrée sera branchée en parallèle sur l'entrée d'un ampli stéréo, afin de renforcer les graves d'un paire d'enceintes un peu faibles en dessous de 60Hz.
Le vendeur donne cependant le choix entre deux versions : filtrée à 60Hz ou full-range. En version full-range il faudra un filtre actif en amont.

Mon projet étant basé sur un filtre actif ayant une fréquence de coupure située aux alentours de 80Hz, il me faut donc une carte sans filtrage.

2. La mise en boîte

J'ai choisi un boîtier HIFI 2000 Galaxy GX288, aux dimensions de 80x230x280mm, disponible ici : audiophonics.fr

2.1. L'alimentation

Il s'agit d'une alimentation à découpage 48V 200W achetée chez TME.

MeanWell RSP-200-48

 

On peut alimenter la carte amplificateur avec une tension allant de 25V jusqu'à 52V. Une tension de 48V permettra d'atteindre une puissance de 150W sur 8Ω.

2.2. Les borniers

Ceux-ci sont les mêmes que ceux utilisés sur l'amplificateur 2.1.

L'entrée mono sur la carte nécessite d'approvisionner un connecteur JST XH 2 points (pas de 2.56mm), mais on peut aussi dessouder le connecteur femelle et le remplacer, ou souder directement les fils sous la carte.

Le connecteur d'alimentation et la sortie haut-parleur sont des JST VH 2 broches (pas de 3.96mm).

La tension secteur est amenée à l'alimentation à l'aide d'une embase IEC sans filtre anti-parasites, car l'alimentation possède déjà le sien.

Un porte fusible est également nécessaire, ainsi qu'un interrupteur marche / arrêt et une LED.

2.3. La carte anti ploc

Le bruit à la mise sous tension et à la coupure est faible, la carte anti-ploc n'est pas urgente. Elle sera développée plus tard, avec seulement 1 canal, donc un seul relais.

2.4. Le prix

Cet amplificateur revient à environ 120€.

3. Le montage

L'article décrivant l'amplificateur stéréo LM3886 2x40W peut aider à la réalisation de ce modèle :

Amplificateur stéréo LM3886

4. Photos

Voici quelques photos de la réalisation :

Face avant

 

La LED est reliée à l'alimentation 48V à travers une résistance de 10KΩ. Elle se trouve dans la gaine thermorétractable, comme sur l'ampli 2.1 :

Interrupteur et LED

 

Vue de dessus

Face arrière

5. Téléchargements

Le projet de carte anti-ploc n'est pas essentiel pour l'instant, il sera disponible dans quelques mois.

6. Sécurité

Il faut être prudent lorsque l'on manipule un montage alimenté par le secteur, et toute intervention doit être faite cordon secteur débranché.

7. Conclusion

Cet amplificateur pour caisson de basses fonctionne parfaitement. Je ne peux en dire plus pour l'instant, car son écoute sur le caisson de basses devra attendre, ma solution de filtrage actif étant en cours d'étude.

Cordialement

Henri

TCA9548A : multiplexer le bus I2C

 

TCA9548A : multiplexer le bus I2C

 

Comme vous le savez probablement le bus I2C permet de dialoguer avec des composants à l'aide de seulement deux fils et on peut théoriquement en brancher un bon nombre :

Sur ce schéma que j'ai déjà publié sur ce blog je compare 7 capteurs météo. Le composant avec lequel on désire dialoguer est sélectionné par le logiciel.

Les composants I2C possèdent souvent une ou plusieurs broches de sélection d'adresse. Par exemple le capteur de température et humidité HDC2080 possède une broche ADD que l'on peut relier au 3.3V pour changer son adresse I2C (0x41 au lieu de 0x40 si elle est reliée à GND).

Mais certains composants ne disposent que d'une seule adresse (HTU21D, SI7021, afficheurs OLED I2C, etc.).

Le cas doit se produire plutôt rarement, mais que faire lorsque l'on est dans l'obligation d'utiliser deux composants I2C ayant la même adresse ?

Un autre cas peut se produire : certains composants mal conçus cohabitent  difficilement avec d'autres sur le bus.

Le TCA9548 permet de multiplexer 8 bus I2C. Il a les caractéristiques suivantes :

• 8 bus esclaves
• alimentation 1.65V - 5.5V
• 3 broches de sélection d'adresse

C'est un circuit CMS 24 pins, mais il est facile de trouver des modules "breakboard" équipés de ce circuit (voir image ci-dessus).

1. Le schéma

Sur ce schéma le TCA9548 est alimenté sous 5V (une alimentation sous 3.3V serait parfaitement possible) et il contrôle deux modules I2C également alimentés sous 5V.

Les deux modules I2C sont branchés sur les ports I2C 2 et 3 du TCA9548.

Les broches d'adresse A0, A1 et A2 sont reliées à GND. L'adresse I2C du TCA9548 sera donc 0x70. D'autres choix sont possibles, entre 0x70 et 0x77.

2. La librairie

Il existe quelques librairies. Celle que je vais utiliser est la suivante :

https://github.com/sparkfun/SparkFun_I2C_Mux_Arduino_Library

Elle est installable depuis l'IDE ARDUINO.

3. Le code

3.1. Capteurs SHT31D

J'ai câblé un petit montage avec une carte ARDUINO NANO, le TCA9548 et 2 capteurs SHT31D A et B. L'alimentation des 3 modules est en 3.3V. Cela fonctionnerait de la même façon sous 5V, le SHT31D supportant de 2.4V à 5.5V. 

La librairie Adafruit_SHT31 est nécessaire (installable depuis l'IDE). 

Voici le code :

#include <Wire.h>
#include <SparkFun_I2C_Mux_Arduino_Library.h>
#include <Adafruit_SHT31.h>

QWIICMUX myMux;
Adafruit_SHT31 sht31A = Adafruit_SHT31();
Adafruit_SHT31 sht31B = Adafruit_SHT31();

void setup()
{
  Serial.begin(115200);
  Wire.begin();

  if (myMux.begin() == false) {
    Serial.println("Mux not detected. Freezing...");
    while (1);
  }
  Serial.println("Mux detected");

  byte currentPortNumber = myMux.getPort();
  Serial.print("CurrentPort: ");
  Serial.println(currentPortNumber);

   // initialisation SHT31 A
  myMux.setPort(2);
  if (!sht31A.begin(0x44)) {
    Serial.println("Couldn't find sensor A");
    while (1) delay(1);
  }
  // initialisation SHT31 B
  myMux.setPort(3);
  if (!sht31B.begin(0x44)) {
    Serial.println("Couldn't find sensor B");
    while (1) delay(1);
  }
}

void loop()
{
  myMux.setPort(2);
  float temp = sht31A.readTemperature();
  float hum = sht31A.readHumidity();
  Serial.print("SHT31 A temperature = ");
  Serial.print(temp);
  Serial.println(" *C");
  Serial.print("SHT31 A humidity = ");
  Serial.print(hum);
  Serial.println(" %\n");
  myMux.setPort(3);
  temp = sht31B.readTemperature();
  hum = sht31B.readHumidity();
  Serial.print("SHT31 B temperature = ");
  Serial.print(temp);
  Serial.println(" *C");
  Serial.print("SHT31 B humidity = ");
  Serial.print(hum);
  Serial.println(" %\n");
  delay(10000);
}

Mon doigt est posé sur le capteur A. Voici ce qu'affiche le sketch :

Mux detected
CurrentPort: 255
SHT31 A temperature = 30.34 *C
SHT31 A humidity = 69.97 %
 
SHT31 B temperature = 22.81 *C
SHT31 B humidity = 41.96 %

Les deux modules SHT31 A et B sont branchés sur les ports I2C 2 et 3 du TCA9548.

A chaque fois que l'on veut communiquer avec le module A il suffit d'appeler :

  myMux.setPort(2);

A chaque fois que l'on veut communiquer avec le module B il suffit d'appeler :

  myMux.setPort(3);

3.2. Afficheurs OLED

On peut aisément faire la même chose avec 2 petits afficheurs OLED SSD1306, pour afficher des informations sur l'un ou sur l'autre.

Ici encore l'alimentation du TCA9548 et des écrans est en 3.3V.

La librairie de Bill Greiman SSD1306Ascii est nécessaire (installable depuis l'IDE).

Voici le code :

#include <Wire.h>
#include <SparkFun_I2C_Mux_Arduino_Library.h>
#include "SSD1306Ascii.h"
#include "SSD1306AsciiAvrI2c.h"

QWIICMUX myMux;
SSD1306AsciiAvrI2c displayA;
SSD1306AsciiAvrI2c displayB;

void setup()
{
  Serial.begin(115200);
  Wire.begin();
  pinMode(13, OUTPUT);

  if (myMux.begin() == false) {
    Serial.println("Mux not detected. Freezing...");
    while (1);
  }
  Serial.println("Mux detected");

  byte currentPortNumber = myMux.getPort();
  Serial.print("CurrentPort: ");
  Serial.println(currentPortNumber);

  delay(2000); // nécessaire à la mise sous tension

  // initialisation OLED A
  myMux.setPort(2);
  Serial.println("initialisation OLED A");
  displayA.begin(&Adafruit128x32, 0x3C);
  displayA.setFont(System5x7);
  displayA.set1X();
  displayA.setCursor(0, 0);
  displayA.clearToEOL();
  displayA.print("INITIALIZED");
  // initialisation OLED B
  myMux.setPort(3);
  Serial.println("initialisation OLED B");
  displayB.begin(&Adafruit128x32, 0x3C);
  displayB.setFont(System5x7);
  displayB.set1X();
  displayB.setCursor(0, 0);
  displayB.clearToEOL();
  displayB.print("INITIALIZED");
  delay(500);
  displayA.set2X();
  displayB.set2X();
  digitalWrite(13, HIGH);
}

void loop()
{
  static int toggle = -1;

  myMux.setPort(2);
  displayA.setCursor(0, 0);
  displayA.clearToEOL();
  if (toggle != HIGH) {
    displayA.print("SCREEEN A");
  }
  myMux.setPort(3);
  displayB.setCursor(0, 0);
  displayB.clearToEOL();
  if (toggle != LOW) {
    displayB.print("SCREEEN B");
  }
  delay(1000);
  toggle = toggle == LOW ? HIGH : LOW;
}

Un délai d'au moins une seconde est nécessaire entre l'initialisation du TCA9548 et celle des écrans, si l'on met sous tension le montage. Lors d'un reset ce délai n'est pas utile. Je n'ai pas d'explication.

3.3. Adresse du TCA9548

A noter : si l'on désire utiliser une adresse alternative du TCA9548 il suffit de passer cette adresse à la méthode begin() :

  if (myMux.begin(0x71) == false) {
    Serial.println("Mux not detected. Freezing...");
    while (1);
  }

Dans ce cas (0x71) il faudra relier la broche A0 au +5V, ou 3.3V, suivant le cas.

4. Conclusion

Voici un petit composant bien pratique lorsque l'on est confronté à une situation de conflit sur un bus I2C.

Cordialement

Henri

Janvier 2021 : Actualité des Blogs du Mois

 

Actualité des Blogs du Mois

Sur le blog d'Yves Pelletier :

• Envoi d'un email par l'ESP32
  
• Communication Bluetooth entre micro:bit et smartphone
  
• Contrôler plusieurs servomoteurs avec le PCA9685
  
• Communication RF 433 MHz avec RadioHead (Arduino, ESP32, ESP8266)
• Mesurer la température avec le capteur interne du STM32
• Module GPS NEO 6MV2 et Raspberry Pi
  

Sur  Framboise 314 :

• Utiliser le Raspberry Pi PICO avec Thonny et MicroPython
  
• Raspberry Pi PICO la carte Microcontrôleur de la Fondation
  
• PyQt5 – Développez vos interfaces graphiques en Python
  
• Les imprimantes Creality en promotion
  
• Configurer un écran tactile Waveshare 4 pouces 800×480 pixel sur Raspberry Pi
  
• Installer Discord sur le Raspberry Pi
• Camera de surveillance intelligente Imilab EC2 – Chaîne Écologique Xiaomi
• Passer le routeur Xiaomi mi R4 sous OpenWrt 
  

Sur  MCHobby :

• Projet de Charge à courant constant controlé par Arduino
  
• Brancher un ILI9341 sur Raspberry-Pi Pico
  
• Raspberry-Pi Pico & MicroPython - La fondation lance son microcontroleur double coeur
  
• Et bien d'autres articles ...
  

Sur Papsoid :

• Aquapi: nouvelle carte
• Aquapi Monitoring DIY aquarium: boîtier 3D - partie 05 
  

Sur ArduiBlog

• Prusa i3 MK3S
  
• Bientôt une mise à jour de mon livre sur l’Arduino
• Octoprint sur Rasperry Pi Zero W 
  

 

Cordialement
Henri