En lisant le manuel de référence du EFM8BB10F8 mon attention a été attiré par le périphérique PCAProgrammable Counter Array. Chaque fabriquant nomme ses périphériques comme sa lui chante d'autres appelleraient ça Advance Capture/Compare. Cependant le PCA possède un mode de fonctionnement que je n'ai pas vue ailleurs. Silicon Labs appelle-ça le mode Frequency output. Dans cette deuxième partie mon objectif est d'expérimenter cette fonctionnalité.

PCA experements

Le PCA possède un compteur 16 bits et 3 canaux comparateurs qui peuvent-être utilisés selon 11 modes. J'ai créé un nouveau projet appelé PCA experements dans simplicity studio.

problème avec le configurateur

le PCA a 3 canaux j'ai choisi le canal 0 pour ma sortie en fréquence. L'entrée/sortie CEX0 peut-être assignée à n'importe qu'elle broche des ports 0 ou 1 mais j'ai découvert qu'il n'y a pas de registres pour sélectionner la broche désirée. Le crossbar choisi lui-même la broche en fonction de celles qui sont disponibles et d'un système de priorité par périphérique¹.

Au diable le configurateur

Au diable le configurateur, on n'est jamais mieux servit que par soi-même. J'ai configuré ce que j'ai pu dans le configurateur et j'ai ajouter le code suivant dans la fonction void SiLabs_Startup (void) du fichier pca_experements_main.c.

void SiLabs_Startup (void)
{
 // empêche le crossbar d'utiliser le port 0.
 P0SKIP=255; 
 // bloc pour le crossbar toutes les broches du port 1
 // sauf P1.3
 P1SKIP=~(1<<3); 
}

A part ça il n'y a rien d'autre à faire sinon d'ajouter une seule ligne de code dans la fonction main. En mode Frequency output, la valeur dans le registre PCA0CPHx détermine la fréquence du générateur selon la formule:

Fcex=Fpca/2/PCA0CPHx
Fpca est la fréquence du signal qui alimente la minuterie du PCA
PCA0CPHx  est la valeur dans le registre PCA0CPHx. 
Ici x représente le canal, i.e. {0,1,2}

int main (void)
{
  // Call hardware initialization routine
  enter_DefaultMode_from_RESET();

 //fréquence de sortie sur Fcex0=Fpca/2/PCA0CP0H
        // Fsys=24,5Mhz/32
 // Fpca=Fsys/12=63802Hertz
 // Fcex0=63802/2/10=3190Hertz
 PCA0CPH0=10;
  while (1) 
  {
    // $[Generated Run-time code]
    // [Generated Run-time code]$
  }                             
}

Expérience #2

Dans le configurateur si on active les interruptions sur PCA0

SI_INTERRUPT (PCA0_ISR, PCA0_IRQn)
{
 static unsigned char hcycles=0;
 PCA0CN0&=0xfe; // remet à zéro le bit CCF0
 hcycles++;
 if (hcycles==2){
    hcycles=0;
           // truc pour commuter la valeur de PCA0CPH0 entre 10 et 20.
    PCA0CPH0=30-PCA0CPH0;
 }
}

Conclusion

1. pas de récompense pour l'ingénieur qui a imaginé ce système.

Je poursuis mes expériences avec le PCA Programmable Counter Array du EFM8BB10F8G-A-SOIC6 débuté dans la partie 2 de cette série. J'en suis rendu au mode high speed output.

high speed output

D'emblée je dois dire que la documentation fournie par Silicon Labs laisse à désirer. Voici tout ce qu'a à dire le manuel de référence à propos de ce mode de fonctionnement.
15.3.6 High-Speed Output Mode In High-Speed Output mode, a module’s associated CEXn pin is toggled each time a match occurs between the PCA Counter and the module's 16-bit capture/compare register (PCA0CPHn and PCA0CPLn). When a match occurs, the capture/compare flag (CCFn) in PCA0CN0 is set to logic 1. An interrupt request is generated if the CCFn interrupt for that module is enabled. The CCFn bit is not automatically cleared by hardware when the CPU vectors to the interrupt service routine. It must be cleared by software. Setting the TOGn, MATn, and ECOMn bits in the PCA0CPMn register enables the High-Speed Output mode. If ECOMn is cleared, the associated pin retains its state and not toggle on the next match event. Note: When writing a 16-bit value to the PCA0 Capture/Compare registers, the low byte should always be written first. Writing to PCA0CPLn clears the ECOMn bit to 0; writing to PCA0CPHn sets ECOMn to 1. À partir de cette information insuffisante j'ai eu de la difficulté à faire fonctionner ce mode malgré mes recherches sur le site de Silicon labs qui ne m'ont pas permis de trouver un exemple d'application spécifique à ce MCU mais seulement la note applicative AN107 qui concerne les MCU C8051Fxxxx. Après de nombreux essais et erreurs j'ai réussi à faire fonctionner le mode high speed output pour faire du PWM 16 bits. Pour cette expérience j'ai utilisé le même montage que pour la partie 1. Dans cette expérience l'intensité de la LED varie selon une fonction triangulaire sur une période de 2 secondes.

Comme on le voie sur le diagramme bloc ci-dessous ce mode utilise un compteur 16 bits constitué de PCA0H:PCA0L et d'un registre de comparaison de 16 bits constitué de PCA0CPHn:PCA0CPLn. Lorsque le compteur atteint la valeur de comparaison la sortie CEXn est inversée. Le compteur PCA0 marche en boucle de 0 à 65535. Donc la période est fixée par la fréquence Fpca qui alimente le compteur PCA0. Si on configure Fsys à la fréquence maximale de 24,5Mhz et qu'on alimente le compteur PCA0 directement à cette fréquence,la fréquence du cycle PWM sera de 24,5e6/65536=373,8Hertz.

Pour faire du PWM 16 bits avec ce mode il faut activer l'interruption sur débordement du Compteur PCA0 et celle du comparateur et la l'intérieur de la routine d'interruption modifier la valeur de comparaison dans PCA0CP. On va garder le même projet que dans la partie 2 mais en retournant dans le configurateur et on va modifier la configuration pour obtenir les valeurs suivantes.

• clockà la fréquence maximale pour obtenir un Fsys de 24,5Mhz.
• PCA0 alimenté par Fsys ce qui va nous donner une fréquence PWM de 24,5e6/65536=373,8Hertz. On va activé l'interruption sur débordement du compteur PCA0
• PCA0, Channel 0 configuré pour le high speed output avec activation de l'interruption sur le comparateur. La sortie est aussi inversée car la broche est configurée en open drain avec la cathode de la LED sur la broche P1.3. Si la sortie n'est pas inversée l'intensitée sera inversement proportionnelle à la valeur de PCA0CP0 et non proportionnelle mais ça va fonctionner quand même.
.

On ferme le configurateur pour mettre à jours les fichiers et on va ajouter quelques lignes de codes.

• Dans le fichier InitDevice.h on va ajouter les constantes suivantes. La valeur de PWM_MIN a été déterminée par essaie et erreur et dépend de la durée de l'interruption. Plus l'interruption met de temps à s'exécuter plus cette valeur est grande. // USER CONSTANTS // valeur minimale autorisée pour le rapport cyclique #define PWM_MIN ((unsigned)52) // valeur maximale autorisée pour le rapport cyclique #define PWM_MAX ((unsigned)~PWM_MIN) // incrément du rapport cyclique pour un // fade-in fade-out de 2 secondes #define DURATION (2) // durée du cycle fade-in fade-out // 374 est la fréquence du cycle PWM. #define PWM_STEP (((unsigned)(PWM_MAX-PWM_MIN))/374/DURATION)
• Dans le fichier Interrupts.c on va ajouter du code dans la routine d'interruption générée par le configurateur. #include "InitDevice.h" // pour les USER CONSTANTS char lock; // mutex sur la variable pwm_val unsigned int pwm_val=PWM_MIN; SI_INTERRUPT (PCA0_ISR, PCA0_IRQn) { static unsigned int brightness=PWM_MIN; if (PCA0CN0&PCA0CN0_CF__BMASK){ // première partie du cycle PWM if (!lock) brightness=pwm_val; PCA0CPL0=brightness&0xff; PCA0CPH0=(brightness>>8)&0xff; }else{ // deuxième partie du cycle PWM PCA0CPL0=0; PCA0CPH0=0; } PCA0CN0=~(PCA0CN0_CF__BMASK|PCA0CN0_CCF0__BMASK); }
• Finalement on va ajouter le code pour contrôler l'intensité de la LED dans la fonction main() du fichier pca_experiments_main.c
  On met les instructions à l'intérieur de la boucle while parce que à chaque interruption le MCU sort du mode idle et que c'est à ce moment qu'on modifie l'intensité avant de remettre le MCU en idle.
