Fer à Souder : recommandations

 

Fer à Souder : recommandations

 

Pour ceux qui désirent réaliser des projets aboutis et finalisés, un fer à souder est un outil indispensable. Il est utilisé pour différents usages :

• assemblage de cartes électroniques
• cosses à souder
• bornes
• étamage de fils
  
• etc.
  

Tout d'abord, en matière d'électronique, on ne soude pas, on brase, car l’assemblage est fait à l’aide de métal d’apport de nature différente des pièces  assemblées, et le métal d’apport a une température de fusion inférieure aux pièces à assembler. Mais dans la vie courante de l'électronicien, on parle de soudure, donc nous allons adopter ce terme, même s'il est inexact.

1. Type de fer

Un fer à souder 230V comporte des risques pour les composants sensibles à l'électricité statique. Préférer les modèles avec prise 230V 2 pôles + terre.

Sinon, il est recommandé de relier la base de la panne à une prise de terre si l'on veut éviter les surprises. Le moyen de fixation à la base de la panne sera choisi en fonction des possibilités (soudure, pince crocodile, etc.). Le fil de terre pourra être fixé au câble secteur par du ruban adhésif pour ne pas trop handicaper le travail.

Pour souder des composants électroniques, il est préférable d'utiliser un fer d'environ 30 watts. Un fer de 50W à 80W sera nécessaire uniquement pour souder des cosses ou des bornes d'épaisseur importante.

Mieux : un fer de 50W à 80W à température réglable permettra d'adapter celle-ci au travail à effectuer.

Un support de fer est un accessoire indispensable si l'on veut éviter les accidents :

Certains sont équipés d'un accessoire de nettoyage de la panne.

Pour des travaux réguliers je recommande la station de soudage basse tension anti-ESD :

Weller WS51 80W

Celle-ci est relativement chère, mais on trouve d'excellents modèles à moins de 50€.

Il est préférable de choisir un modèle pour lequel on pourra trouver des pannes de rechange, car une panne s'use.

2. La panne

De préférence, choisir un modèle de fer avec au minimum une panne fine, ou un jeu de pannes interchangeables :

La pointe de celles-ci (pannes dites longue durée) est traitée anti-corrosion, ce qui est indispensable si l'on veut que la soudure adhère à la panne, et éviter les crises de nerfs.

3. Le fil de soudure

Pour les travaux courants, utiliser un fil de soudure 0.5mm. Le 0.25mm sera utile seulement si l'on désire assembler des cartes avec des composants de surface (CMS).

La soudure sans plomb est obligatoire dans l'industrie (directive RoHS), sauf pour du prototypage, car le plomb est toxique. Mais elle est difficile à utiliser pour un amateur, elle réclame une température plus élevée, et l'absence de plomb rend la soudure agressive pour la panne.

La soudure 60%/40% étain plomb (SnPb) vous évitera bien des désagréments.

La soudure à l'argent (62% Sn + 36% Pb + 2% Ag.) est un must :

https://www.gotronic.fr/art-soudure-a-l-argent-eso14-7440.htm

Pour des travaux de longue durée, un petit ventilateur permettra de ne pas respirer les fumées toxiques. Aérer la pièce si possible.

4. La température

En général il est préférable d'adopter une température élevée (350°) afin de réduire le temps de soudure. Une température basse allongera le temps de soudure, ce qui peut être néfaste pour certains composants sensibles.

La soudure de composants épais (cosses, bornes, etc.) se fera à température maximale.

5. Nettoyage

On ne nettoie pas une panne longue durée avec un objet abrasif (papier de verre, grattoir, etc.). Cela endommagerait la couche protectrice, de très faible épaisseur.

Avant soudure, nettoyer la panne chaude sur une petite éponge légèrement humide :

Ou mieux, une boule de paille de laiton :

Par contre, avant d'éteindre le fer, ne nettoyez pas la panne. La soudure présente sur la pointe la préservera et allongera sa durée de vie.

5. Soudure de composants traversants

On appelle composants traversants ceux dont les pattes sont glissées à travers les trous de la carte, et soudés par dessous.

