Microcontrôleur Arduino, minuteur (timer), assembleur et synchronisation de deux Arduinos
Cette page est un complément à ma série de vidéos youtube sur le microcontrôleur ATmega328P utilisé par l'Arduino UNO et l'Arduino Nano.
Elle n'est PAS destinée aux débutants, mais à des personnes ayant déjà des connaissances
dans la programmation en langage C dans l'IDE de Arduino.
C'est le programme Nano_TinyLev.ino de la
page Web de référence
qui m'a poussé à faire cette série de vidéos avec les informations associées dans cette page Web.
Je traiterai des sujets suivants :
En fin de page, je donne des liens sur mes vidéos youtube concernant les sujets indiqués ci-dessus.
Avant Je donne également tous les codes arduinos (.ino) et (.S) et des fichiers de dessins (.odg)
Comment voir le code Assembleur généré par l'IDE Arduino après compilation ?
Sous Linux, il faut en premier installer le programme : avr-objdump
Pour l'installer, taper dans un Terminal :
sudo apt install binutils-avr
Après avoir compilé un programme .ino dans l'IDE Arduino, aller dans :
Sketch > Export Compiled Binary Alt+Ctrl+S
Aller dans le sous-dossier : build/arduino.avr.uno
La commande suivante permet de voir le code assembleur généré.
avr-objdump -h -S -z ex5040_ASM_blink_pin13.ino.elf
Pour mettre le résultat dans un fichier .asm
avr-objdump -h -S -z ex5040_ASM_blink_pin13.ino.elf > ex5040_ASM_blink_pin13.asm
Sous windows :
D:\LocalData\user\Downloads\arduino-1.8.5\avr-objdump -S -z C:\Users\user\AppData\Local\Temp\arduino_build_956846/sketch_sep10a.ino.elf > D:\LocalData\user\Downloads\arduino-1.8.5\myskeych.asm
Lire le code assembleur généré par l'IDE de Arduino donne beaucoup d'informations.
J'étudie ce code dans une de mes vidéos youtube sur l'assembleur Arduino.
Voici une série de références, Web, .pdf, vidéos et livres sur l'assembleur avec l'IDE de Arduino :
°
Atmel AVR 8-bit Instruction Set
Toutes les instructions de l'Assembleur, bien présenté. Document de 152 pages.
Les pages : "Complete Instruction Set Summary" 11 à 14 sont très utiles.
C'est un document que
j'apprécie particulièrement.
°
AVR Instruction Set Manual
Un manuel identique au précédent donnant beaucoup d'explication sur la programmation en assembleur,
avec chaque instruction assembleur expliquée en détail.
C'est un manuel de 166 pages plus récent que le précédente,
mais je me suis habitué au précédent, dont je préfère la présentation,
bien que les deux présentations sont très similaires.
°
Inline Assembler Cookbook
( https://www.nongnu.org/avr-libc/user-manual/inline_asm.html )
Donne beaucoup d'information sur la programmation en Assembleur pour le microcontrôleur ATmega328P
(celui utilisé dans l'arduino UNO).
La page est vieille, mais reste intéressante.
Des vidéos youtube d'explication sur l'assembleur dans l'Arduino :
Un défaut de beaucoup de vidéos sur l'assembleur est qu'elles donnent des exemples académiques,
qui ne montrent pas l'intérêt et l'avantage de la programmation en assembleur.
°
Assembly via Arduino (part 1) - Introduction
Une playliste de vidéos youtube sur l'assembleur dans l'IDE de Arduino.
Très bien fait, j'ai appris beaucoup de choses en regarant certaines de ces vidéos.
Malheureusement, ses vidéos 12 et 13 sur les Timers (Minuteurs) sont peu utiles,
car elles n'utilisent pas l'avantage principal des Timers qui est de générer des interruptions.
Pour finir sur les références, voici deux livres qui m'ont été utiles :
°
Arduino Inline Assembly
C'est un livre au format ebook, qui est intéressant.
Malheureusement, il faut soit une liseuse Kindle,
soit un programme Windows pour lire ce livre, donc sous Linux,
j'ai été embêté pour le lire. J'ai du lancer dans virtualbox
comment synchroniser deux Arduinos, pour qu'ils aient exactement la même fréquence d'horloge
C'est dans ma vidéo Youtube : "arduino05_synchronisation_deux_arduinos.mp4" que je montre comment
synchroniser de façon hardware deux microcontrolleur ATmega328.
Dans la vidéo suivante : "arduino06_synchronisation_deux_arduinos_suite.mp4",
je montre comment synchroniser de façon hardware deux Arduinos.
Ensuite je montre plusieurs tentatives de synchroniser deux Arduinos
de manière logicielle (software).
C'est possible, mais pas entièrement satisfaisant.
Information et références supplémentaires
Plusieurs documents .pdf concernant les micro-contrôleur de Atmel
En particulier :
doc2559.pdf sur les convertisseurs ADC.
Un bon document expliquant la conversion ADC et comment l'accélérer
Voici tous mes codes arduino .ino et .S dans un fichier compressé .zip.
Voici diverses dessins à coller sur des C.I. dans un fichier compressé .zip.
Voici la liste des fichiers et un exemple de dessins pour l'ATmega328 :
0fichiers.txt
ATmega328_ATtiny_85_84_4313_2313.odg
ATmega328_ATtiny_85_84_4313_2313.pdf
ATmega328_et_autres.odg
code.zip
Dessins_CI_Ampli_OP.odg
Dessins_CI_Arduino_and_Display.odg
Dessins_CI.odg
Dessins_CI_suite.odg
dessins.zip
ex0440_2_signaux_40kHz_dephase_ASM_ISR.odg
ex0441_2_signaux_40kHz_dephase_ASM_ISR.odg
ex0441_2_signaux_40kHz_dephase_ASM_ISR_400_frames.odt
ex0444_2_signaux_frequ_variables_ASM_ISR.odg
ex0444_2_signaux_frequ_variables_ASM_ISR.odt
ex0426_Nanoscope_fr.ino
ex0426_Nanoscope.ino
ex0427_signal_40kHz.ino
ex0428a_Nano_Tiny_Lev_original.ino
ex0428b_Nano_Tiny_Lev_original.ino
ex0429_timer_2_interrupt_40kHz_pour_2_arduinos_synchrones.ino
ex0430a_timer_2_interrupt_40kHz_master_synchronise_fixe.ino
ex0430b_timer_2_interrupt_40kHz_master_println.ino
ex0430c_timer_2_interrupt_40kHz_master_synchronise_auto_fixe.ino
ex0430d_timer_2_interrupt_40kHz_master_synch_a_init.ino
ex0430e_timer_2_interrupt_40kHz_master_sync_a_init2.ino
ex0430f_timer_2_interrupt_40kHz_master_sync_ASM.ino
ex0430f_timer_2_interrupt_40kHz_master_sync_ASM.S
ex0430g_timer_2_interrupt_40kHz_master_sync.ino
ex0430h_timer_2_interrupt_40kHz_master_sync.ino
ex0430i_timer_2_interrupt_40kHz_master_sync_ASM.ino
ex0430i_timer_2_interrupt_40kHz_master_sync_ASM.S
ex0430_timer_2_interrupt_40kHz_slave.ino
ex0431b_timers_0_2_interrupt_40kHz_marche_PAS.ino
ex0431_timers_0_2_interrupt_40kHz_marche_PAS.ino
ex0432_timer_2_interrupt_40kHz_marche_PAS.ino
ex0433_2_signaux_40kHz_dephase.ino
ex0434_2_signaux_40kHz_dephase.ino
ex0435_2_signaux_40kHz_dephase.ino
ex0436_2_signaux_40kHz_dephase_ASM_inline.ino
ex0437_2_signaux_40kHz_dephase_ASM.ino
ex0437_2_signaux_40kHz_dephase_ASM.S
ex0438_2_signaux_40kHz_dephase_ASM.ino C'est le programme que je conseille.
ex0438_2_signaux_40kHz_dephase_ASM.S
ex0439_2_signaux_40kHz_dephase_56_frames_ASM.ino
ex0439_2_signaux_40kHz_dephase_56_frames_ASM.S
ex0440_2_signaux_40kHz_dephase_ASM_ISR_132_frames.ino
ex0440_2_signaux_40kHz_dephase_ASM_ISR_132_frames.S
ex0441_2_signaux_40kHz_dephase_ASM_ISR_400_frames.ino est étonnamment bien.
ex0441_2_signaux_40kHz_dephase_ASM_ISR_400_frames.S
ex0442_2_signaux_40kHz_dephase_ASM_ISR_400_frames.ino
ex0442_2_signaux_40kHz_dephase_ASM_ISR_400_frames.S
---
ex0444_2_signaux_frequ_variables_ASM_ISR.ino
ex0444_2_signaux_frequ_variables_ASM_ISR.S
ex0445_2_signaux_frequ_variables_ASM_ISR.ino
ex0445_2_signaux_frequ_variables_ASM_ISR.S
ex0446_2_signaux_frequ_variables_ASM_ISR_LCD_MEGA.ino
ex0446_2_signaux_frequ_variables_ASM_ISR_LCD_MEGA.S
ex0447_2_signaux_frequ_variables_ASM_ISR_LCD_MEGA_LOW.ino
ex0447_2_signaux_frequ_variables_ASM_ISR_LCD_MEGA_LOW.S
ex0448_2_signaux_frequ_variables_ASM_ISR_LCD_MEGA_LOW_FIN.ino
ex0448_2_signaux_frequ_variables_ASM_ISR_LCD_MEGA_LOW_FIN.S
ex0540_DigitalWrite_speed.ino
ex5010_ASM_blink_pin13.ino
ex5015_ASM_Signal_2MHz.ino
ex5020_ASM_blink_pin13.ino
ex5030_ASM_blink_pin13.ino
ex5030_ASM_blink_pin13.S
ex5040_ASM_blink_pin13.ino
ex5110_ASM_ISR_Interrupt_handler.ino
ex5110_ASM_ISR_Interrupt_handler.S
ex5115_ASM_ISR_Interrupt_handler_400kHz.ino
ex5115_ASM_ISR_Interrupt_handler_400kHz.S
ex5120_ASM_ISR_Interrupt_handler.ino
ex5130_ASM_ISR_Interrupt_handler.ino
ex5140_Main_Test_CLI.ino
ex5142_Main_programme_minimal.ino
ex5144_Main_PWM_8MHz.ino
Liens sur des vidéos youtube :
Lien sur la Playlist.
#01 Arduino et lévitation acoustique
1ère vidéo d’une suite consacrée à la génération de deux paires de signaux à 40 kHz.
Le but étant de générer les signaux nécessaire à faire de la LÉVITATION ACOUSTIQUE.
Je veux pouvoir déphaser ces deux paires de signaux.
Dans chaque paire, un signal est en opposition de phase avec l’autre.
La
page Web de référence
qui indique comment construire un appareil à lévitation acoustique
et qui met à disposition le programme Nano_TinyLev.ino
C’est ce programme qui m’a inspiré et a initié la suite des programmes que j’explique dans
cette suite de vidéos.
#02 Arduino, génération de deux paires de signaux de 40 kHz de phases fixes.
2ème vidéo d’une suite consacrée à la génération de deux paires de signaux à 40 kHz.
Dans cette vidéo, je montre comment générer simplement deux paires de signaux à 40 kHz
en utilisant des Minuteurs (Timers).
On ne peut pas déphaser une paire relativement à la suivante.
C'est pour pouvoir faire ce déphasage qu'il y a la suite des autres vidéos et programmes.
Programme associé : ex0427_signal_40kHz.ino
#03 Arduino, voir le code assembleur généré par l’IDE de Arduino.
3ème vidéo d’une suite consacrée à la génération de deux paires de signaux à 40 kHz.
Dans cette vidéo, j’explique comment voir le code assembleur généré par l’IDE de Arduino.
Ceci sera utile dans plusieurs programmes à venir.
J’explique ceci dans plusieurs autres vidéos et dans ma page Web associée à cette suite de vidéos.
Programme associé : ex0427_signal_40kHz.ino
#04 Arduino, utiliser deux Minuteurs (Timers) pour générer deux paires de signaux de 40 kHz
Dans cette vidéo, je montre une tentative de générer deux paires de signaux de 40 kHz pouvant être déphasés.
Ceci, en utilisant les deux Minuteurs (Timers) 0 et 2.
Le résultat est insatisfaisant, mais donne des idées pour faire mieux.
Programme associé : ex0431b_timers_0_2_interrupt_40kHz_marche_PAS.ino
#05 Arduino, synchronisation deux Arduinos ou microcontrôleurs ATmega328, façon hardware
Dans cette vidéo, je montre comment synchroniser deux microcontrôleurs ATmega328 de façon hardware.
De cette manière, les deux microcontrôleurs ont une fréquence d’horloge exactement identique.
C’est très simple à faire, ça fonctionne très bien, mais cela nécessite deux microcontrôleurs ATmega328.
Dans la vidéo suivante, je montre l’équivalent avec deux Arduinos à la place des microcontrôleurs.
Donc je montre comment synchroniser deux Arduinos de façon hardware.
Programme associé : ex0429_timer_2_interrupt_40kHz_pour_2_arduinos_synchrones.ino
#06 Arduino, synchronisation deux Arduinos, façon hardware
Cette vidéo fait suite à celle montrant comment synchroniser deux microcontrôleurs ATmega328 de façon hardware.
Dans cette vidéo suivante, je montre l’équivalent avec deux Arduinos à la place des ATmega328.
De cette manière, les deux Arduinos ont une fréquence d’horloge exactement identique.
C’est très simple à faire, ça fonctionne très bien, mais cela nécessite deux Arduinos.
Programme associé : ex0429_timer_2_interrupt_40kHz_pour_2_arduinos_synchrones.ino
C’est le même que celui servant à synchroniser les ATmega328.
#07 Arduino, synchronisation deux Arduinos, façon software
Cette vidéo est la première d’une suite de tentatives de synchroniser deux Arduinos de façon logiciel (software).
C’est plus compliqué que de façon hardware et il y a des limitations.
Ici, je montre uniquement le programme d’un des deux Arduinos, qui génère deux signaux qui seront utilisés par l’autre Arduino.
Programme associé : ex0430_timer_2_interrupt_40kHz_slave.ino
#08 Arduino, synchronisation deux Arduinos, façon software
Cette vidéo est la deuxième d’une suite de tentatives de synchroniser deux Arduinos de façon logiciel (software).
C’est plus compliqué que de façon hardware et il y a des limitations.
Ici, la synchronisation est assez simple et fonctionne très bien, mais il n’est pas possible de déphaser les deux paires de signaux.
Programme associé : ex0430a_timer_2_interrupt_40kHz_master_synchronise_fixe.ino
#09 Arduino, synchronisation deux Arduinos, façon software, println
Cette vidéo est la troisième d’une suite de tentatives de synchroniser deux Arduinos de façon logiciel (software).
C’est plus compliqué que de façon hardware et il y a des limitations.
Le but ici est juste d’afficher la différence de vitesse des deux Arduinos.
Programme associé : ex0430b_timer_2_interrupt_40kHz_master_println.ino
#10 Arduino, synchronisation deux Arduinos, façon software, déphasage par à-coup.
Cette vidéo est la quatrième d’une suite de tentatives de synchroniser deux Arduinos de façon logiciel (software).
C’est plus compliqué que de façon hardware et il y a des limitations.
Ici, la synchronisation est assez simple et fonctionne très bien, mais le déphaser se fait par à-coup d'un quart de période.
Programme associé : ex0430g_timer_2_interrupt_40kHz_master_sync.ino
#11 Arduino, synchronisation deux Arduinos, façon software, déphasage ok mais instable
Cette vidéo est la cinquième d’une suite de tentatives de synchroniser deux Arduinos de façon logiciel (software).
C’est plus compliqué que de façon hardware et il y a des limitations.
Ici, il est possible de déphaser une paire de signaux relativement à l’autre,
mais un léger déphasage se fait automatiquement, de manière indésirable.
Programme associé : ex0430d_timer_2_interrupt_40kHz_master_synch_a_init.ino
#12 Arduino, synchronisation deux Arduinos, façon software, en assembleur
Cette vidéo est la sixième d’une suite de tentatives de synchroniser deux Arduinos de façon logiciel (software).
C’est plus compliqué que de façon hardware et il y a des limitations.
Ici, il est possible de déphaser une paire de signaux relativement à l’autre.
Pour améliorer le programme précédent, trop de code doit être exécuté dans la routine de gestion d’interruption.
En conséquence, il faut l’écrire en assembleur pour optimiser le code.
Le programme écrit en langage C sert à voir (à l’aide du programme avr-objdump) le code assembleur généré par l’environnement Arduino.
Ensuite, ce code est repris pour écrire en assembleur la fonction de gestion d’interruption.
Programmes associés : ex0430e_timer_2_interrupt_40kHz_master_sync_a_init2.ino et
ex0430f_timer_2_interrupt_40kHz_master_sync_ASM.ino et
ex0430f_timer_2_interrupt_40kHz_master_sync_ASM.S
#13 Arduino, synchronisation deux Arduinos, façon software, en assembleur, amélioré
Cette vidéo est la septième et dernière d’une suite de tentatives de synchroniser deux Arduinos de façon logiciel (software).
C’est plus compliqué que de façon hardware et il y a des limitations.
Ici, il est possible de déphaser une paire de signaux relativement à l’autre.
Pour le développement en langage C, j’ai diminué la fréquence des signaux de 40 kHz à 5 kHz.
Ensuite, j’ai écrit le programme en assembleur.
Il fonctionne très bien, est stable et permet de déphaser un signal relativement à l’autre.
Programmes associés : ex0430h_timer_2_interrupt_40kHz_master_sync.ino et
ex0430i_timer_2_interrupt_40kHz_master_sync_ASM.ino et
ex0430i_timer_2_interrupt_40kHz_master_sync_ASM.S
#14 Arduino, génération de deux paires de signaux à 40 kHz, stables et pouvant être déphasés.
Cette vidéo est le début d’une autre approche de générer deux paires de signaux à 40 kHz, sables et pouvant être déphasés.
Il se base sur le programme Nano_TinyLev.ino de la page Web de référence :
https://www.instructables.com/Acoustic-Levitator/
expliquant comment construire une machine à lévitation acoustique.
Dans ma page Web :
"Lévitation acoustique, Transducteur et microcontroleur Arduino"
je donne des informations complémentaires pour faciliter la construction d’une machine à lévitation acoustique.
J’y ai également référencé quelques vidéos que j’ai faites sur ce sujet.
Ici, je commence par reprendre le programme Nano_TinyLev.ino, à l’expliquer et à l’améliorer.
Les vidéos qui suivent, donnent les différentes étapes que j’ai suivi pour améliorer ce programme.
Programmes associés : ex0428a_Nano_Tiny_Lev_original.ino et
ex0428b_Nano_Tiny_Lev_original.ino
#15 Arduino, génération de deux paires de signaux à 40 kHz, stables, déphasable, amélioration 1.
Cette vidéo est la deuxième de ma suite d’améliorations pour générer deux paires de signaux à 40 kHz,
sables et pouvant être déphasés.
Il se base sur le programme Nano_TinyLev.ino
de la page Web de référence :
https://www.instructables.com/Acoustic-Levitator/
expliquant comment construire une machine à lévitation acoustique.
Un gros tableau de 25 lignes de 24 colonnes est utilisé pour générer les signaux.
C’est déjà une modification du tableau similaire du programme de référence.
J’explique comment ce tableau est utilisé dans le programme.
Programme associé : ex0433_2_signaux_40kHz_dephase.ino
#16 Arduino, génération de deux paires de signaux à 40 kHz, stables, déphasable, amélioration 1 suite.
Cette vidéo est la troisième de ma suite d’améliorations pour générer deux paires de signaux à 40 kHz,
sables et pouvant être déphasés.
Il se base sur le programme Nano_TinyLev.ino
de la page Web de référence
https://www.instructables.com/Acoustic-Levitator/
expliquant comment construire une machine à lévitation acoustique.
Un gros tableau de 25 lignes de 24 colonnes est utilisé pour générer les signaux.
Dans la vidéo précédente, j’ai expliqué comment ce tableau est utilisé dans le programme.
Dans cette vidéo, j’explique le code du programme associé.
Programme associé : ex0433_2_signaux_40kHz_dephase.ino
#17 Arduino, génération de 2 paires de signaux à 40 kHz, stables, déphasable, amélioration 2.
Cette vidéo est la quatrième de ma suite d’améliorations pour générer deux paires de signaux à 40 kHz,
sables et pouvant être déphasés.
Il se base sur le programme ex0433_2_signaux_40kHz_dephase.ino expliqué dans la vidéo précédente.
Ce programme permet de générer plus de « Frames » que le programme précédent.
J’explique le tableau, qui est très similaire au précédent.
Programme associé : ex0434_2_signaux_40kHz_dephase.ino
#18 Arduino, génération de 2 paires de signaux à 40 kHz, stables, déphasable, simplifications.
Cette vidéo est la cinquième de ma suite d’améliorations pour générer deux paires de signaux à 40 kHz,
sables et pouvant être déphasés.
Il se base sur le programme ex0434_2_signaux_40kHz_dephase.ino expliqué dans la vidéo précédente.
Ce programme fait une grosse simplification, qui remplace le tableau de 41 lignes et 40 colonne par un tableau de 80 octets.
J’explique cette simplification et le code associé, qui n’est pas très différent de celui du programme précédent.
Programme associé : ex0435_2_signaux_40kHz_dephase.ino
#19 Arduino, génération de 2 paires de signaux à 40 kHz, stables, déphasable, assembleur inline
Cette vidéo est la sixième de ma suite d’améliorations pour générer deux paires de signaux à 40 kHz, sables et pouvant être déphasés.
Il se base sur le programme ex0435_2_signaux_40kHz_dephase.ino expliqué dans la vidéo précédente.
Je montre comment traduire le programme précédent en assembleur, pour mieux maîtriser la génération du code.
J’explique comment voir le code assembleur généré par l’IDE de Arduino, en utilisant le programme : avr-objdump
décrit en début de cette page Web.
Ici, on écrit du code assembleur « inline », c’est-à-dire qui se trouve à l’intérieur du code écrit en langage C.
Dans la vidéo suivante, j’étudierai le code généré par l’IDE de Arduino.
Ensuite, ce code assembleur sera écrit dans un fichier séparé et sera plus lisible.
Programme associé : ex0436_2_signaux_40kHz_dephase_ASM_inline.ino
#20 Arduino, génération de 2 paires de signaux à 40 kHz, stables, déphasable, assembleur inline, suite
Cette vidéo est la septième de ma suite d’améliorations pour générer deux paires de signaux à 40 kHz, sables et pouvant être déphasés.
Il se base sur le programme ex0435_2_signaux_40kHz_dephase.ino expliqué dans la vidéo précédente.
J’ai montré dans la vidéo précédente comment traduire le programme précédent en assembleur à l’aide du programme avr-objdump.
Dans cette vidéo, j’étudie le code généré par l’IDE de Arduino. Cela est utile pour écrire du code en assembleur.
Dans la vidéo suivante, ce code assembleur sera écrit dans un fichier séparé .S et sera plus lisible.
Programme associé : ex0436_2_signaux_40kHz_dephase_ASM_inline.ino
Le même que dans la vidéo précédente.
#21 Arduino, génération de 2 paires de signaux à 40 kHz, stables, déphasable, assembleur .S
Cette vidéo est la huitième de ma suite d’améliorations pour générer deux paires de signaux à 40 kHz, sables et pouvant être déphasés.
Il se base sur le programme ex0436_2_signaux_40kHz_dephase_ASM_inline.ino expliqué dans la vidéo précédente.
J’ai montré dans la vidéo précédente comment écrire du code assembleur « inline », à l’intérieur du code écrit en C.
Dans cette vidéo, ce code assembleur est écrit dans un fichier séparé .S et est plus lisible.
Cette écriture permettra de faire une nouvelle amélioration pour obtenir 50 « Frames » au lieu de 40.
Programmes associés : ex0437_2_signaux_40kHz_dephase_ASM.ino
ex0437_2_signaux_40kHz_dephase_ASM.S
#22 Arduino, génération de 2 paires de signaux à 40 kHz, stables, déphasable, assembleur .S amélioration
Cette vidéo est la neuvième de ma suite d’améliorations pour générer deux paires de signaux à 40 kHz, sables et pouvant être déphasés.
Il se base sur le programme ex0437_2_signaux_40kHz_dephase_ASM.ino expliqué dans la vidéo précédente.
Dans cette vidéo, le code assembleur est écrit dans un fichier séparé (.S), plus lisible.
Cette écriture permet de faire une nouvelle amélioration pour obtenir 50 « Frames » au lieu de 40.
Je considère le programme associé à cette vidéo comme étant le plus important de ceux que j’ai écrit dans cette évolution,
même si certaines programme qui suivent ont des approches intéressantes.
Programmes associés : ex0438_2_signaux_40kHz_dephase_ASM.ino
ex0438_2_signaux_40kHz_dephase_ASM.S
#23 Arduino, génération de 2 paires de signaux à 40 kHz, stables, déphasable, assembleur .S petite amélioration
Cette vidéo est la dixième de ma suite d’améliorations pour générer deux paires de signaux à 40 kHz, sables et pouvant être déphasés.
C’est une curiosité, sans importance, qui apporte une légère amélioration au programme précédent.
Il se base sur le programme ex0438_2_signaux_40kHz_dephase_ASM.ino expliqué dans la vidéo précédente.
Il passe de 50 « Frames » à 56 « Frames », c’est tout.
Au prix de générer les signaux à des fréquences de 40,0816 kHz au lieu de 40,000 kHz.
Programmes associés : ex0439_2_signaux_40kHz_dephase_56_frames_ASM.ino
ex0439_2_signaux_40kHz_dephase_56_frames_ASM.S
#24 Arduino, génération de deux paires de signaux à 40 kHz, autre approche
Dans cette vidéo, je présente une nouvelle approche pour générer deux paires de signaux à 40 kHz, stables, pouvant être déphasés.
Pour ce faire, le Minuteur (Timer) 2 de l’Arduino est utilisé.
Il est indispensable d’utiliser de l’assembleur (.S) pour contrôler précisément le temps d’exécution de diverses instructions.
Donc le Minuteur est utilisé dans la routine assembleur.
Cette approche permet d’avoir 132 « Frames », qui peut être considéré comme une nette amélioration.
Pour moi, cette « amélioration » est peu importante.
La complexité du code de ce programme est nettement plus grande que celle des programmes précédents.
Dans cette vidéo, j’explique l’idée de cette approche et le code assembleur du programme.
Dans la vidéo suivante, j’explique comment certains paramètres délicats ont été déterminés.
Programmes associés : ex0440_2_signaux_40kHz_dephase_ASM_ISR.ino
ex0440_2_signaux_40kHz_dephase_ASM_ISR.S
#25 Arduino, génération de deux paires de signaux à 40 kHz, autre approche, suite
Dans la vidéo précédente, je présente une nouvelle approche pour générer deux paires de signaux à 40 kHz, stables, pouvant être déphasés.
Cette vidéo est un complément expliquant comment certains paramètres délicats ont été déterminés.
Programmes associés : ex0440_2_signaux_40kHz_dephase_ASM_ISR.ino
ex0440_2_signaux_40kHz_dephase_ASM_ISR.S
Les même que ceux de la vidéo précédente.
Home
arduino_minuteur_assembleur_synchronisation.html
Mise à jour le 21 janvier 2025 par Libre Gisin.
