Servomoteurs et Solénoïdes – Dahee Cha / Madeleine Vilette

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.

-> Observations : adaptations à faire pour réduire le nombre de servo moteur à utiliser. En effet, ici 1 POINT = 1 SERVO MOTEUR

-> Première intention – visualisation 3D d’un module

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.

-> Branchements Arduino – Transistor – Diode – Résistance – Solénoïde

3. Arduino

  • FONCTIONNEMENT DES SOLENOÏDES
-> mise en place des branchements du solénoïde

-> 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
-> schéma pris en note pour le branchement d’un solenoide – pour la connexion de chaque solénoïdes, connecter la résistance à un nouveau Pin (de 2 à 11). chaque solenoide à son transistor, sa résistance et sa diode (branchement à effectuer – 3 câbles)
-> utilisation d’une alimentation externe pour alimenter tous les solénoïdes et leur fournir suffisamment de puissance.
-> schéma pris en note de la connexion de l’alimentation externe à l’Arduino et aux branchements des solénoï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
  }
}
-> *
  1. FINALISATION DES RECHERCHES
-> 10 compositions potentielles – chiffres de 0 à 9
-> visualisation de l’enchaînement des 10 compositions
-> impression 3D de la boîte contenant les 10 solénoïdes, fixés à 10 tiges

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
-> OBJECTIF : comprendre le fonctionnement du code (voir ci-dessous) pour contrôler l’angle et les durées de rotation de la flèche.

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
-> OBJECTIF : contrôler l’angle de rotation du servo moteur avec un 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 &lt;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.