Quand cela est nécessaire, on plie les pattes de composants à l'aide d'une pince à becs fins ou d'un gabarit de pliage :

Pour des raisons de facilité, on commence toujours par souder les composants de faible hauteur, souvent les résistances, en terminant par les gros composants, relais par exemple.

On peut s'aider d'un support pivotant :

Après insertion, on peut plier légèrement les pattes des composants qui le permettent (résistances, condensateurs), afin qu'ils ne tombent pas lorsque l'on retourne la carte pour effectuer les soudures :

Après soudure, couper les pattes au raz de la soudure à l'aide d'une pince coupante.

Dernière recommandation : on ne soude pas une résistance de puissance au ras de la carte. Prévoir un espace entre le corps de la résistance et la carte, afin qu'elle puisse dissiper la chaleur plus efficacement :

6. Soudure CMS

La soudure de composants de surface CMS est tout à fait à la portée de l'amateur. Je vous renvoie à cet article :

https://riton-duino.blogspot.com/2019/07/soudure-dun-microcontroleur-cms.html

7. Liens utiles

https://www.framboise314.fr/comment-bien-souder-un-tutoriel-sur-la-soudure

Cordialement

Henri

ARDUINO : le moniteur série

 

 ARDUINO : le moniteur série

 

Le moniteur série est un outil indispensable au développement d'un logiciel sur ARDUINO. Beaucoup de débutants ignorent même son existence, ce qui est bien dommage.

1. Mise en œuvre

On peut lancer cet outil à partir du menu "Outils / Moniteur série", après avoir branché une carte, en ayant choisi au préalable le port correspondant à la carte branchée, à l'aide du menu "Outils / port".

Voici un petit sketch qui affiche des informations simples :

void setup() {
  Serial.begin(115200);
  Serial.println("Test ARDUINO");
}

void loop() {
  for (int i = 0 ; i < 10 ; i++) {
    Serial.print("compteur : ");
    Serial.println(i);
    delay(1000);
  }
  delay(10000);
}

Ce sketch, si on le lance avec le moniteur série ouvert affichera les informations suivantes :

On voit tout de suite quel est l'intérêt d'un pareil outil, qui servira principalement à mettre au point son logiciel et vérifier que tout se passe bien.

On peut ainsi suivre le déroulement de l'exécution de son logiciel, afficher des variables, des textes, etc.

En bas de la fenêtre, un menu permet de sélectionner la vitesse de transmission, ici 115200 baud, conformément à ce qui est écrit dans le code :

  Serial.begin(115200);

Par pitié ne choisissez pas de vitesse inférieure, 9600 baud par exemple, comme on le voit beaucoup trop souvent. Cette vitesse appartient au passé.

L'autre menu permet de choisir le caractère de fin lorsque l'on entre une chaîne de caractères dans la zone de texte sous le titre (Aucun, NL, CR, les deux).

2. print() ou println()

Ces deux méthodes sont presque identiques, mis à part que println() affiche un caractère '\n', ou NEWLINE, à la fin de la ligne. Autrement dit le prochain affichage se fera sur la ligne suivante.

Ces deux méthodes acceptent un argument de type int, long, char, char [], float, etc.

Quelques petits détails :

Afficher un nombre flottant :

  float f = 123.456;
  Serial.println(f, 3);  // permet d'afficher 3 décimales (2 par défaut)

Afficher un nombre en hexadécimal :

  int x = 123;
  Serial.println(x, HEX);

3 autres options existent : OCT (octal), DEC (décimal), BIN (binaire).

3. Serial.printf() sur ESP8266 et ESP32

La méthode printf() de l'objet Serial n'est pas disponible sur les plateformes ARDUINO, mais elle est présente sur ESP8266 et ESP32.

  for (int i = 0 ; i < 10 ; i++) {

    Serial.print("compteur : ");

    Serial.println(i);

  }

Avec Serial.printf() ces deux lignes pourront être remplacées par une seule :

  for (int i = 0 ; i < 10 ; i++) {

    Serial.printf("compteur : %d\n", i);

  }