extern char lock; extern unsigned int pwm_val; //----------------------------------------------------------------------------- // main() Routine // ---------------------------------------------------------------------------- int main (void) { unsigned int temp,step=PWM_STEP; // Call hardware initialization routine enter_DefaultMode_from_RESET(); while (1) { PCON0|=1; lock=1; temp=pwm_val+step; if ((temp>PWM_MAX) || (temp<pwm_min step="-step;" pwm_val lock="0;" run-time code></pwm_min>

Fonctionnement

Commençons par la fonction main(). le code tourne indéfiniment dans une boucle while(1){}. La première instruction de la boucle suspend l'exécution de code en mettant le MCU en mode idle. Lorsqu'une interruption se produit le MCU sort du mode idle et lorsque l'interruption se termine le CPU exécute le code qui suis l'instruction PCON0|=1. Ce code débute par un verrou lock. lock est ce qu'on appelle en informatique une variable mutex(i.e. mutually exclusive). Sont rôle est d'empêcher la routine d'interruption d'accéder la variable pwm_val lorsque la routine main() est en train de la modifier. Comme il s'agit d'une variable 16 bits il faut plus d'une instruction machine pour modifier cette variable. Imaginez qu'une interruption se produit entre le moment où la fonction main() a modifié l'octet faible de pwm_val et celui où elle modifie l'octet fort de pwm_val. Si l'interruption fait une lecture de pwm_val la valeur lue sera erronée. Donc avant de lire pwm_val l'interruption vérifie la valeur de la variable lock et ne lie la variable que si lock est à zéro. Ainsi on est certain que la valeur lue est bonne. Donc la variable lock est mise à 1 avant de débuter le bloc d'instructions qui va modifier la valeur de pwm_val qui contrôle l'intensité de la LED. Elle est remise à zéro lorsque la modification est complétée.

À chaque interruption la fonction main() modifie la valeur de pwm_val en ajoutant ou soustrayant la valeur step qui contrôle la vitesse du cycle fade in, fade out. Plus step est grand plus la LED va varier d'intensité rapidement. Dans ce démo le cycle est régler sur 2 secondes. La fonction main() s'assure que la valeur de pwm_val demeure à l'intérieur des limites valides.

Le rôle de la routine d'interruption

Le compteur PCA0 compte en boucle de 0 à 65535. À chaque débordement de PCA0 ainsi que lorsque PCA0==PCA0CP0 l'interruption SI_INTERRUPT (PCA0_ISR, PCA0_IRQn) est déclenchée. S'il s'agit d'une interruption causée par le débordement du compteur PCA0, c'est la première moitié du cycle PWM. On vérifie si la variable pwm_val est disponible. Si c'est le cas on réinitialise la variable locale brightness avec la valeur de pwm_val. Ensuite on affecte la valeur de brightness au registre PCA0CP0 qui détermine l'intensité de la LED. Par contre si l'interruption est causée par PCA0==PCA0CP0,c'est la deuxième moitié du cycle PWM. Alors PCA0CP0 est mis à 0 pour compléter le cycle en inversant à nouveau la sortie P1.3 lorsque le compteur va revenir à zéro par débordement.

Notez que PWM_MIN ne peut être inférieur au délais de réponse de l'interruption car pendant ce délais le compteur PCA0 continue à avancé. Si on initialise PCA0CP avec une valeur trop petite le compteur aura déjà dépassé cette valeur lorsque PCACP0 sera initialisé et le comparateur ne déclenchera pas l'inversion de la sortie. Ce raisonnement vaut aussi pour la valeur PWM_MAX qui est le complément à 1 de PWM_MIN.

Générateur de fréquence avec diviseur 16 bits

Il est possible d'utiliser le mode high speed output pour générer des fréquences. On retourne dans le configurateur pour désactiver l'interruption sur le débordement du compteur PCA0.

Le principe de fonctionnement est le même que pour le générateur de fréquence de la partie 2 sauf que la mise à jour de PCA0CP doit-être faite manuellement dans la routine d'interruption. Ce qui implique encore une fois une valeur minimum pour FRQ_DIV. Par essaie erreur j'obtiens 48 pour cette valeur minimum. Avec le compteur PCA0 alimenté à 24,5Mhz ça donne une fréquence maximale de 24,5Mhz/2/48=255Khz la valeur de fréquence minimale est de 24,5Mhz/2/65535=187Hertz. La granularité, c'est à dire la variation de fréquence entre 2 diviseurs adjacents, est inversement proportionnelle à FRQ_DIV.

Gestion de la consommation

Tous les MCU possèdent un mécanisme de gestion de la consommation électrique. Les EFM8BB1xxx ne font pas exceptions. Quelques explications sur les modes disponibles. Il y en a 4.

1. Normal, dans ce mode le CPU et les périphériques activés fonctionnent normalement. C'est le maximum de consommation électrique. On peut réduire la consommation en réduisant la fréquence de l'horloge.
2. Idle, dans ce mode le CPU est désactivé donc aucune instructions n'est exécutée. Par contre les périphériques continues à fonctionner comme ils ont été configurés. On économise donc l'énergie dépensée par le CPU. Ce mode est utilisé dans les applications pilotées par interruption. Sitôt qu'une interruption est déclenchée le CPU se remet en fonction pour exécuter le code de l'interruption. À la fin de l'interruption il ne retombe pas en mode idle il faut l'y remettre. L'exemple ci-haut est un exemple de ce mode de fonctionnement. La dépense d'énergie est principalement celle causée par les périphériques. Dans ce mode la mémoire RAM est conservée et les états du CPU sont conservés. A la sortie de l'interruption c'est l'instruction qui suis celle qui a mis le CPU en idle qui est exécutée.
3. stop, arrête tous les signaux d'horloges. Donc le CPU et les périphériques nécessitant un signal d'horloge sont désactivés. Par contre les entrés/sorties demeure dans leur état. Donc si une LED branchée sur une broche est allumée elle demeure allumée. Les comparateurs analogiques continus de fonctionner et peuvent-être configurer pour déclencher un reset. La seule façon de sortir de ce mode est par un reset ou une remise sous tension. Notez que si la détection missing clock est activée elle va générer un reset après son délais normal et redémarrer le MCU. Pour garder le MCU en mode stop il faut donc que la détection missing clock soit désactivée. Lorsque le MCU sort de ce mode il exécute le code à partir de l'adresse 0x0000 comme s'il venait juste d'être mis sous tension.
4. shutdown, semblable au mode stop mais en plus le régulateur de tension du CPU est désactivé. Consommation minimale assurée. Le CPU fonctionne à 1,8 volt et puisque le MCU doit-être alimenté avec une tension entre 2,2 et 3,6 volt il faut un régulation de tension interne fournissant 1,8 volt au CPU.

• PCON0, Contient les bits IDLE et STOP. Les 6 autres bits peuvent-être utilisés par les application comme indicateurs booléens et sont nommés GF0 à GF5.
• REGCN0, Il n'y a qu'un seul bit d'utilisé dans ce registre STOPCF. Si ce bit est mis à 1 avant de mettre le bit STOPà 1 alors le MCU va passé en mode SHUTDOWN et seule la broche ~reset ou un cyclage de l'alimentation pourra le redémarrer.

Dans cette quatrième partie consacrée au EFM8BB10F8G je discute de l'implémentation du jeu breakout. Il s'agit d'un jeu d'arcade datant de 1976. Il s'agit de casser un mur de brique à l'aide d'une balle qui rebondie sur les murs extérieurs ainsi que sur la palette que le joueur déplace de gauche à droite dans le bas de l'écran.

Breakout

