Studio Numérique – Semestre 1 – 2025/2026
Lors de ce studio, nous avons décidé de chacune développer nos idées de projets, tout en s’aidant mutuellement et en découvrant ensemble le fonctionnement des servomoteurs et des solénoïdes.
MADELEINE
1. Présentation du projet
Mouvement de différentes formes (monter, descendre)
-> Formation d’un motif déterminé ou aléatoire
-> Travail du point qui apparait / disparait
-> application sur une horloge avec décomposition des chiffres en points, qui se lèvent et se remettent à fleur de surface pour former l’heure.
-> commencer par le travail d’une unité (heure = quatre chiffres/unités)
-> pourrait aussi prendre forme sur une plaque avec un travail de motif mouvant aléatoire, formé par les points qui montent et descendent.

2. Matériel nécessaire
- SOLENOÏDE
Un solénoïde est une bobine de fil conducteur enroulée autour d’un noyau mobile en métal (piston).
Quand on fait passer du courant dans la bobine, un champ magnétique se crée et attire ou repousse le noyau, produisant un mouvement mécanique (comme tirer ou pousser une tige).
-> permet d’effectuer un mouvement linéaire
- TRANSISTOR
Le transistor (souvent un NPN) fonctionne comme un interrupteur contrôlé par l’Arduino :
- La broche Arduino envoie un signal (0 ou 5 V).
- Le transistor laisse alors passer le courant à travers le solénoïde depuis l’alimentation.
Cela permet de commander le solénoïde avec un signal faible.
- DIODE
Un solénoïde est une bobine de fil. Lors de son activation, il crée un champ magnétique. Dès que le courant est coupé (avec le transistor), ce champ magnétique s’arrête brutalement. Cet arrêt génère une étincelle de haute tension (plusieurs centaines de volts) dans le sens inverse. Sans diode, cette tension revient vers l’Arduino ou le transistor et peut les griller instantanément.
- RÉSISTANCE
La résistance a un rôle très différent de celui de la diode. Elle ne sert pas à protéger des pics de tension, mais à contrôler le signal qui commande le solénoïde. On place une petite résistance en série, directement entre la broche de l’Arduino et l’entrée du transistor (le MOSFET). Elle limite le courant qui sort de l’Arduino lors de l’activation de la broche.

3. Arduino
- FONCTIONNEMENT DES SOLENOÏDES


-> test solénoïde
Code ARDUINO / ci-dessus : fonctionnement d’un solénoïde
int solenoidPin = 7; // On relie le solénoïde à la broche 7 de l’Arduino
void setup () {
// put your setup code here, to run once:
pinMode (solenoidPin, OUTPUT); // On configure la broche 7 comme une sortie
}
void loop() {
// put your main code here, to run repeatedly:
digitalWrite(solenoidPin, HIGH); // Envoie 5V sur la broche 7 → le solénoïde s’active
delay (2000); // Attend 2000 millisecondes = 2 secondes
digitalWrite(solenoidPin, LOW); // Coupe la tension → le solénoïde se désactive
delay (2000); // Attend encore 2 secondes avant de recommencer
}
Code ARDUINO / variation de la fréquence d’activation. Le solénoïde s’active de plus en plus vite, puis ralentit.
int solenoidPin = 7;
void setup() {
pinMode(solenoidPin, OUTPUT);
}
void loop() {
// Fait varier la vitesse entre 2 secondes et 0.2 seconde
for (int delayTime = 2000; delayTime >= 200; delayTime -= 200) {
digitalWrite(solenoidPin, HIGH); // Active le solénoïde
delay(delayTime); // Temps d’activation variable
digitalWrite(solenoidPin, LOW); // Désactive le solénoïde
delay(delayTime); // Même durée d’attente
}
- FONCTIONNEMENT SOLÉNOÏDE + SERVOMOTEUR

Code ARDUINO / ci-dessus : déplacement servomoteur 90 degrés – déplacement inverse servo-moteur 90 degrés – solénoïde on/off)
// Include the servo library:
#include "Servo.h"
// Create a new servo object:
Servo myservo;
// Define the servo and solenoid pins:
#define servoPin 9
#define solenoidPin 7 // Correction du nom de variable
void setup() {
// Attach the Servo variable to a pin:
myservo.attach(servoPin);
// Configure the solenoid pin as output:
pinMode(solenoidPin, OUTPUT);
}
void loop() {
// Déplacer le servomoteur :
myservo.write(90);
delay(1000);
myservo.write(0);
delay(1000);
// Activer/désactiver le solénoïde :
digitalWrite(solenoidPin, HIGH); // Active le solénoïde
delay(2000);
digitalWrite(solenoidPin, LOW); // Désactive le solénoïde
delay(2000);
}
Code ARDUINO / déplacement servo-moteur 90 degrés – solénoïde on/off – déplacement inverse servo-moteur 90 degrés
#include "Servo.h"
Servo myservo; // Créer un objet servo
#define servoPin 9
#define solenoidPin 7
void setup() {
myservo.attach(servoPin); // Attacher le servo à la broche 9
pinMode(solenoidPin, OUTPUT); // Configurer la broche du solénoïde en sortie
}
void loop() {
// Déplacer le servo à 90° (aller)
myservo.write(90);
delay(2000); // attendre que le servo arrive à la position
// Activer le solénoïde puis le désactiver
digitalWrite(solenoidPin, HIGH); // solénoïde ON
delay(1000);
digitalWrite(solenoidPin, LOW); // solénoïde OFF
delay(2000);
// Revenir le servo à 0° (retour)
myservo.write(0);
delay(5000);
}
- FONCTIONNEMENT DE PLUSIEURS SOLENOÏDES