La chaîne "%d" est ce que l'on appelle une chaîne de formatage, et le programme va remplacer cette chaîne par la valeur de l'argument suivant, dans notre cas une variable entière nommée i.

printf() n'ajoute pas de caractère de fin de ligne. Il faut l'ajouter : \n

Différents formats sont possibles :

• %d : afficher un entier
• %l : afficher un entier long
• %u : afficher un entier non signé
• %lu : afficher un entier long non signé
• %c : afficher un caractère
• %s : afficher une chaîne de caractères

Afficher plusieurs variables est possible :

  for (int i = 0 ; i < 10 ; i++) {
    int j = i * 10;
    char s[] = "blabla";
    Serial.printf("compteurs : %s %d %d\n", s, i, j);
  }

Je vous renvoie à la documentation :

https://www.cplusplus.com/reference/cstdio/printf/

4. printf() sur ARDUINO

Pour ceux qui viennent du monde C standard, il existe éventuellement une possibilité d'utiliser printf() sur ARDUINO, et là je parle de la fonction C standard printf(), pas de la méthode Serial.printf().

printf() est disponible sur ARDUINO, mais elle n'affiche rien sur la sortie standard, car celle-ci n'est pas redirigée vers un port série précis. La sortie standard existe bien mais il faut lui affecter un flux. On procède comme ceci :

static FILE uartout = {0} ;

static int console_putchar (char c, FILE *stream)
{
  if (c == '\n') Serial.write('\r');
  Serial.write(c);
  return 0;
}

void setup(void)
{
  Serial.begin(115200);
  Serial.println("printf() sur ARDUINO");
  fdev_setup_stream (&uartout, console_putchar, NULL, _FDEV_SETUP_WRITE);
  stdout = &uartout;
}

// Ensuite les fonctions standard C putchar(), printf() et puts() sont parfaitement utilisables :

void loop() {
  for (int i = 0 ; i < 10 ; i++) {
    printf("compteur : %d\n", i);
    delay(1000);
  }
  delay(10000);
}

printf() n'ajoute pas de caractère de fin de ligne. Il faut l'ajouter : \n

Les appels à delay() sont bien entendu facultatifs.

5. sprintf(), snprintf()

Ces fonctions sont disponibles sur ARDUINO. Elles réalisent la même opération que printf(), mais dans une chaîne de caractères, que l'on peut ensuite afficher :

  for (int i = 0 ; i < 10 ; i++) {

    char s[15];

    sprintf(s, "compteur : %d", i);

    Serial.println(s);

  }

 

Pour plus de sécurité il est préférable d'utiliser snprintf() :

  for (int i = 0 ; i < 10 ; i++) {

    char s[15];

    snprintf(s, 15, "compteur : %d", i);

    Serial.println(s);

  }

On évitera ainsi les débordements si la chaîne s est trop courte pour contenir le résultat.

6. dtostrf()

Pourquoi utiliser dtostrf() ?

Toujours pour une question de mémoire disponible, le fonction sprintf() n'accepte pas les chaîne de formatage du type flottant : %f

  float f = 1.234;

  char s[10];

  dtostrf(f, 5, 3, s);

  Serial.print("valeur : ");

  Serial.println(s); 

Ses paramètres sont les suivants :

char *dtostrf(double val, signed char width, unsigned char prec, char *s)

val : la valeur flottante

width : la longueur totale, y compris le point

prec : le nombre de décimales

s : la chaîne de caractères destinataire (de longueur suffisante)

Si le nombre de caractères à afficher est supérieur au nombre de chiffres réel, la fonction complète avec des blancs à gauche (width peut être négatif pour que les blancs soient ajoutés à droite).

Il faut bien dimensionner la chaîne fstr en fonction du paramètre width car la fonction ne vérifie pas le débordement. fstr doit être dimensionné au minimum à width + 1, car il ne faut pas oublier qu'une chaîne de caractère C se termine toujours par un caractère nul.

Un petit exemple avec printf() et dtostrf() :

void loop()
{
  float f = 6789.12345;
  char fstr[12];
  
  for (int i = 0 ; i < 10 ; i++) {
    printf("%lu result: i=%d f=\"%s\"\n", millis(), i, dtostrf(f, -10, 4, fstr));
  }
  delay(10000);
}

