Auteur/autrice : ES

Installer Arduino 1.0.6 sous Debian 10

Les sites officiels : Arduino et Debian

Dans la console :

Si le répertoire Arduino n’existe pas déjà, je le crée :
sudo mkdir /usr/share/arduino

Je télécharge la version 64 bits (à adapter) :
cd Téléchargements
wget -c http://downloads.arduino.cc/arduino-1.0.6-linux64.tgz

Je décompresse l’archive et l’installe à l’endroit voulu :
tar -zxvf arduino-1.0.6-linux64.tgz
sudo mv arduino-1.0.6 /usr/share/arduino

Je télécharge l’icône Arduino et l’installe à l’endroit voulu :
wget http://entropie.org/3615/download/arduino.png
sudo mv arduino.png /usr/share/arduino

Pour effacer une version précédente d’Arduino (x à adapter) :
sudo rm -rf /usr/share/arduino/arduino-1.x.x

Pour intégrer le programme au menu de Xfce, je crée un fichier arduino-1.0.6.desktop dans le répertoire /usr/share/applications :
cd /usr/share/applications
sudo nano arduino-1.0.6.desktop

[Desktop Entry]
Type=Application
Name=Arduino 1.0.6
Comment=Un environnement de développement pour Arduino
GenericName=Create physical computing projects
Exec=/usr/share/arduino/arduino-1.0.6/arduino
Icon=/usr/share/arduino/arduino.png
Terminal=false
Categories=Development;Engineering;Electronics;
MimeType=text/x-arduino
Keywords=embedded electronics;electronics;avr;microcontroller;

Pour que le port série soit accessible et éviter de devoir utiliser Arduino en mode administrateur :
sudo usermod -a -G tty $USER ($USER à adapter)
sudo usermod -a -G dialout $USER ($USER à adapter)
Redémarrer.

Installer Arduino 1.8.15 sous Debian 10

Article mis à jour le 9 juillet 2021.

Les sites officiels : Arduino et Debian

Dans la console :

Je télécharge la version 64 bits (à adapter) :
cd Téléchargements
wget -c http://downloads.arduino.cc/arduino-1.8.15-linux64.tar.xz

Je décompresse l’archive et l’installe à l’endroit voulu :
tar -xJf arduino-1.8.15-linux64.tar.xz
sudo mv arduino-1.8.15 /usr/share/arduino

Je télécharge l’icône arduino et l’installe à l’endroit voulu :
wget http://entropie.org/3615/download/arduino.png
sudo mv arduino.png /usr/share/arduino/

Pour effacer une version précédente d’Arduino :
sudo rm -rf /usr/share/arduino

Pour intégrer le programme au menu de Xfce, je crée un fichier arduino.desktop dans le répertoire /usr/share/applications :
cd /usr/share/applications
sudo nano arduino.desktop

[Desktop Entry]
Type=Application
Name=Arduino
Comment=Un environnement de développement pour Arduino
GenericName=Create physical computing projects
Exec=/usr/share/arduino/arduino
Icon=/usr/share/arduino/arduino.png
Terminal=false
Categories=Development;Engineering;Electronics;
MimeType=text/x-arduino
Keywords=embedded electronics;electronics;avr;microcontroller;

Pour que le port série soit accessible et éviter de devoir utiliser Arduino en mode administrateur :
sudo usermod -a -G tty $USER ($USER à adapter)
sudo usermod -a -G dialout $USER ($USER à adapter)
Redémarrer.

Compléments (ATtiny, ATmega Mighty, ESP32) :

Pour ATtiny (45/85/44 notamment) :
https://github.com/SpenceKonde/ATTinyCore
Pour ATmega (644P/1284P notamment) :
https://github.com/MCUdude/MightyCore
Voir également : https://entropie.org/3615/index.php/2015/09/25/resolution-du-probleme-lie-a-la-bibliotheque-sd-arduino-1-0-5-sur-latmega1284p/
Pour ESP32 :
https://github.com/espressif/arduino-esp32

Fichier > Préférences > URL de gestionnaire de cartes supplémentaires :
http://drazzy.com/package_drazzy.com_index.json,https://mcudude.github.io/MightyCore/package_MCUdude_MightyCore_index.json,https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json