Code Arduino – première écriture pour le fonctionnement de 10 solénoïdes en même temps (à tester avec les branchement à la suite du semestre) *voir explication des numéros de 2 à 13 en bas du code
// Broches des solénoïdes
// connecter chaques solenoides à un pin (de 2 à 13 sur l'Arduino)
int solenoids[10] = { // total de 10 solenoides
2, 3, 4, 5, 6, // Colonne gauche (haut → bas) = 5 solenoides
7, 8, 9, 10, 11 // Colonne droite (haut → bas) = 5 solenoides
};
// Initialisation
void setup() {
for (int i = 0; i < 10; i++) { // répeter le code 10 fois (int i=0 -> commence à 0 / i<10 -> s'arrete à 9 / i++ -> aug i de 1 à chaque tour)
pinMode(solenoids[i], OUTPUT); // i correpond à la broche de connexion Arduino du solenoide / OUTPUT -> cette broche (i) sert à envoyer le courant)
digitalWrite(solenoids[i], LOW); // LOW = OV (éteint) -> pour que les solenoides soient désactivés au démarrage
}
}
// Fonction pour éteindre tous les solénoïdes
void resetSolenoids() {
for (int i = 0; i < 10; i++) {
digitalWrite(solenoids[i], LOW);
}
}
// Affichage d'un chiffre avec switch-case
void afficherChiffre(int chiffre) { // déclarer une action
resetSolenoids(); // appelle la fonction void resetSolenoid, pour éteindre tous les solénoïdes avant d’allumer uniquement ceux nécessaires pour le chiffre actuel.
switch (chiffre) {
case 1:
digitalWrite(2, HIGH); digitalWrite(4, HIGH); digitalWrite(5, HIGH); digitalWrite(6, HIGH); // HIGH = les points se baissent et se positionnent à la surface de la boite -> parties vides des chiffres
break;
case 2:
digitalWrite(3, HIGH);
digitalWrite(10, HIGH);
break;
case 3:
digitalWrite(3, HIGH); digitalWrite(5, HIGH);
break;
case 4:
digitalWrite(5, HIGH); digitalWrite(6, HIGH);
digitalWrite(7, HIGH); digitalWrite(8, HIGH);
break;
case 5:
digitalWrite(5, HIGH);
digitalWrite(8, HIGH);
break;
case 6:
digitalWrite(8, HIGH);
break;
case 7:
digitalWrite(2, HIGH); digitalWrite(5, HIGH); digitalWrite(6, HIGH); // 2,4 allumés - donc 3,5,6 automatiquement éteints
break;
case 8:
digitalWrite(4, HIGH);
digitalWrite(9, HIGH);
break;
case 9:
digitalWrite(5, HIGH);
break;
// HIGH = état haut / tension positive, typiquement 5 V sur Arduino UNO.
// est ce qu'il faut mettre les point LOW??
default:
// Aucun chiffre valide
break;
}
}
// Boucle principale
void loop() {
for (int chiffre = 0; chiffre <= 9; chiffre++) {
afficherChiffre(chiffre);
delay(5000); // Durée d'affichage en milisecondes
}
}

- FINALISATION DES RECHERCHES