7. Plusieurs instances

Lorsque plusieurs cartes ARDUINO sont branchées sur un PC, et que l'on désire afficher les informations de ces différentes cartes, ouvrir une nouvelle fenêtre IDE ne suffit pas, car on ne pourra ouvrir qu'un seul moniteur série. Il faut lancer deux instances de l'IDE, en double-cliquant sur chaque fichier .ino.

8. alternatives

Le moniteur série de l'IDE ARDUINO n'est qu'un terminal comme il en existe des dizaines.

Sous Windows, on peut utiliser également teraterm, coolterm, et bien d'autres.

Sous Linux, minicom, picocom, etc.

9. Reset

A chaque fois que l'on lance le moniteur série, ou un autre terminal, la carte ARDUINO est redémarrée. Ceci est dû au simple fait que la ligne DTR est reliée à la broche RESET de l'ARDUINO, à travers un condensateur. Or la ligne DTR bascule à l'ouverture de la ligne série, ce qui provoque donc un RESET. C'est un moindre mal, mais il vaut mieux le savoir.

Sur une PRO MINI, par exemple, si l'on veut éviter cet inconvénient, il suffit de ne pas brancher le fil DTR du convertisseur USB, mais seulement RX, TX et GND. 

10. Utiliser le traceur série pour afficher des graphes

Dans le menu outils on trouve également le Traceur Série, qui permet d'afficher des graphes.

Un petit exemple :

void setup() {
  Serial.begin(115200);
  Serial.println("A1 A2");
}

void loop() {
  for (int i = 0 ; i < 10 ; i++) {
    float a1 = random(1000,2000)/100.0;
    float a2 = random(1000,2000)/100.0;
    a2 += 20;        // offset
    Serial.print(a1);
    Serial.print(",");
    Serial.println(a2);
    delay(500);
  }
  delay(1000);
}

Un tutoriel assez complet ici :

https://www.redohm.fr/2020/01/arduino-traceur-serie/ 

Cet outil est assez pauvre en fonctionnalités. Personnellement je préfère de très loin MatPlotLib, une librairie PYTHON.

Quelques exemples ici :

https://riton-duino.blogspot.com/2019/08/un-logger-analogique-et-digital.html

https://riton-duino.blogspot.com/2018/07/banc-de-mesure-de-consommation.html 

11. Utiliser le moniteur série pour entrer des commandes

La zone de texte sous le titre peut servir à envoyer des chaînes de caractères qui pourront être lues par le sketch, à l'aide de diverses méthodes (read(), readBytesUntil(), parseInt(), etc.).

Je vous renvoie à cet article :

https://riton-duino.blogspot.com/2019/12/commander-un-arduino-par-la-ligne-serie_21.html

12. Conclusion

Le moniteur série est un outil que l'on devrait mettre en œuvre systématiquement au démarrage de l'écriture d'un code. On ne peut en tirer que des bénéfices, surtout en phase de mise au point d'un programme.

Cordialement

Henri

Mars 2021 : Actualité des Blogs du Mois

 

Actualité des Blogs du Mois

Sur le blog d'Yves Pelletier :

• Écrire des nombres sur une matrice de LEDs RGB 16 X 16 WS2812B
  
• ESP32 et VS1053: écouter la radio sur internet
  
• ESP32 et VS1053: écouter les fichiers mp3 d'une carte SD
  
• Essai de l'IDE Arduino version 2.0 beta
  
• Contrôler Powerpoint avec un Leonardo et une télécommande de téléviseur
  

Sur  Framboise 314 :

• Support de montage de Raspberry Pi sur rail DIN
  
• Arduino un livre de Jean-Christophe Quetin aux Editions ENI
  
• Raspberry Pi Imager préconfigure votre distribution
  
• Comment bien souder, un tutoriel sur la soudure
  
• Mayflower : Un bateau autonome avec 4 Raspberry Pi
  
• Bientôt une carte multifonction pour le Raspberry Pi
  
• Des tutoriels Arduino français sur electronique-kit
  
• Et bien d'autres articles ...