Puis aller dans le gestionnaire de carte (Outils > Type de carte > Gestionnaire de carte) pour installer :
ATTinyCore by Spence Conde,
MightyCore by MCUdude,
esp32 by Espressif Systems.

L’éthique des hackers

Un livre publié en 1984 et paru en France en 2013 :

Quatrième de couverture :

Précision : un « hacker » n’est pas un vulgaire pirate informatique. Un hacker est un « bricoleur de code ». Son truc : plonger dans les entrailles de la machine. Bill Gates, Steve Jobs, Steve Wozniak, Mark Zuckerberg ont commencé leurs brillantes carrières comme hackers… La plupart ne paient pas de mine mais tous partagent une même philosophie, une idée simple et élégante comme la logique qui gouverne l’informatique : l’ouverture, le partage, le refus de l’autorité et la nécessité d’agir par soi-même, quoi qu’il en coûte, pour changer le monde. C’est ce que Steven Levy appelle l’Ethique des hackers, une morale qui ne s’est pas exprimée dans un pesant manifeste, mais que les hackers authentiques ont mise en pratique dans leur vie quotidienne. Ce sont eux qui ont œuvré, dans l’obscurité, à la mise en marche de la révolution informatique. Depuis les laboratoires d’intelligence artificielle du MIT dans les années 1950 jusqu’aux gamers des années 1980, en passant par toutes les chambres de bonne où de jeunes surdoués ont consacré leurs nuits blanches à l’informatique, Steven Levy les a presque tous rencontrés. Voici leur histoire.

Mise à jour de la centrale Alpha 3

  • Alpha 1
  • Alpha 1
  • Alpha 2
  • Alpha 2
  • Alpha 3
  • Alpha 3

Je viens de mettre à jour la centrale Alpha 3. Elle est le 3ème prototype d’une centrale d’acquisition LIBRE à destination des enseignants de physique-chimie. Elle est actuellement conçue autour d’une carte Arduino Mega 2560 (par conséquent, entièrement reprogrammable par le port USB). Les périodes d’échantillonnages sont adaptées à des phénomèmes relativement lents : elles varient du dixième de seconde à l’heure. Un mode manuel (acquisition pas à pas) est également disponible. Les données (horodatées) sont enregistrées au format texte sur une carte SD. Elles se récupèrent par l’intermédiaire d’un câble USB connecté à un ordinateur sous Linux, Windows ou Mac OS X. Les données brutes sont ensuite facilement exploitables dans un tableur ou avec Python (format CSV). La centrale fonctionne sur batterie ou sur secteur. Elle peut être également alimentée par le port USB. Elle intègre un certain nombre de capteurs dont une boussole qui mesure l’azimut, le roulis et le tangage ; un baro-altimètre qui mesure la pression absolue, la pression relative et l’altitude ; enfin un accéléromètre qui mesure les accélérations suivant 2 axes actuellement. Les mesures renvoyées par la boussole font l’objet d’un traitement informatique en temps réel afin de compenser certaines erreurs de mesures liées à des perturbations électromagnétiques à l’intérieur du boîtier.

Code source sur GitHub

Le logiciel de récupération et traitement des données est désormais développé en Python. Il permet d’effectuer plusieurs types de régression (linéaire, quadratique, cubique, quartique, exponentielle, logarithmique, puissance, trigonométrique) :

Le capteur capacitif QT110

La vidéo : 3 réglages différents du QT110 (DC Out, Toggle et Pulse)

Le montage :

Concernant les composants périphériques au QT110 :
Cx est en général de l’ordre de 10 picofarads. Cs doit être 1000 fois plus grand que Cx, soit 10 nanofarads. Rs est à 470 kilo-ohms. Re doit être le plus grand possible tout en préservant la sensibilité du capteur (sur mon montage, Re est à 1 kilo-ohms).

Concernant le QT110 :
La patte 1 est reliée au +5V de la carte Arduino.
La patte 2 est reliée à l’entrée analogique 0 de la carte Arduino.
Les pattes 3 et 4 sont reliées soit à +5V, soit à Gnd sur la carte Arduino, selon la manière dont on souhaite faire réagir le capteur (voir le tableau ci-dessous).
La patte 5 n’est pas connectée (si on choisit un gain maximum).
Les pattes 6 et 7 sont reliées entre elles par l’intermédiaire du condensateur Cs en parallèle avec la résistance Rs.
La patte 7 est reliée à la résistance Re en série avec l’électrode de détection.
La patte 8 est reliée à Gnd sur la carte Arduino.

