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 mon_identifiant (à adapter)
sudo usermod -a -G dialout mon_identifiant (à adapter)
Redémarrer.

Installer Arduino 1.8.9 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.8.9-linux64.tar.xz

Je décompresse l’archive et l’installe à l’endroit voulu :
tar -xJf arduino-1.8.9-linux64.tar.xz
sudo mv arduino-1.8.9 /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.8.9.desktop dans le répertoire /usr/share/applications :
cd /usr/share/applications
sudo nano arduino-1.8.9.desktop

[Desktop Entry]
Type=Application
Name=Arduino 1.8.9
Comment=Un environnement de développement pour Arduino
GenericName=Create physical computing projects
Exec=/usr/share/arduino/arduino-1.8.9/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 mon_identifiant (à adapter)
sudo usermod -a -G dialout mon_identifiant (à adapter)
Redémarrer.

Mise à jour de la centrale 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.
}

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

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)

Sur le site Arduino, on trouve quelques informations : 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.

Travailler avec Arduino 1.0.6 (problèmes avec les autres versions).

> sketchbook > hardware > breadboard >boards.txt
S’il n’existe pas, créer un sous-répertoire « hardware » dans le répertoire « sketchbook » d’Arduino ; puis un sous-répertoire « breadboard » dans le répertoire « hardware ». Dans le répertoire « breadboard », créer (ou compléter) le fichier boards.txt :

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

atmega328bb.name=ATmega 328P on a breadboard (8 MHz / 3.3 V / BOD at 2.7 V)

atmega328bb.upload.protocol=stk500
atmega328bb.upload.maximum_size=30720
atmega328bb.upload.speed=57600

atmega328bb.bootloader.low_fuses=0xE2
atmega328bb.bootloader.high_fuses=0xDA
atmega328bb.bootloader.extended_fuses=0x05
atmega328bb.bootloader.path=arduino:atmega
atmega328bb.bootloader.file=ATmegaBOOT_168_atmega328_pro_8MHz.hex
atmega328bb.bootloader.unlock_bits=0x3F
atmega328bb.bootloader.lock_bits=0x0F

atmega328bb.build.mcu=atmega328p
atmega328bb.build.f_cpu=8000000L
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 Arduino 1.0.6
– Choisir comme type de carte ATmega 328P (8 MHz / 3,3 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 Arduino 1.0.6
– Choisir comme type de carte ATmega 328P (8 MHz / 3,3 V)
– Choisir comme programmateur Arduino as ISP
– Graver la séquence d’initialisation


Pour programmer son application, on peut revenir à une version plus récente d’Arduino (1.8.x). Pour y faire apparaître la carte ATmega 328 P (8 MHz / 3,3 V), copier / coller le fichier boards.txt ici :
> sketchbook > hardware > breadboard > avr > boards.txt