Installation de DOSBox sous Debian 10

DOSBox est un émulateur simulant un environnement compatible MS-DOS dans le but d’exécuter des programmes développés autrefois pour ce système. Il se trouve que j’ai besoin de faire tourner certains de mes vieux programmes…

Dans la console :
sudo apt-get install dosbox
mkdir ~/DOSBox (ou un autre chemin)
nano ~/.dosbox/dosbox-0.74-2.conf

Modifier le fichier dosbox-0.74-2.conf :
[cpu]
cycles=max
(à la place de cycles=auto)
[dos]
keyboardlayout=fr
(à la place de keyboardlayout=auto)
[autoexec]
mount c ~/DOSBox
(pour un chemin qui contient des espaces, mettre le chemin entre guillements : " ")

Lancer DOSBox depuis la console :
dosbox

Dans DOSBox :
c:
dir

Pour basculer entre le mode fenêtré et le mode plein écran, presser Alt-Entrée. Pour libérer le curseur de la souris, presser Ctrl-F10.


Complément personnel à mettre dans le fichier dosbox-0.74-2.conf dont il est question ci-dessus :

[autoexec]
# Lines in this section will be run at startup.
# You can put your MOUNT lines here.
mount c "/media/eric/Fichiers Eric/Programmation/DOSBox/"
c:

### OPEN WATCOM 1.9 ###
path=%path%;c:\watcom\binw       
set include=c:\watcom\h
set watcom=c:\watcom
set edpath=c:\watcom\eddat
set wipfc=c:\watcom\wipfc

### TURBO PASCAL 7.0 ###
path=%path%;c:\tp7\bin

### NASM 2.15.05 ###
path=%path%;c:\nasm

Installation du scanner Epson Perfection V37 sous Debian 10

Brancher et allumer le scanner.

Dans la console :
lsusb (Pour récupérer ID idVendor:idProduct)
sudo nano /etc/udev/rules.d/60-sane-missing-scanner.rules

Compléter le fichier ci-dessus avec :
# Epson Perfection V37
ATTRS{idVendor}=="04b8", ATTRS{idProduct}=="014a", MODE="0664", GROUP="scanner", ENV{libsane_matched}="yes"

Télécharger le fichier iscan-perfection-v370-bundle-2.30.4.x64.deb.tar.gz depuis cette adresse. En cas de lien rompu, faire une nouvelle recherche depuis EPSON Download Center et adapter les instructions ci-dessous.

Dans la console :
cd Téléchargements
tar -zxvf iscan-perfection-v370-bundle-2.30.4.x64.deb.tar.gz
cd iscan-perfection-v370-bundle-2.30.4.x64.deb
sudo gdebi data/iscan-data_1.39.2-1_all.deb => IGNORER LE PROBLÈME
sudo gdebi core/iscan_2.30.4-2_amd64.deb
sudo gdebi plugins/iscan-plugin-perfection-v370_1.0.1-1_amd64.deb

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.

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)

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

Clavier PS/2 et Arduino (sans bibliothèque dédiée)

Le montage :

Port PS/2
Broche 1 (data) => Broche 4 de l’Arduino
Broche 2 (non connecté)
Broche 3 => GND de l’Arduino
Broche 4 => 5V de l’Arduino
Broche 5 (clock) => Broche 3 de l’Arduino
Broche 6 (non connecté)

Le code Arduino :

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

const int DATA_PIN = 4;
const int CLOCK_PIN = 3;

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

void setup() {
  pinMode(DATA_PIN, INPUT);
  // C'est le clavier qui génère l'horloge de synchronisation
  pinMode(CLOCK_PIN, INPUT);
  Serial.begin(9600);
}

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

void loop() {
  Serial.println(dataRead(),HEX);
}

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

int dataRead() { // La trame est de 11 bits
/*
  Si la pression est maintenue, le code est envoyé environ toutes
  les 100 ms (make code). Quand la touche est relachée, le clavier
  envoie le code F0 suivi du code de la touche relachée (break
  code), sauf pour quelques touches particulières (voir le fichier
  PDF correspondant ci-dessous).
*/
  byte data = 0;
  while (digitalRead(DATA_PIN) && digitalRead(CLOCK_PIN));
  // 1 bit de start : La ligne de transmission des données est
  // passée au niveau bas et un signal d'horloge est engendré :
  while (digitalRead(CLOCK_PIN));
  while (!digitalRead(CLOCK_PIN));
  // 8 bits de données (bit de poids faible (LSB) en premier)
  for (int d=0; d<=7; d++) {
    // Les données sont valables sur le front descendant
    // du signal d'horloge
    while (digitalRead(CLOCK_PIN));
    data = data | digitalRead(DATA_PIN) << d;
    while (!digitalRead(CLOCK_PIN));
  }
  // 1 bit de parité
  while (digitalRead(CLOCK_PIN));                    
  while (!digitalRead(CLOCK_PIN));
  // 1 bit de stop
  while (digitalRead(CLOCK_PIN));                   
  while (!digitalRead(CLOCK_PIN));
  return data;
}

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

Les codes obtenus avec le programme Arduino ci-dessus :

Clavier PS/2 (fichier PDF)

Hack d’un clavier avec port PS/2

L’objectif :

Le but est de réaliser une matrice de clavier relativement grande qui utilise le moins d’entrées / sorties possible sur une carte Arduino par exemple. Le port PS/2 d’un clavier de PC n’utilise que 4 broches sur les 6 de la prise correspondante (+5V, GND, CLK, DATA). Deux de ces lignes (CLK et DATA) sont suffisantes pour faire communiquer un clavier de 105 touches avec un PC. Je vais donc m’atteler à en comprendre le fonctionnement afin de pouvoir réutiliser l’encodeur du clavier.

Les pièces maîtresses :

L’analyse :

Étude des pistes du clavier

Installer Processing 3 sous Debian 10

Les sites officiels : Processing et Debian

Dans la console :

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

Je télécharge la version 64 bits (à adapter) :
cd Téléchargements
wget -c http://download.processing.org/processing-3.5.4-linux64.tgz

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

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

Pour effacer une version précédente de Processing (x à adapter) :
sudo rm -rf /usr/share/processing/processing-3.x.x

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

[Desktop Entry]
Type=Application
Name=Processing 3
Comment=Un environnement de développement pour le langage Processing
Exec=/usr/share/processing/processing-3.5.4/processing
Icon=/usr/share/processing/processing.png
Terminal=false
Categories=Development;