Le MCU EFM8BB10F8G ne possède que 512 octets de mémoire RAM divisé en 256 octets de mémoire interne idata et 256 octets de mémoire externe xdata. La mémoire externe est utilisée comme mémoire vidéo ce qui limite la résolution d'écran à 64 pixels par 32 pixels en monochrome. C'est suffisant pour ce jeu. J'ai créé un projet appellé BBchip8 dans simplicity studio. je l'ai appellé ainsi pour 2 raisons. La première étant que la résolution est la même que pour l'émulateur CHIP-8 et la seconde est que j'ai implémenté dans les fichiers chip8.c et keypad.c des fonctions qui permettent d'écrire d'autre jeux dans le style CHIP-8 en utilisant la même base de code. D'ailleurs le jeu breakout utilisant moins de la moitié de la mémoire programme il serait possible d'ajouter un autre jeu sur la même plateforme et d'offrir un menu de sélection à l'utilisateur. Le jeu tétris entrerais dans la mémoire restante.

schématique du circuit

schématique

prototype

Utilisation du configurateur

Il s'agit d'un projet créer avec le configurateur.

Un oscillateur à cristal externe avec une fréquence de 25.175Mhz est utilisé. Fsys fonctionne à la fréquence maximale.

Le watchdog timer est désactivé.

Le Programmable counter array est utilisé pour générer le signal NTSC. Les 3 canaux sont utilisés.

Les 3 canaux fonctionnent en mode 1, 16 bits software timer.

Le périphérique SPI est utilisé pour sérialiser les pixels vidéo.

La minuterie 0 est utilisée pour les délais et la minuterie 1 pour les sons.

Les interruptions sur le PCA et sur le TIMER0 sont activées.

SI_INTERRUPT_USING (PCA0_ISR, PCA0_IRQn,1)// use register bank 1

organisation du code.

• Le fichier chip8.c contient les routines pour la gestion vidéo, les sons, la routine pause() pour les délais ainsi que des routines pour le générateur pseudo-aléatoire. Le générateur pseudo-aléatoire utilise le convertisseur analogue/numérique pour lire une entrée inexistante. En effet à la mise sous tension le registre ADC0MX contient 0x1F. Avec cette valeur l'entrée du convertisseur est flottante. On lit donc le bruit produit par le MCU. Seul le bit le moins significatif est conservé, celui-ci étant suffisamment aléatoire pour cette application. La fonction random() accumule le nombre de bits demandés en appelant répétitivement rand_bit() qui est la fonction qui lit la sonde de température.
• Le fichier keypad.c contient les routines pour la lecture des boutons.
• Le fichier breakout.c contient la logique du jeu.
• Les autres fichiers sont ceux générés automatiquement par le configurateur. Dans le fichier interrupts.c le code pour la gestion des interruptions PCA et TIMER0 a été ajouté manuellement.

vidéo démo

Lorsque j'étais enfant il y avait des boites à musique qui fonctionnaient avec un ressort. Un jour j'en ai démonté une pour voir comment c'était fait. Il y avait un cylindre avec des pointes de métal ainsi qu'un peigne en métal avec les dents de longueurs différentes. La longueur de chaque dent déterminait la fréquence de la note. Le ressort faisait tourner le cylindre et les pointes de métal du cylindre accrochaient les dents du peigne au passage. Les pointes étaient disposées pour jouer une mélodie en particulier.

Dans cet article je présente une version électronique de la boite à musique. Contrairement à la boite à musique mécanique celle-ci peu jouer plusieurs mélodies.

schématique

Pour que le son soit moins saccadé j'ai ajouté un générateur d'enveloppe constitué du transistor Q1 et des résistances,R6,R10 et R12 ainsi que du condensateur C3. Au début de chaque note la sortie P1.1 est mise à 1 pendant 40 millisecondes. Pour permettre à C3 de se charger. Ensuite P1.1 est mise en haute impédance et C3 se décharge lentement à travers R10 et la base de Q1. l'effet produit est que le son monte en intensité en suivant la courbe de charge du condensateur et ensuite l'intensité diminue plus lentement par la décharge de C3. La montée sonore appelée attaque est déterminée par la constante de temps R6*C3 tandis que la descente est déterminée par la constante de temps C3*(R10+Rb) où Rb est la résistance réfléchie par la base du transistor. Rb est approximativement G*R12, G étant le gain du transistor. Donc le transistor C3 se décharge beaucoup plus lentement qu'il ne se charge.

Les notes sont produites par le canal 0 du PCA0 dont la sortie est acheminée sur la broche P1.0.

Le bouton déclencheur est branché sur la broche P1.2. Chaque fois que le bouton est enfoncé une seule mélodie est jouée. Le bouton doit-être relâché et enfoncé à nouveau pour jouer la mélodie suivante.

Sur la broche P1.3 il y a un sélecteur de mode. On peut choisir entre le mode aléatoire et le mode séquentiel. Le mode doit-être sélectionné avant que l'appareil soit mis sous tension. Dans le mode séquentiel les mélodies sont jouées toujours dans le même ordre, celui où elles apparaîssent dans la table tunes_list. En mode aléatoire la mélodie est sélectionnée au hasard. En fait de hasard, il s'agit de lire le registre TL0 qui est la partie basse de la minuterie TIMER0 qui compte en boucle rapidement à la fréquence Fsys. Il est impossible de prévoir ou est rendu le compte dans TL0 au moment ou on presse le bouton d’où l'effet aléatoire.

Je n'ai pas fait de montage final de ce projet mais je pense que ça pourrait plaire à un jeune enfant. Sur le montage temporaire tel que vue dans la vidéo ci-bas je n'ai pas fait le montage au complet, je n'utilise qu'une alimentation de 3,3 volt et un petit ampli à transistors fait maison qui fonctionne à cette tension contrairement au LM386 qui nécessite un minimum de 4 volts.

Actuellement il y a 8 mélodies d'enregistrées dans la mémoire flash du MCU et il y a 1305 octets d'utilisés sur les 8Ko. Il est donc possible de rallonger cette liste. Il y a probablement assez d'espace pour une symphonie ;-)

Les mélodies que j'ai utilisées proviennent du site http://www.apprendrelaflute.com

Comme toujours l'ensemble du projet est sur github.

démo

Liens

source du projet.

Dans cet article j'explique comment installer un boot loader compatible avec l'environnement de développement Arduino ansi que l'installation de Arduino IDE sur Ubuntu.

Modification matérielle

La spécification USB précise qu'il doit y avoir une résistance de 1k5 entre D+ et l'alimentation 5V. Hors les cartes blue pill ne respecte pas ce standard. Sur la schématique que j'ai téléchargé R10 indique une valeur de 4k7 et sur les cartes que j'ai la valeur est de 10K. Plutôt fantaisiste comme valeurs.

La carte blue pill doit-être modifiée soit en remplacant la résistance R10 par une résistance de 1k5 ou en mettant en parallèle avec celle-ci une résistance pour que la valeur équivalente de R10//Rs soit de 1k5. Sur mes cartes R10 est de 10K donc il faut une résistance de 1k8 en parallèle pour obtenir 1k5 entre D+ du connecteur USB et le +5v comme sur la photo suivante où j'ai soudé Rs entre les broches A12 et 5V de la carte. A12 est relié à D+ du connecteur USB.

Programmation du bootloader STM-Arduino

1. Clonez sur votre ordinateur le dépôt https://github.com/rogerclarkmelbourne/STM32duino-bootloader
   git clone https://github.com/rogerclarkmelbourne/STM32duino-bootloader
   Déplacez vous dans le dossier binaries de ce dépôt. Sur mes cartes la LED verte est branchée sur la broche PC13 donc j'utilise le bootloader
   generic-boot20_pc13.bin.
   Si votre carte est différente utilisez le fichier correspondant à la broche où est branché la LED verte.
2. Sur la carte blue pill placer le cavalier boot0à la position 1.
3. Branchez le programmeur à la carte blue pill et au PC.
4. faites la commande:
   st-info --probe
   Pour être certain que le programmeur est fonctionnel et que la carte blue pill est bien détectée.
5. Pour programmer le bootloader faite la commande:
   st-flash --reset write generic-boot20_pc13.bin 0x8000000
   Vérifier les messages pour vous assurez que tout c'est bien passé.
6. Maintenant que le bootloader est installé sur la carte on n'a plus besoin du programmeur ST-LINK v2. La programmation va se faire via le connecteur USB à l'autre bout de la carte. Débranchez et mettez de côté le programmeur. Replacez et cavalier boot0à la position 0.
7. Connectez la carte blue pill au PC en utilisant un câble USB. Au moment du branchement la LED verte clignote rapidement puis lentement 5 fois. Si ce n'est pas le cas le bootloader n'est pas installé correctement ou bien vous avez oublier de remettre le cavalier boot0à la position 0.