DC Out : Quand on s’approche de l’électrode, la DEL verte s’éteint et la rouge s’allume. On repasse au vert dès qu’on s’éloigne de l’électrode. Par contre si le contact se prolonge, on reste au rouge près de 10 secondes (ou 60 secondes) avant de basculer de nouveau au vert.
Toggle : La couleur change à chaque nouvelle approche de l’électrode. Elle ne change pas quand on s’en éloigne.
Pulse : Quand on s’approche de l’électrode, la DEL verte s’éteint et la rouge s’allume une fraction de seconde, puis on bascule tout de suite au vert, même si le contact se prolonge.

Concernant les DEL rouge et verte :
Elles sont chacune mises en série avec une résistance de 330 ohms, puis reliées sur les sorties digitales 2 et 3 de la carte Arduino.

Le code Arduino :

/////////////////////////////////////////////////////////////////
/*
  Capteur capacitif QT110
*/
/////////////////////////////////////////////////////////////////

int ledrPin = 2;  // LED rouge sur la sortie digitale 2.
int ledvPin = 3;  // LED verte sur la sortie digitale 3.
int aPin = 0;     // Patte 2 du QT110 sur l'entrée analogique 0.
int value = 0;    // Variable de stockage de la valeur mesurée.

void setup()
{
  pinMode(ledrPin, OUTPUT);  // Declare the ledrPin as an OUTPUT.
  pinMode(ledvPin, OUTPUT);  // Declare the ledvPin as an OUTPUT.
  pinMode(aPin, INPUT);
}

void loop()
{
  value = analogRead(aPin);  // Read the input pin.
  
  if (value >= 512) digitalWrite(ledrPin, LOW);
  else digitalWrite(ledrPin, HIGH);
  if (value < 512) digitalWrite(ledvPin, LOW);
  else digitalWrite(ledvPin, HIGH);
  
  delay(20);  // Wait 20 milliseconds.
}

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

Opérateurs Qwant / Google

Pour des recherches pointues sur Qwant :

« » : pour rechercher une phrase exacte.
– : exclure des mots de la recherche en utilisant le signe moins.
OR : pour rechercher le premier ou le second mot clé, ou les deux.
site: pour rechercher les pages web d’un site spécifique.
intitle: pour effectuer des recherches dans les balises title.
filetype: limite la recherche au type de fichier spécifié.

Pour des recherches pointues sur Google, on a en plus :

allintitle: recherche tous les termes dans les balises title.
inurl: pour rechercher les URLs qui contiennent des éléments précis.
cache: permet de visualiser la page spécifiée au niveau du cache Google.
after: date au format AAAA-MM-JJ ou AAAA-MM ou AAAA.
before: date au format AAAA-MM-JJ ou AAAA-MM ou AAAA.

Etude d’un accéléromètre 2D

Il s’agit de la remise en ligne d’un article que j’ai écrit en 2012.

La vidéo :

Le matériel et les logiciels utilisés :

Une carte Arduino Duemilanove.
Un shield avec plaque d’essais.
Des fils de diamètre 0,5 mm.
Un accéléromètre DE-ACCM2G de DimensionEngineering (construit autour de l’ADXL322).
Le logiciel Arduino.
Le logiciel Processing.

Etape 1 : L’accéléromètre et l’interfaçage avec la carte Arduino

La patte Vcc est à connecter à la borne 5V de la carte Arduino (au niveau de POWER). La patte Ground est à connecter à la borne Gnd de la carte Arduino (au niveau de POWER). La patte X output est à connecter à la borne analogique 1 par exemple (au niveau de ANALOG IN). La patte Y output est à connecter à la borne analogique 2 par exemple (au niveau de ANALOG IN).

Etape 2 : La programmation de la carte avec le logiciel Arduino

Sur GitHub

Etape 3 : L’interfaçage avec le logiciel Processing

Sur GitHub