Sur  MCHobby :

• Oscilloscope: quand utiliser l' "AC Coupling" ?
  
• Ajouter le bouton reset sur Pico
  
• Sonde Différentielle abordable pour Maker
• Et bien d'autres articles ...
  

 

Cordialement

Henri 

 

ARDUINO et pile 9V

 

ARDUINO et pile 9V

 

On voit trop souvent sur Internet ce genre de schéma : une carte ARDUINO alimentée par une pile 9V, y compris accompagnée d'un moteur !

Cette hérésie provient probablement de Fritzing, logiciel avec lequel on peut dessiner des circuits, et qui propose la pile 9V comme alimentation standard.

1. La pile 9V

Une pile 9V a une capacité d'environ 500mAH. De plus elle est incapable de débiter un courant suffisamment important pour alimenter un montage de ce genre.

Même Duracell ne donne aucune courbe de décharge au delà de 250mA pour ses piles alcalines 9V :

Si la pile débite seulement 50mA, ce qui est à peine plus que la consommation d'une carte ARDUINO UNO, la tension atteindra 6.5V au bout de 10 heures. Or 6.5V est la tension minimale dont a besoin une UNO sur sa prise JACK pour pouvoir fonctionner !

De là à piloter un moteur, même miniature, il y a un gouffre !

Le multimètre est la seule application que je lui réserve, et encore, c'est par obligation.

2. La batterie 9V NIMH

Ceux qui pensent qu'une batterie 9V a une capacité supérieure se trompent. Elle est de 200mAH pour les meilleures d'entre elles, et elle pourra débiter au maximum 1C, c'est à dire 200mA.

3. Quelle solution ?

Il y a des tas de solutions, mais il faut déjà se poser la question de l'autonomie désirée, et surtout choisir une carte ayant une consommation la plus faible possible.

Pour information, voici un article qui résume les consommations des différentes cartes : https://riton-duino.blogspot.com/2018/12/consommation-dune-carte-arduino.html

3.1. La UNO ou NANO

Une carte UNO ou NANO consomme environ 30mA, et 12mA en veille.

L'autonomie nécessaire pour une journée sera de :

C = 0.030 * 24 = 900mAH

En mode sommeil elle sera de :

C = 0.012 * 24 = 290mAH

On constate assez vite que la batterie devra être énorme si l'on désire avoir une autonomie importante.

3.1.1. Alimentation en 5V

Ce mode d'alimentation peut être mis en œuvre de deux manières :

• connecteur USB
• broche VCC ou 5V
  

La batterie 5V n'existe pas. Tout ce que l'on peut proposer dans le commerce est basé sur une batterie LITHIUM-ION 3.7V, suivie d'un régulateur élévateur de tension, comme un POWER-BANK par exemple.

On trouve des POWER-BANK de capacités diverses. On pourra alimenter l'ARDUINO directement à l'aide d'un cordon USB.

On peut aussi fabriquer son propre POWER-BANK à l'aide d'une carte spécialisée :

Cartes d'alimentation par batterie

3.1.2. Alimentation > 6.5V

Ce mode d'alimentation peut être mis en œuvre de deux manières :

• connecteur JACK sur une UNO ou MEGA
  
• broche VIN
  

Il est possible d'utiliser toute pile ou batterie ayant une tension comprise entre 6.5V et 15V :

• batterie 12V
• 2 batteries LITHIUM-ION en série
• batterie LIPO 7.4V
  
• 6 batteries NI-MH en série
• 5 piles 1.5V en série
  

Par exemple deux batteries LITHIUM-ION 18650 de 2500mAH pourront alimenter une UNO pendant :

T = 2500mAH / 30mA = 83 heures en mode éveil permanent

T = 2500mAH / 12mA = 200 heures en mode veille

Ce n'est pas fabuleux mais cela peut convenir à une utilisation occasionnelle (robot, voiture, jouet, éclairage portatif, etc.).

A noter : brancher plusieurs batteries en série ne modifie en rien leur capacité. Autrement dit 2 batteries de 3.7V 2500mAH en série sont équivalentes à une batterie de 7.4V 2500mAH.