DAHEE
1. Présentation du projet
Ce projet est une expérimentation de typographie interactive 3D qui intègre deux systèmes d’écriture — le hangeul et l’alphabet latin — en un seul objet, en s’appuyant sur leurs similitudes phonétiques. Des paires de lettres phonétiquement correspondantes (B ↔ ㅂ, A ↔ ㅏ) ont été sélectionnées et fabriquées par impression 3D, puis rendues lisibles sous différents angles grâce à un mécanisme de rotation piloté par Arduino et servomoteurs.
Reference : https://pinaffo-pluvinage.com
2. Sélection de lettres par correspondance phonétique
Des paires de lettres coréennes et latines ont été choisies sur la base de leur similarité phonétique :
- B / ㅂ [b/p]
- A / ㅏ [a/ɑ]
3. Modélisation et fabrication 3D
Un modèle 3D fusionnant chaque paire de lettres en une seule forme volumétrique a été conçu. La structure squelettique des deux lettres a été reconstituée spatialement de sorte que l’alphabet latin soit lisible de face (0°) et que les lettres hangeul apparaissent après une rotation de 90°.
- Objet B-ㅂ : « B » visible de face, « ㅂ » après rotation de 90°
- Objet A-ㅏ : « A » visible de face, « ㅏ » après rotation de 90°
Il s’agit d’une extension tridimensionnelle de la typographie où le sens change selon la perspective, ce qui est impossible sur un plan 2D.



4. Modélisation et fabrication 3D
Un modèle 3D fusionnant chaque paire de lettres en une seule forme volumétrique a été conçu. La structure squelettique des deux lettres a été reconstituée spatialement de sorte que l’alphabet latin soit lisible de face (0°) et que les lettres hangeul apparaissent après une rotation de 90°.
- Objet B-ㅂ : « B » visible de face, « ㅂ » après rotation de 90°
- Objet A-ㅏ : « A » visible de face, « ㅏ » après rotation de 90°
Il s’agit d’une extension tridimensionnelle de la typographie où le sens change selon la perspective, ce qui est impossible sur un plan 2D.
3. Arduino
- FONCTIONNEMENT D’UN SERVOMOTEUR

Code ARDUINO / lien ci-dessus
/* Servo motor with Arduino example code. Position and sweep. More info: https://www.makerguides.com/ */
// Include the servo library:
#include "Servo.h"
// Create a new servo object:
Servo myservo;
// Define the servo pin:
#define servoPin 9
void setup() {
// Attach the Servo variable to a pin:
myservo.attach(servoPin);
}
void loop() {
// Demander au servomoteur d’aller à un angle précis :
myservo.write(90);
delay(1000);
myservo.write(0);
delay(1000);
// Balayer de 0 à 180 degrés :
for (int angle = 0; angle <= 180; angle += 1) {
myservo.write(angle);
delay(10);
}
delay(1000);
// Puis revenir de 189 à 0 degrés :
for (int angle = 180; angle >= 0; angle -= 1) {
myservo.write(angle);
delay(10);
}
delay(1000);
}
- ROTATION AVEC POTENTIOMÈTRE

Code ARDUINO / ci-dessus
#include "Servo.h" // include the required Arduino library
#define servoPin 9 // Arduino pin for the servo
#define potPin A0 // Arduino pin for the potentiometer
int angle = 0; // variable to store the servo position in degrees
int reading = 0; // variable to store the reading from the analog input
Servo myservo; // create a new object of the servo class
void setup() {
myservo.attach(servoPin);
}
void loop() {
reading = analogRead(potPin); // read the analog input
angle = map(reading, 0, 1023, 0, 180); // map the input to a value between 0 and 180 degrees
myservo.write(angle); // tell the servo to go to the set position
delay(15); // wait 15 ms for the servo to reach the position
Serial.println(reading);
Serial.println(" ");
Serial.println(angle);
}
- FONCTIONNEMENT DE DEUX SOLENOÏDES



Code ARDUINO / ci-dessus : fonctionnement de deux servo-moteurs
#include <Servo.h>
Servo servo1; // 첫 번째 서보 객체
Servo servo2; // 두 번째 서보 객체
void setup() {
servo1.attach(9); // 서보1 신호선 Arduino 9번 핀
servo2.attach(10); // 서보2 신호선 Arduino 10번 핀
}
void loop() {
// 두 서보 동시에 90도로 이동
servo1.write(90);
servo2.write(90);
delay(1000); // 1초 대기
// 두 서보 동시에 0도로 복귀
servo1.write(0);
servo2.write(0);
delay(1000); // 1초 대기
}
5. Signification
- Extension de la typographie 2D dans l’espace tridimensionnel
- Nouvelle approche intégrant physiquement la typographie bilingue
- Transformation de lettres statiques en typographie cinétique (kinetic typography)
- Exploration spatiale de la relation entre forme et prononciation des caractères
6. Limites
- Nature multicouche de la prononciation : La correspondance phonétique entre le hangeul et l’alphabet latin n’est jamais totalement exacte. Certaines paires de lettres sonnent différemment selon le contexte ou l’environnement phonétique, ce qui limite la généralisation d’une correspondance phonétique stricte.
- Limitation de la correspondance entre lettres :Si les lettres partageant des sons similaires peuvent être mises en correspondance, celles issues de systèmes phonétiques différents sont difficiles à apparier.