Etape 4 : A l’écran


Remarques :

Le capteur étudié ici n’a pas une réponse linéaire quand il est utilisé en inclinomètre. J’ai donc décidé de découper la courbe de réponse en 18 morceaux (10° chacun) et de les approcher par des fonctions affines. Les animations à l’écran, visuellement très satisfaisantes, montrent que cette approche est pertinente.

Poussons l’étude un peu plus loin : Les deux courbes ci-dessus font penser à la représentation graphique de la fonction Arc sinus ; nous allons donc prendre le sinus de la variable degY (ou degX) afin d’essayer d’obtenir une droite :

Bingo ! Nous avons une belle fonction affine. Nous allons donc pouvoir calculer facilement des accélérations à partir des mesures reçues par le capteur. Reste à faire la même chose avec X et degX. Nous obtenons ainsi :

a(X) = (0,0067560184 * X – 3,4804161956) * g
a(Y) = (0,0067732268 * Y – 3,4058636402) * g

Etape 5 : En voiture

On embarque la carte Arduino et l’ordinateur dans une voiture, l’axe Y du capteur étant orienté dans le sens de la marche et le capteur posé à plat. Les données sont enregistrées en temps réel dans le fichier « données.txt » dans le répertoire du programme. En utilisant les fonctions affines déterminées ci dessus, nous pouvons calculer l’accélération de la voiture selon l’axe X ou Y du capteur.

Programmation d’un bootloader sur un ATmega 328P (8 MHz / 3,3 V)

Article mis à jour le 21/03/2021.

Sur le site Arduino, on trouve la marche à suivre : From Arduino to a Microcontroller on a Breadboard. Toutefois, cela s’est avéré insuffisant en ce qui me concerne, d’où ce tutoriel pour compléter ou corriger.

Version du logiciel utilisée : Arduino 1.8.13

S’il n’existe pas, créer un sous-répertoire « hardware » dans le répertoire personnel « sketchbook » d’Arduino.
Télécharger et décompresser breadboard-1-8-x.7z dans le répertoire hardware ci-dessus :

> sketchbook > hardware > breadboard > avr > boards.txt
> sketchbook > hardware > breadboard > avr > bootloaders > atmega > ATmegaBOOT_168_atmega328_pro_8MHz.hex

Fichier boards.txt :

#################################################################

atmega328bb.name=ATmega328P on a breadboard (8 MHz internal clock / 3.3 V / BOD at 2.7 V)

atmega328bb.upload.protocol=arduino
atmega328bb.upload.maximum_size=30720
atmega328bb.upload.speed=57600
atmega328bb.upload.tool=arduino:avrdude

atmega328bb.bootloader.low_fuses=0xE2
atmega328bb.bootloader.high_fuses=0xDA
atmega328bb.bootloader.extended_fuses=0xFD
atmega328bb.bootloader.file=atmega/ATmegaBOOT_168_atmega328_pro_8MHz.hex
atmega328bb.bootloader.unlock_bits=0x3F
atmega328bb.bootloader.lock_bits=0x0F
atmega328bb.bootloader.tool=arduino:avrdude

atmega328bb.build.mcu=atmega328p
atmega328bb.build.f_cpu=8000000L
atmega328bb.build.board=AVR_ATMEGA328BB
atmega328bb.build.core=arduino:arduino
atmega328bb.build.variant=arduino:standard

#################################################################

Concernant les fusibles (fuses), voir AVR Fuse Calculator.

Si l’ATmega a déjà été « bootloadé » en 16 MHz :
– Mettre le quartz 16 Mhz
– Ouvrir le logiciel Arduino
– Choisir comme type de carte ATmega 328P on a breadboard (8 MHz internal clock / 3,3 V / BOD at 2.7 V)
– Choisir comme programmateur Arduino as ISP
– Graver la séquence d’initialisation

Si l’ATmega a déjà été « bootloadé » en 8 MHz interne :
– Ne pas mettre de quartz
– Ouvrir le logiciel Arduino
– Choisir comme type de carte ATmega 328P on a breadboard (8 MHz internal clock / 3,3 V / BOD at 2.7 V)
– Choisir comme programmateur Arduino as ISP
– Graver la séquence d’initialisation