3.1.3. Alimentation secteur

L'alimentation secteur est souvent la meilleure alternative si le montage a une consommation importante. Un bloc secteur 5V USB est parfaitement adapté.

3.2. La PRO MINI 3.3V

La carte PRO MINI 8MHz 3.3V a de multiples avantages :

• elle peut fonctionner entre 2.7V et 6V, alimentée par sa broche VCC
• elle consomme 5mA en mode éveil permanent
• elle consomme 1.5mA en mode veille
• elle consomme 1.5µA en mode veille si on la bricole un peu (voir ICI)
  

Il est possible d'utiliser toute pile ou batterie ayant une tension de 3.6V ou 3.7V, ou même 4.5V :

• 1 batterie LITHIUM-ION
• 1 batterie LIPO 3.7V
  
• 3 batteries NI-MH en série
• 3 piles 1.5V en série
  

Par exemple une batterie LITHIUM-ION 18650 de 2500mAH pourra alimenter une PRO MINI 3.3V pendant :

T = 2500mAH / 5mA = 500 heures en mode éveil permanent

T = 2500mAH / 1.5mA = 1600 heures en mode veille

T = 2500mAH / 1.5µA = 1600000 heures en mode veille pour une carte bricolée

Ce chiffre de 1600000 heures est théorique. Le courant d'auto-décharge de la batterie limitera cette durée à environ 1 an, 1,5 an pour les meilleures.

4. Conclusion

Pour conclure je vous renvoie à la lecture d'un certain nombre d'articles :

Consommation d'une carte ARDUINO, ESP8266 ou ESP32

ARDUINO : l'alimentation (VCC, VIN, etc.)

ARDUINO : PRO MINI 5V ou 3.3V

ARDUINO PRO MINI & basse consommation

Alimenter un ARDUINO sur Pile ou Batterie

ESP8266 et ESP32 sur batterie

Alimentation par batterie + panneaux solaires

Convertisseurs STEPUP & STEPDOWN

Cartes d'alimentation par batterie

Un thermomètre MYSENSORS sur batterie

Un thermomètre / hygromètre MYSENSORS sur batterie

Détecteur de mouvement MYSENSORS sur batterie

Porte Motorisée de Poulailler

Cordialement

Henri

Février 2021 : Actualité des Blogs du Mois

 

Actualité des Blogs du Mois

Sur le blog d'Yves Pelletier :

• Contrôler un diaporama Powerpoint avec Arduino Leonardo
  
• ESP8266 et ESP32: Contrôle d'une matrice de LEDs RGB
  
• ESP32/ESP8266: Écriture et lecture d'un fichier en mémoire flash
  
• Programmation OTA de l'ESP32 / ESP8266
  
• Screenduino: un outil en ligne pour dessiner sur un LCD 2X16
• IDE Arduino: modifier les paramètres du formatage automatique
  

Sur  Framboise 314 :

• Enceinte Bluetooth Tronsmart Force 2
  
• Multimètre automatique Kkmoon HT118A
  
• Crowbits un système modulaire pour apprendre à programmer
  
• A vendre Oscilloscope Hameg HM203-5
  
• Regarder Netflix sur un Raspberry Pi 4
  
• Améliorer l’alimentation du Raspberry Pi 4
• Un automate industriel programmable à base de Raspberry Pi
• Les imprimantes Creality en promotion
• Un lien vers les serveurs Microsoft dans Raspberry Pi OS ! 
  
• JLCPCB : Mieux fabriquer les Circuits imprimés PCB
• Détection d’intrusion (IDS) avec Suricata sur Raspberry Pi 
  

Sur  MCHobby :

• LNK305PN : pour créer des alimentation AC/DC sans isolation
  
• PowerBank-Foolish : empêcher la mise en veille des PowerBanks intelligents
  
• Pyboard-D Butterfly : Faciliter le prototypage avec la Pyboard-D
  
• Et bien d'autres articles ...
  

Sur Papsoid :

• Hello Pico !
  

Sur ArduiBlog

• Raspberry Pico
  
• Octoprint sur Rasperry Pi Zero W
  

 

Cordialement
Henri 

 

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