Installation de Arduino IDE sur Ubuntu Linux

1. À partir de cette page téléchargez la version qui convient à votre PC.
2. À partir du dossier où vous avez téléchargé le fichier lancez le programme d'installation ./install.sh. Une icône raccourci sera créée sur le bureau. Sur mon PC l'icône de fonctionnait pas il y avait une erreur au lancement du programme. Il a fallut que j'édite le fichier raccourci pour mettre le nom de l'exécutable entre guillemets car il y avait un espace dans le nom du fichier.
   gedit ~/Bureau/arduino-arduinoide.desktop
   ligne modifiée encadrée en rouge

Progammation de la blue pill en utilisant Arduino IDE

L'IDE nécessite d'être configuré pour l'utilisation des µC STM32

1. Lancez Arduino IDE.
2. Allez dans le menu Fichiers - Préférences pour ajouter URL de gestionnaire de carte supplémentaire suivante
   http://dan.drown.org/stm32duino/package_STM32duino_index.json
3. Maintenant il faut installer les librairies pour la carte blue pill dans Outils - Type de carte - Gestionnaire de cartes. Déroulez la liste jusqu'à la carte STM32F1xx/GD32F1xx. Cliquez dans le carré. Sélectionnez la version la plus récente dans la liste dérourante et cliquez sur le bouton installer. Fermer ce fenêtre lorsque l'installation est complétée.
4. Retournez encore dans le menu Outils - Type de carte, cette fois-ci sélectionnez dans la liste la carte GenericSTM32F103C series
5. Allez dans Outils - Variant: et sélectionnez STM32F103C8 (20K RAM, 64K flash).

Premier programme, blink

Allez dans Fichier - Exemples - A_STM32_Examples - Digital et sélectionnez Blink

/*
  Blink
  Turns on an LED on for one second, then off for one second, repeatedly.

  Most Arduinos have an on-board LED you can control. On the Uno and
  Leonardo, it is attached to digital pin 13. If you're unsure what
  pin the on-board LED is connected to on your Arduino model, check
  the documentation at http://arduino.cc

  This example code is in the public domain.

  modified 8 May 2014
  by Scott Fitzgerald

  Modified by Roger Clark. www.rogerclark.net for Maple mini 25th April 2015 , where the LED is on PB1

   Modified by PICATOUT for blue pill 2018/08/22, green LED on PC13
 */

// La LED verte est sur la broche PC13
#define GREEN_LED PC13
// the setup function runs once when you press reset or power the board
void setup() {
  // initialise la broche GREEN_LED en sortie digitale.
  pinMode(GREEN_LED, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
// fait clignoter la LED 3 fois/secondes.
// puisque la LED est branchée avec la cathode à PC13 elle allume
// lorsque PC13 est LOW.
  digitalWrite(GREEN_LED, HIGH);   // éteint la LED verte
  delay(167);              // attend 1/6 de seconde
  digitalWrite(GREEN_LED, LOW); // allume la LED verte
  delay(167);              // attend 1/6 de seconde
}
}

En cliquant sur la flèche qui pointe à droite sur barre d'outils le programme se compile et s'il n'y a pas d'erreur est téléversé sur la carte blue pill.

Et bien j'ai essayé plusieurs fois et ça ne fonctionne pas. Il y a un message d'erreur dans la fenêtre du bas qui dit:

Comment désintaller le bootloader

1. Débrancher le cable USB et mettre le cavalier boot0à 1.
2. Brancher la carte au ST-LINK V2 et brancher celui-ci au PC
3. Faire la commande:
   st-flash erase
4. Débrancher la carte et remettre le cavalier boot0à sa position initiale. Rebrancher la carte et le programmeur au PC.
5. Il faut modifier la configuration du Arduino IDE pour utiliser le ST-LINK comme programmeur en allant dans Outils - Upload method: et sélectionner STLINK
6. Réessayer le téléversement. Bingo ça fonctionne.

Il y a 1 peu plus d'un an j'ai découvert l'existence d'une carte de développement très économique basée sur un µC STM32F103C8T6. Il s'agit d'un µC 32 bits Cortex M3. Suite à la lecture de l'article suivant sur hackaday, j'en ai commander 5 sur ebay.ca. Cette carte a étée bâptisée blue pill.

Cet article est le premier d'une série sur la programmation de la blue pill en utilisant différents outils.

• Programmation en utilisant Arduino IDE.
• Programmation en C en utilisant les outils GNU arm-none-eabi.
• Programmation en utilisant MECRISP Forth.
• Programmation en utilisant la plateforme WEB mbed.

Pré-requis

Je travaille sous Ubuntu 16.04 LTS les descriptions que je vais faire sont donc pour cette plateforme. Ça devrait aussi être valide pour une autre distribution Linux basé sur Debian-Linux.

Dans cette première partie je vais décrire comment installer les outils de développement qui seront nécessaires pour les prochains articles.

Blue pill

Voici la schématique de la carte blue pill

STM32F103C8T6

Voici les principales caractéristiques du µC qui est installé sur cette carte.

• Coeur ARM Cortex M3, Fsys maximale 72Mhz.
• Mémoire flash 64Ko
• Mémoire RAM 20Ko
• 3 timers usage général et 1 avancé.
• 2 SPI
• 2 I²C
• 3 USART
• 1 USB
• 1 CAN
• 37 GPIO
• 2 ADC 10 canaux résolution 12 bits
• datasheet

STLINK-V2

Pour programmer la carte il faut un programmeur STLINK-V2. Heureusement un clone de ce programmeur est aussi disponible sur ebay.caà petit prix.

Installation des outils logiciels.

Pour les étapes d'installation logicielle vous devez être membre du groupe sudo car des privilèges root sont requis pour certaines étapes.

utilitaire ST-LINK

Les utilitaires ST-LINK sont disponibles en open-source sur https://github.com/texane/stlink.
Étapes à suivre à partir de la ligne de commande i.e. sous Ubuntu on fait <CTRL>-<ALT>-T pour ouvrir la console de comamdes.

1. Installer les outils de développement gcc et binutils.
   sudo apt install gcc binutils
2. Installer l'utilitaire cmake.
   sudo apt install cmake
3. Installer libusb-dev
   sudo apt install libusb-dev
4. Cloner le dépôt https://github.com/texane/stlink.
   J'ai créé un dossier ~/Documents/blue pill dans lequel j'ai cloné le dépôt:
   git clone https://github.com/texane/stlink
5. Lancer cmake à partir du dossier stlink pour créer les fichiers de configurations utilisés par make. N'oubliez pas le point après cmake pour indiquer à cmake qu'il travaille à partir du répertoire courant.
   cmake .
6. Lancer make
   make
7. Lancer make install. Utilisez sudo car les privilèges root sont requis.
   sudo make install.
   Les utilitaires sont installés dans /usr/local
8. Modifier /etc/ld.so.conf pour indiquer le chemin des librairies utilisées par st-link. Utilisez votre éditeur de texte préféré et ajouter à la fin du fichier /etc/ld.so.conf la ligne /usr/local/lib et sauvegarder. sudo est requis.
   sudo gedit /etc/ld.so.conf
   cat /etc/ld.so.conf
   include /etc/ld.so.conf.d/*.conf
   /usr/local/lib
   
   On recharge la configuration avec la commande.
   $ sudo ldconfig
9. Maintenant branchez le programmeur ST LINK v2 dans un port USB. Faites la commande
   $ lsusb
   Bus 002 Device 007: ID 0483:3748 STMicroelectronics ST-LINK/V2
   Bus 002 Device 002: ID 8087:0024 Intel Corp. Integrated Rate Matching Hub
   Bus 002 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
   Bus 001 Device 004: ID 0461:0010 Primax Electronics, Ltd HP PR1101U / Primax PMX-KPR1101U Keyboard
   Bus 001 Device 003: ID 0000:0538
   Bus 001 Device 002: ID 8087:0024 Intel Corp. Integrated Rate Matching Hub
   Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
   
   Assurez-vous que votre système a bien détecter le programmeur identifié par STMicroelectronics ST-LINK/V2

Branchement de la carte blue pill

Le programmeur viens avec un petit cable à 4 fils. Les connections sont bien identifiées sur le programmeur et sur le connecteur à 4 broches qui dépassent au bout de la carte blue pill.

Maintenant on va essayer l'utilitaire st-info avec l'option --probe qui devrait nous afficher les informations sur le programmeur et la µC qui y est branché.

Nous avons donc complété la première étape de cette série d'articles dans le prochain article nous allons voir comment programmer la blue pillà partir de l'environnement Arduino IDE.

Ce projet est une suite logique des projets comme PICvision et PICvision portable. Il s'agit d'un petit ordinateur dans le style 1978, pensez à Apple II ou TRS-80 modèle I. Le montage électronique est réalisé avec seulement 3 composants actifs, le MCU PIC24EP512MC202, la mémoire SPI RAM 23LC512 et le régulateur de tension 3,3Volt. Le montage est réalisé sur une carte à pastilles passantes (sur les 2 faces).

Puisque ce projet a sa propre page WEB je ne ferai ici qu'une brève présentation.

Caractéristiques

• Processeur: MCU PIC24EP512MC202. Il s'agit d'un MCU 16 bits avec 512Ko de mémoire flash et 48Ko de mémoire RAM.
• Video: Sortie vidéo NTSC 16 tons de gris.
  • Mode texte: 21 lignes de 40 caractères.
  • Mode graphique: 240x170 pixels 16 tons de gris
• Son: Sortie tonalité simple (onde carré).
• périphériques utilisateur: Clavier PS/2 et joystick Atari 2600
• Stockage: Carte SD format en FAT/FAT32.
• Shell: Shell de commandes dans le style MS-DOS avec des commandes comme dir, del, ren,etc.
• Programmation: BASIC inspiré de QBASIC. Il s'agit d'un compilateur BASIC entier 16 bits procédural. Pas de numéro de lignes ni de GOTO et GOSUB, je voulais quelque chose de plus moderne. Ce BASIC peut-être utilisé en interactif à la manière de Python, mais il y a aussi un éditeur de texte pour écrire des programmes et les sauvegardés dans un fichier.
• RAM: La mémoire RAM disponible pour les programmes BASIC est de 20512 octets. La SPI RAM peut-aussi être utilisée pour conserver des données temporaires.

Vidéo de présentation

présentation du boitier. Réalisé en contre-plaqué de merisier 3mm.

Présentation du shell de commande. Exécution de quelques commandes, de quelques petits démo en BASIC et finalement écriture d'une fonction factiorielle utilisant la résursivité.

État du projet

L'ordinateur est utilisable dans l'état actuel du code. Lorsque je tombe sur un bogue je le corrige rapidement. La documentation n'est pas tout à fait complétée. Je dois encore écrire des exemples pour le BASIC.

Liens

• dépot github du projet.
• Page WEB du projet.

Boite à musique

Une boite à musique réalisée avec un µC PIC10F202 et quelques composants.

Description

Le PIC10F202 est le plus simple et limité des µC. Comme périphérique il ne possède qu'une minuterie de 8 bits. Donc presque tout doit-être fait en logiciel. La minuterie est utilisée pour contrôler la fréquence de la note. La durée de la note ainsi que la durée du soutenu de la note sont contrôlées par des compteurs logiciels de 24 bits avec une résolution de 8µSec.

Le PIC10F202 possède seulement 512 octets de mémoire flash. De plus les appels de sous-routines sont limités aux adresse 0 à 255 (page 0). Cette limitation impose 2 contraintes au projet. La première est que toutes les tables de données doivent-être situées entre les adresses 0 et 255. Les entrées de sous-routines doivent aussi être situées dans l'espace d'adressage entre 0 et 255. Ce qui m'a obligé à utiliser un artifice pour placer les sous-routines après l'adresse 255. L'instruction GOTO est là seule qui permet de couvrir les 512 mots d'adressage. Donc je place les entrées de sous-routines dans la page 0 mais ces entrées ne contiennent qu'un GOTO vers le vrai code de la sous-routine qui est après l'adresse 256 (page 1). Ceci permet de conserver l'espace de la page 0 pour les tables de données.

Considérant la mémoire flash limitée du PIC10F202, il n'y a que 4 mélodies d'enregistrées. Celle-ci sont jouées une après l'autre en boucle à chaque pression du bouton SW2. Après chaque mélodie le µC entre en mode SLEEP et ne se réveille que lorsqu'on pèse sur le bouton SW2 pour jouer la mélodie suivante.

En mode SLEEP le PIC10F202 consomme moins de 1µA de sorte que le commutateur d'alimentation SW1 est facultatif.

Circuit

La sortie GP0 est utilisée pour la tonalité. Ce signal audio est envoyé au collecteur du transistor Q1 qui fonctionne comme un amplificateur en base commune avec la sortie sur l'émetteur qui alimente un petit haut-parleur de 135 ohm. Le gain est contrôlé par la polarisation de la base qui dépend du voltage aux bornes du condensateur C2. Donc en faisant varier ce voltage on fait varier l'amplitude du signal audio.

Au début de la note la sortie GP1 est mise à Vdd pour charger C2à travers R3. Lorsque le délais de soutenance de la note est expiré. la sortie GP1 est mise en haute impédance et cesse donc de garder la charge sur C2. Donc le condensateur commence à se décharger à travers R4 et la base de Q1. Le gain du transistor diminue en même temps que le voltage aux bornes de C2 et ainsi le signal audio. On a donc un signal audio qui monte et descend progressivement plutôt que de débuter et terminer brutalement ce qui est plus plaisant pour l'oreille.

La LED sur GP2 suis le signal sur GP1 elle s'allume donc au rythme de la musique.

Le bouton SW2 permet de faire jouer la mélodie suivante.

Sur cette capture d'écran de l'oscilloscope on aperçoit en bleu la forme du voltage sur C2 et en jaune le voltage aux bornes du haut-parleur.

Table de mélodie

Les macros suivantes aide à créer les tables de mélodies.

• MELODY nom, cré l'entête de la table avec le nom de la mélodie comme point d'entré. nom doit être un nom d'étiquette valide pour l'assembleur.
• NOTE n, d, ajoute une note à la table n est le nom de la notes tel que défini dans les EQU qui associent un nom symbolique à chaque note de la gamme. d est la durée de la note tel que définie dans les EQU qui associent les durées à un nom symbolique
• PMODE m, détermine le mode phrasé des notes qui suivent. Le phrasé musical demeure constant tant qu'il n'est pas remplacé par un autre. Il y a 3 phrasé. PHRASE_NORMAL, PHRASE_STACCATO et PHRASE_LEGATO. Ce paramètre détermine la portion de la note qui est soutenue. Ce paramètre peut apparaître plusieurs fois dans la même mélodie. STACCATO correspond aux notes pointées. LEGATO corresponds aux notes reliées par un arc de cercle.
• MELODY_END, indique la fin de la mélodie.

code source

L'ensemble du projet est disponible ici

; NOM: music_box.asm ; DESCRIPTION: une boite à musique basée sur le PIC10F202 ;AUTEUR: Jacqes Deschênes ;DATE: 2018-11-29 ;REF: gamme tempérée: http://davbucci.chez-alice.fr/index.php?argument=musica/scala/scala.inc ;REF: happy birthday: http://en.wikipedia.org/wiki/File:GoodMorningToAll.svg #include p10f202.inc __config _WDTE_OFF & _MCLRE_OFF ;;;;;;;;;;;; constantes ;;;;;;;;;; radix dec ;durées notes WHOLE_NOTE EQU 0 HALF_NOTE EQU 1 QUARTER_NOTE EQU 2 HEIGTH_NOTE EQU 3 SIXTEENTH EQU 4 PAUSE_BIT EQU 7 ; indicateur booléen pour phase soutenue de la note F_SUSTAIN EQU 0 ; position du bit dans flags ; sélection du phrasé PHRASE_NORMAL EQU 0 ; note soutenu au 3/4 de la durée PHRASE_STACCATO EQU 1; note soutenu 1/2 de la durée PHRASE_LEGATO EQU 2 ; les notes sont attachées PHRASE_MASK EQU 0xC0 ; utilisé dans le décodage de la mélodie ;;;;;;;;;;;; macros ;;;;;;;;;;;;;; #define AUDIO_P GP0 #define AUDIO GPIO, AUDIO_P #define ENV_P GP1 #define ENV GPIO, ENV_P #define LED_P GP2 #define LED GPIO, LED_P #define BTN_P GP3 #define BTN GPIO, BTN_P ; met la broche ENV_P en mode entreée haute impédance ; la broche AUDIO_P demeure en mode sortie disable_env macro movlw ~(1<<audio_p tris gpio endm met la broche audio au niveau audio_hi macro bsf audio_lo bcf les broches audio_p et env_p en mode sortie enable_audio movlw led env haute imp entr instructions disable_audio d demi-cycle pour g une note delay_half_cycle movfw tmr0 skpz goto aider l table de m param nom selon plus bas duree retlw modification du phras peut- ins n o dans p est des valeur suivante> phrasé normal ; 1 -> phrasé staccato ; 2-> phrasé légato PMODE macro p retlw (0xC+(p&3))<<4 endm ; instructions entête d'une mélodie MELODY macro nom nom movfw note_idx addwf PCL,F endm ; fin de la mélodie MELODY_END macro retlw H'FF' endm ;;;;;;;;;;;; variables ;;;;;;;;;;;; udata duration_cntr res 3 ; compteur pour délais durée notes sustain_cntr res 3 ; durée maintenue de la note freq_dly res 1 ; délais demi-cycle pour produire la fréquence x phrase_mode res 1 ; mode du phrasé {PHRASE_NORMAL,PHRASE_STACCATO,PHRASE_LEGATO} note_idx res 1 ; index de la note dans la table melody flags res 1 ; indicateurs booléens play res 1; quel mélodie est jouée, index dans table play_list temp res 2 ; registres de travail temporaire ; accumulateur 24 bits accL res 1 ; bits 0-7 accH res 1 ; bits 8-15 accU res 1 ; bit 16-23 rst_vector org 0 clrf OSCCAL nop goto init ; lien indirect aux sous-routine situées après 0xff query_timeout goto query_timeout_upper calc_sustain goto calc_sustain_upper decay goto decay_upper play_note goto play_note_upper ; nom des notes DO4 EQU .0 DO4D EQU .1 RE4B EQU .1 RE4 EQU .2 RE4D EQU .3 MI4B EQU .3 MI4 EQU .4 FA4 EQU .5 FA4D EQU .6 SOL4B EQU .6 SOL4 EQU .7 SOL4D EQU .8 LA4B EQU .8 LA4 EQU .9 LA4D EQU .10 SI4B EQU .10 SI4 EQU .11 DO5 EQU .12 DO5D EQU .13 RE5B EQU .13 RE5 EQU .14 PAUSE EQU .15 scale ; table des notes échelle tempérée addwf PCL, F dt .239 ;do4 dt .225 ;do#4 dt .212 ;ré4 dt .201 ;ré#4 dt .189 ;mi4 dt .179 ;fa4 dt .169 ;fa#4 dt .159 ;sol4 dt .150 ;sol#4 dt .142 ;la4 dt .134 ;la#4 dt .126 ;si4 dt .119 ;do5 dt .112 ;do#5 dt .106 ;ré5 dt H'FE' ; pause ; durée des notes WHOLE EQU .0 WHOLE_DOT EQU .1 HALF EQU .2 HALF_DOT EQU .3 QUARTER EQU .4 QUARTER_DOT EQU .5 HEIGTH EQU .6 HEIGTH_DOT EQU .7 SIXTHEENTH EQU .8 SIXTHEENTH_DOT EQU .9 ; modification du prhasé NORMAL EQU .12 STACCATO EQU .13 LEGATO EQU .14 duration ; table des durées en multiple de 8 microsecondes ; tempo 120 noires (QUARTER_NOTE) / minutes ; pour varier le tempo il faut recalculer les valeurs de ; cette table v= durée_note/8e-6 addwf PCL, F dt low .250000, high .250000, upper .250000 ; WHOLE_NOTE dt low .375000, high .375000, upper .375000; WHOLE_NOTE. dt low .125000, high .125000, upper .125000 ; HALF_NOTE dt low .187500, high .187500, upper .187500 ; HALF_NOTE. dt low .62500, high .62500, 0 ; QUARTER_NOTE dt low .93750, high .93750, upper .93750 ; QUARTER_NOTE. dt low .31250, high .31250,0 ; HIEGTH_NOTE dt low .46875, high .46875, 0 ; HEIGTH_NOTE. dt low .15625, high .15625, 0 ; SIXTHEENTH_NOTE. dt low .23437, high .23437, 0 ; SXTHEENTH_NOTE. play_list addwf PCL,F goto bon_tabac goto ode_joie goto beau_sapin goto claire_fontaine goto reset_list ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ajout des tables de mélodies ici ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; J'ai du bon tabac dans ma tabatière MELODY bon_tabac NOTE SOL4,QUARTER NOTE LA4,QUARTER NOTE SI4,QUARTER NOTE SOL4,QUARTER NOTE LA4, HALF NOTE LA4, QUARTER NOTE SI4, QUARTER NOTE DO5, HALF NOTE DO5, HALF NOTE SI4, HALF NOTE SI4, HALF NOTE SOL4, QUARTER NOTE LA4, QUARTER NOTE SI4, QUARTER NOTE SOL4, QUARTER NOTE LA4, HALF NOTE LA4, QUARTER NOTE SI4, QUARTER NOTE DO5, HALF NOTE RE5, HALF NOTE SOL4, WHOLE NOTE RE5, HALF NOTE RE5, QUARTER NOTE DO5, QUARTER NOTE SI4,HALF NOTE LA4,QUARTER NOTE SI4,QUARTER NOTE DO5, HALF NOTE RE5, HALF NOTE LA4, WHOLE MELODY_END ; joyeux aniversaire ; MELODY joyeux_anniv ; NOTE DO4,HEIGTH_DOT ; NOTE DO4,SIXTEENTH ; NOTE RE4,QUARTER ; NOTE DO4,QUARTER ; NOTE FA4,QUARTER ; NOTE MI4,HALF ; NOTE DO4,HEIGTH_DOT ; NOTE DO4,SIXTEENTH ; NOTE RE4,QUARTER ; NOTE DO4,QUARTER ; NOTE SOL4,QUARTER ; NOTE FA4,HALF ; NOTE DO4,HEIGTH_DOT ; NOTE DO4,SIXTEENTH ; NOTE DO5,QUARTER ; NOTE LA4,QUARTER ; NOTE FA4,QUARTER ; NOTE MI4,QUARTER ; NOTE RE4,QUARTER ; NOTE SI4B,HEIGTH_DOT ; NOTE SI4B,SIXTEENTH ; NOTE LA4,QUARTER ; NOTE FA4,QUARTER ; NOTE SOL4,QUARTER ; NOTE FA4,HALF ; MELODY_END ; ; ode à la joie de Beethoven MELODY ode_joie NOTE LA4,QUARTER NOTE LA4,QUARTER NOTE SI4B,QUARTER NOTE DO5, QUARTER NOTE DO5, QUARTER NOTE SI4B, QUARTER NOTE LA4, QUARTER NOTE SOL4, QUARTER NOTE FA4, QUARTER NOTE FA4, QUARTER NOTE SOL4, QUARTER NOTE LA4, QUARTER NOTE LA4, QUARTER_DOT NOTE SOL4, HEIGTH NOTE SOL4, HALF NOTE LA4, QUARTER NOTE LA4, QUARTER NOTE SI4B, QUARTER NOTE DO5,QUARTER NOTE DO5,QUARTER NOTE SI4B,QUARTER NOTE LA4,QUARTER NOTE SOL4,QUARTER NOTE FA4,QUARTER NOTE FA4,QUARTER NOTE SOL4,QUARTER NOTE LA4,QUARTER NOTE SOL4,QUARTER_DOT NOTE FA4,HEIGTH NOTE FA4,HALF NOTE SOL4,QUARTER NOTE SOL4,QUARTER NOTE LA4,QUARTER NOTE FA4,QUARTER NOTE SOL4,QUARTER NOTE LA4,HEIGTH NOTE SI4B,HEIGTH NOTE LA4,QUARTER NOTE FA4,QUARTER NOTE SOL4,QUARTER NOTE LA4,HEIGTH NOTE SI4B,HEIGTH NOTE LA4,QUARTER NOTE SOL4,QUARTER NOTE FA4,QUARTER NOTE SOL4,QUARTER NOTE DO4,HALF NOTE LA4,QUARTER NOTE LA4,QUARTER NOTE SI4B,QUARTER NOTE DO5, QUARTER NOTE DO5, QUARTER NOTE SI4B, QUARTER NOTE LA4, QUARTER NOTE SOL4, QUARTER NOTE FA4, QUARTER NOTE FA4, QUARTER NOTE SOL4, QUARTER NOTE LA4, QUARTER NOTE SOL4, QUARTER_DOT NOTE FA4, HEIGTH NOTE FA4, HALF MELODY_END ; mon beau sapin MELODY beau_sapin NOTE DO4,QUARTER NOTE FA4,HEIGTH_DOT NOTE FA4, SIXTEENTH NOTE FA4, QUARTER NOTE SOL4, QUARTER NOTE LA4, HEIGTH_DOT NOTE LA4,SIXTEENTH NOTE LA4,QUARTER_DOT NOTE LA4,HEIGTH NOTE SOL4,HEIGTH NOTE LA4,HEIGTH NOTE SI4B,QUARTER NOTE MI4,QUARTER NOTE SOL4,QUARTER NOTE FA4,QUARTER NOTE .15,HEIGTH NOTE DO5,HEIGTH NOTE DO5,HEIGTH NOTE LA4,HEIGTH NOTE RE5,QUARTER_DOT NOTE DO5,QUARTER NOTE DO5,QUARTER NOTE SI4B,HEIGTH NOTE SI4B,QUARTER_DOT NOTE SI4B,HEIGTH NOTE SI4B,HEIGTH NOTE SOL4,HEIGTH NOTE DO5,QUARTER_DOT NOTE SI4B,HEIGTH NOTE SI4B,HEIGTH NOTE LA4, HEIGTH NOTE LA4, QUARTER NOTE DO4, QUARTER NOTE FA4,HEIGTH_DOT NOTE FA4,SIXTEENTH NOTE FA4,QUARTER NOTE SOL4,QUARTER NOTE LA4,HEIGTH_DOT NOTE LA4,SIXTEENTH NOTE LA4,QUARTER_DOT NOTE LA4,HEIGTH NOTE SOL4,HEIGTH NOTE LA4,HEIGTH NOTE SI4B,QUARTER NOTE MI4,QUARTER NOTE SOL4,QUARTER NOTE FA4,HALF MELODY_END MELODY claire_fontaine NOTE SOL4,HALF NOTE SOL4,QUARTER NOTE SI4,QUARTER NOTE SI4,QUARTER NOTE LA4,QUARTER NOTE SI4,QUARTER NOTE SOL4,QUARTER NOTE SOL4,HALF NOTE SOL4,QUARTER NOTE SI4,QUARTER NOTE SI4,QUARTER NOTE LA4,QUARTER NOTE SI4,HALF NOTE SI4,HALF NOTE SI4,QUARTER NOTE LA4,QUARTER NOTE SOL4,QUARTER NOTE SI4,QUARTER NOTE RE5,QUARTER NOTE SI4,QUARTER NOTE RE5,HALF NOTE RE5,QUARTER NOTE SI4,QUARTER NOTE SOL4,QUARTER NOTE SI4,QUARTER NOTE LA4,HALF NOTE SOL4,HALF NOTE SOL4,QUARTER NOTE SI4,QUARTER NOTE SI4,QUARTER NOTE LA4,HEIGTH NOTE SOL4,HEIGTH NOTE SI4,QUARTER NOTE SOL4,QUARTER NOTE SI4, HALF NOTE SI4,QUARTER NOTE LA4,HEIGTH NOTE SOL4,HEIGTH NOTE SI4,QUARTER NOTE LA4,QUARTER NOTE SOL4,HALF MELODY_END org 0x100 init ; timer clk=Fosc/4, diviseur=4 ; fréquence timer=250Khz movlw ~((1<<t0cs option clrf phrase_mode btfsc status gpwuf goto main reset_list play comf incf note_idx main01 movfw call play_list xorlw h marque la fin de m skpnz main02 movwf temp movlw andwf skpz main03 phras swapf andlw cours d entre les notes tmr0 play_note f .4 br pause whole_dot sleep termin met le mcu en mode pour pile. duration_cntr sortie carry="=0" si timeout query_timeout_upper freq_dly subwf skpnc retlw initialise variable sustain_cntr fonction du calc_sustain_upper case_normal phrase_staccato case_staccato case_legato note soutenue sur sa dur compl set_flag soutenu moiti clrc rrf est accu acch addwf bsf flags f_sustain lorsque env_p haute imp decay_upper btfss disable_env instructions bcf play_note_upper joue une dans w bits index table low nibble ne garde que c multiplication par rlf duration octet faible interm fort enable_audio xorwf play_note01 disable_audio calc_sustain scale multiple play_note02 audio_hi decay delay_half_cycle audio_lo query_timeout skpc end></t0cs></audio_p>

Music from the web

PIC12F1572

schématique

schématique

réalisation

sculpture complétée

vidéo

lien

source du projet. Comme il s'agissait d'une soumission pour un site anglophone le readme.md est en anglais.

Battement cardiaque

Il est simple de produire avec un µC un effet de battement cardiaque avec une DEL. Il suffit d'utiliser un périphérique PWM pour générer une fréquence entre 100 et 200Hertz et de modifier le rapport cyclique de 0% à 100% progressivement pour ensuite redescendre vers 0% et ceci en boucle. Le rythme cardiaque étant déterminé par la vitesse à laquelle le rapport cyclique est modifié. On peut aussi faire ça sur un PIC10F200 qui n'a pas de PWM par simulation logicielle, c'est pas trop compliqué.

Minuterie 555

La minuterie 555 est un petit circuit intégré qui a été mis en marché en 1971 et qui est toujours d'actualité. Rares sont les C.I. de cette époque qui ont survécus jusqu'à aujourd'hui. Le 555 est un des plus grand succès commercial de l'histoire de l'électronique. Aujourd'hui il existe des versions CMOS qui peuvent fonctionner jusqu'à 2 Mégahertz comme c'est le cas du TLC555 que j'ai utilisé pour ce projet.

Il s'agit simplement d'une démonstration de l'effet heart beat réalisé sans µC. Il faut 2 TLC555 par contre.

schématique

Comment ça marche

On a 2 oscillateurs qui produisent une onde carrée sur leur sortie à la broche 3. 2 DELs sont branchées entre les sorties des 2 oscillateurs. D1 allume lorsque la sortie de U2 est à Vdd et celle de U1à zéro volt. Pour D2 c'est l'inverse qui est vrai.

Imaginez que les 2 oscillateurs fonctionnent exactement à la même fréquence. Si les 2 sorties sont en phase les DELs seront toujours éteintes. Par contre si elles sont en opposition de phase les DELs allumeront en alternance.

Mais que ce passe-t'il si on ajuste RV1 pour que la fréquence de U2 soit légèrement différente de celle de U1? Leur cycle de se suivent plus. Il y a un décalage progressif entre les 2 ondes. La portion de cycle ou les 2 signaux sont en opposition de phase varie continuellement. Donc le temps que les 2 DELs allument est une fraction totale du cycle comme s'il s'agissait d'un PWM dont on fait varier le rapport-cyclique.

La fréquence des oscillateurs étant réglée à environ 300 hertz, notre œil ne perçoit pas le clignotement qui est trop rapide. Il intègre plutôt la luminosité comme une intensité moyenne et cette moyenne varie à la fréquence de

Fhb=|Fosc1-Fosc2|


Fhb fréquence de battement des DELs.
Fos1 fréquence générée par U1
Fos2 fréquence générée par U2

Dans le vidéo suivant je manipule RV1 pour modifier la fréquence de U2 et on peut constater l'influence sur le rythme cardiaque.

sculpture

Un coup parti pourquoi se gêner. Comme vous l'avez constater dans le vidéo j'ai fabriquer une petite sculpture avec ce projet pour la soumettre au concours de sculpture électronique de hackaday.

Le montage est effectué sur le lamelle de microscope.

Lien

Pour voir d'autre photos de cette sculpture suivez ce lien.

Ayant reçu un avis de Google selon lequel blogger sera terminé à partir du 1ier avril et que dans les mois suivants les sites seront supprimés. j'ai pris la décision de transférer ce blogue sur wordpress. Mon nouveau blogue peut-être atteint via l'url. http://www.picatout.ca

J'ai exporté tous les articles sur le nouveau blogue. Malheureusement la mise à forme n'est pas idéale. Curieusement le blog de wordpress ne reconnaît pas la balise <text-area> qui est pourtant une balise standard. Donc tous mes articles qui contiennent cette balise on un rendue non formaté du texte inclus a l'intérieur de cette balise. j'ai commencé à faire les corrections mais il y a plus de 200 articles à réviser...

Me voilà de retour avec l'automne, contrairement aux outardes qui disparaissent à l'automne pour revenir au printemps. On peut constater que malgré ce que Google nous avait annoncé en début d'année, blogger n'a pas été sacrifié. J'avais fait un transfert vers Wordpress mais je n'aimes pas ce site et puisque blogger est toujours actif cet automne je vais poursuivre ici.

Depuis que j'ai créé ce blogue en 2012, mes méthodes et outils de travail ont évolués. Maintenant je travaille sous Ubuntu et j'utilise Github et je me sert des fichiers markdown de github pour la documentation. Donc sur ce blogue je ne fais qu'une brève présentation et puis sur Github vous trouverez tout le code et la documentation. Pour chaque projet le fichier readme.md donne les détails. Parfois un projet comprends plusieurs dossiers avec un readme.md dans chacun. En plus il y a habituellement un dossier nommé docs qui contient des documents variés. Ainsi si vous clonez un dépôt sur votre ordinateur toute la documentation suit.

Aujourd'hui j'ai commandé une carte NUCLEO-8S208RB. Cette carte est abordable, ne nécessite aucun programmeur/débogueur externe, peut-être utilisée avec l'interface de programmation Arduino ou programmée en C en utilisant le compilateur SDCC. Le coeur est un STM8 descendant du classique CPU 6502. Ce sera donc le sujet de ma prochaine chronique.

Cet article est le premier consacré à la carte de développement NUCLEO-8S208RB de STMicroelectronics. Je travaille sur système d'exploitation Ubuntu en utilisant le compilateur et l'assembleur SDCC¹. De plus pour programmer la carte il faut utiliser stm8flash.

J'ai découvert l’existence d'un livre en anglais sur google book qui explique comment développer pour les microcontrôleurs STM8 sur Ubuntu². Le livre n'est pas visible au complet dans google book mais seulement le début qui décrit l'installation de SDCC et stm8flash.

Je vais commencer par décrire brièvement comment installer SDCC³ et stm8flash. Pour l'éditeur de texte je vous laisse choisir selon vos préférences. Un simple éditeur comme geany peut aussi bien faire l'affaire, c'est même préférable si vous êtes un débutant et que vous ne voulez pas avoir à apprivoiser les environnement plus complexes comme vscode ou code:blocks.

Installation des outils de développement

Je présume que vous avez déjà une connaissance d'Ubuntu et de l'utilisation de son gestionnaire de paquets en ligne de commandes. Pour installer SDCC rien de plus simple puisque le paquet est disponible dans le dépôt standard d'Ubuntu.

 sudo apt update && sudo apt install sdcc

Pour stm8flash c'est un plus compliqué car il faut construire le logiciel à partir des sources disponible sur github. Normalement le logiciel git est installé avec Unbutu. S'il n'est pas sur votre ordinateur faites simplement la commande:

 sudo apt install git

 git clone https://github.com/vdudouyt/stm8flash

jacques@HP8200:~/github/stm8flash$ make
cc -g -O0 --std=gnu99 --pedantic -Wall `pkg-config --cflags libusb-1.0`    -c -o stlink.o stlink.c
stlink.c: In function ‘stlink_read_and_cmp’:
stlink.c:62:6: warning: unused variable ‘recv’ [-Wunused-variable]
  int recv = stlink_read(pgm, buf, count);
      ^~~~
stlink.c: In function ‘stlink_swim_write_block’:
stlink.c:484:7: warning: unused variable ‘r’ [-Wunused-variable]
   int r = libusb_bulk_transfer(pgm->dev_handle,
       ^
cc -g -O0 --std=gnu99 --pedantic -Wall `pkg-config --cflags libusb-1.0` 
stlink.o stlinkv2.o espstlink.o main.o byte_utils.o ihex.o srec.o stm8.o 
libespstlink.o `pkg-config --libs libusb-1.0` -o stm8flash
jacques@HP8200:~/github/stm8flash$ ls stm8flash -l
-rwxr-xr-x 1 jacques jacques 104456 oct 19 11:11 stm8flash

 cp stm8flash ~/bin

 sudo apt install libusb-1.0-0-dev

Si tout ça a bien fonctionné on est maintenant prêt à ouvrir l'éditeur de texte et à écrire du code avant de compiler et de flasher le binaire dans la carte nucleo.

Le projet

Comme j'aime écrire en assembleur j'ai décidé de présenter un projet en assembleur. J'ai eu de la misère à trouver la documentation de l'assembleur sdas qui est fait parti de SDCC. Il semble que l'intérêt pour cet assembleur soit limité la plupart construisent leur projets en C. Je vais documenté tous les détails du fichier source en particulier les directives. Pour les mnémoniques d'instructions c'est déjà disponible dans le manuel de programmation des STM8. Il s'agit du manuel PM0044.

MONA

Il s'agit d'un MONiteur écrit en Assembleur. Il est utilisé avec un terminal sur le PC qui communique avec la carte via le UART3 du microcontrôleur. Ce moniteur permet de lire ou d'écrire n'importe où dans la mémoire du STM8S208, RAM, FLASH, EEPROM, OPTION, SFR. Il permet d'interagir avec la carte directement et d'observer le comportement résultant.

Au démarrage le programme affiche son nom ainsi que la version. Le modèle du microcontrôleur et les différentes régions mémoire. MONA protège contre l'écriture la région de mémoire flash qu'il utilise ainsi que la région RAM de 0x0000 - 0x00AE qui contient les variables qu'il utilise.

Voici une capture d'écran qui montre l'exécution de quelque commandes.

• h $4000 est utilisée pour affichier le contenu des adresses $4000-$4007. Chaque fois qu'on presse la barre d'espacement les 8 adresses suivantes sont affichées. N'importe quel autre touche termine la commande. Cette plage d'adresses est située au début de l'EEPROM.
• ! $4000 1 2 3 4 5 6 7 8écris 8 valeurs dans l'EEPROM à partir de l'adresse $4000. Puisque ces valeurs sont inscrites dans l'EEPROM elles vont rester là même après un redémarrage du MCU.
• h $4000 Nous permet de vérifier que les valeurs ont bien étées inscrites.
• les commandes t $500a et t $500e n'ont aucun effet car je n'ai pas fournis le bitmask des bits à inverser.
• t $500a 32 cette commande bascule la valeur du bit 5 à l'adresse $500a qui est le registre PC_ODR. La LED2 de la carte est branchée sur ce bit. Donc en faisant cette commande l'état de la LED2 change.
• t $500a 32 En enfonçant la combinaison de touche CTRL-R on réaffiche la dernière commande. Dans ce cas çi ça permet d'éteindre et d'allumer la LED2 en alternance en faisant uen série de CTRL-RENTER.
• t $500a $20 C'est la même commande sauf que j'ai indiqué la valeur de masque en hexadécimal. Plusieurs bits peuvent être inversés en même temps. Par exemple pour inverser les 8 bits il suffit de faire t addr 255.

Mes projets pour la carte nucleo-8s208rb sont dans un dépôt github. Pour cloner ce dépôt sur votre ordinateur, dans un répertoire de votre choix, faites la commande:

git clone https://github.com/picatout/stm8_nucleo

git pull

Construire et flasher le programme

Chaque programme est dans un dossier séparé. Pour compiler un programme il faut se déplacer dans le dossier. Pour simplifier le tout j'ai créé un fichier Makefile. Voici une capture d'écran qui montre comment compiler et flasher mona sur la carte nucleo 8s208rb.

Analyse du code source de MONA

Dans les jours qui suivent je vais décrire le code source de MONA. Ça pourra servir de tutoriel pour l'écriture en assembleur de programme pour les MCU stm8. Je vais faire ce travail dans un fichier markdown MONA.md qu'il sera plus facile de lire sur le site web que dans un éditeur de texte.

NOTES

1. SDCC signifit Small Device C Compiler.
2. STM8 Microcontroller Development on Ubuntu. Livre numérique kindle à petit prix. Je recommande ce livre si vous lisez l'anglais. La dépense est minime.
3. Au moment de l'écriture de cet article la version de SDCC disponible dans le dépôt d'Unbuntu 18.04 est la version 3.8.0 alors que la version sur souceforge.net est la version 3.9.0. Pour installer la version 3.9.0. il faut construire l'application à partir des sources. La procédure est disponible ici (en anglais).