Cette page fournit une simple interface de navigation pour trouver des entités décrites par une propriété et une valeur nommée. D’autres interfaces de recherche disponibles comprennent la page recherche de propriété, et le constructeur de requêtes ask.
pâte levée, et crée la [https://fr.wikipedia.org/wiki/Mie mie]. Cette fermentation, dite fermentation alcoolique, produit outre le dioxyde de carbone, de l'éthanol, qui est vaporisé lors de la cuisson. Sans ajout de levain ou levure, le pain est dit azyme. Plus d'info ici : https://fr.wikipedia.org/wiki/Pain Plus d'info ici : https://fr.wikipedia.org/wiki/Pain)
| 9H | 8H | 7H | 6H | 5H | 4H | 3H | 2H | H | F | HB | B | 2B | 3B | 4B | 5B | 6B | 7B | 8B | 9B |
| Dure | → | Moyenne | → | Tendre | |||||||||||||||
| Capteur DHT22 | ||
| Avant le Setup | Importation de la bibliothèque | #include "DHT.h" |
| Création de l’objet | DHT dht(broche, DHT22); | |
| Dans le Setup | Démarrage de l’objet | dht.begin(); |
| Dans le Loop | Utilisation | int temp = dht.readTemperature(); int hum = dht.readHumidity(); |
//Ajout de la bibliothèque DHT Sensor Library
#include "DHT.h"
// Broche où est connectée le capteur DHT
#define DHTPIN D2
// Définir le type de capteur DHT
#define DHTTYPE DHT22
// Initialisation du Capteur DHT
DHT dht(DHTPIN, DHTTYPE);
void setup() {
Serial.begin(9600); // démarrage de la connexion série
dht.begin();
}
void loop() {
/* Mesure de température et d'humidité */
//Lecture de l'humidité ambiante
float h = dht.readHumidity();
// Lecture de la température en Celcius
float t = dht.readTemperature();
//Affichage de la température dans le moniteur série
Serial.print("Température : ");
Serial.println(t);
//Affichage de l'humidité dans le moniteur série
Serial.print("Humidité : ");
Serial.println(h);
}| Avant le Setup | Importation de la bibliothèque | #include "SdsDustSensor.h" |
| Création de l’objet | int rxPin = D5; int txPin = D6; SdsDustSensor sds(rxPin, txPin); | |
| Dans le Setup | Démarrage de l’objet | Serial.begin(9600); sds.begin(); |
| Dans le Loop | Utilisation | PmResult pm = sds.readPm(); Serial.print("PM2.5 = "); Serial.print(pm.pm25); Serial.print(", PM10 = "); Serial.println(pm.pm10); |
#include "SdsDustSensor.h"
int rxPin = D5;
int txPin = D6;
SdsDustSensor sds(rxPin, txPin);
void setup() {
Serial.begin(9600);
sds.begin();
Serial.println(sds.queryFirmwareVersion().toString());
Serial.println(sds.setActiveReportingMode().toString());
Serial.println(sds.setContinuousWorkingPeriod().toString());
}
void loop() {
PmResult pm = sds.readPm();
if (pm.isOk()) {
Serial.print("PM2.5 = ");
Serial.print(pm.pm25);
Serial.print(", PM10 = ");
Serial.println(pm.pm10);
Serial.println(pm.toString());
}
else {
Serial.print("Could not read values from sensor, reason: ");
Serial.println(pm.statusToString());
}
delay(500);
}| MPR121 | ||
| Avant le Setup | Importation de la bibliothèque | #include #include "Adafruit_MPR121.h" |
| Création de l’objet | Adafruit_MPR121 capteur = Adafruit_MPR121(); // Déclaration de variable uint16_t actuelleTouche = 0; | |
| Dans le Setup | Démarrage de l’objet | if (!capteur.begin(0x5A)) { while (1); } |
| Dans le Loop | Utilisation | actuelleTouche = capteur.touched(); |
////////////////////////
// Capteur Capacitif //
// MPR121 //
////////////////////////
/*
LOLIN (wemos)D1 mini
_______________________________ Capteur capacitif MPR121
/ _________________ \ _________________
/ / D1 mini \ \ | L 11[ ]|
/ |[ ]RST TX[ ]| \ | E 10[ ]|
| |[ ]A0 -GPIO RX[ ]| \ | D 9[ ]|
| |[ ]D0-16 5-D1[X]| SCL----------. \-|[X]3,3V / 8[ ]|
| |[ ]D5-14 4-D2[X]| SDA---------. \ |[ ]IRQ e 7[ ]|
| |[ ]D6-12 0-D3[ ]| \ \-|[X]SCL l 6[ ]|
| |[ ]D7-13 2-D4[ ]| LED_BUILTIN \--|[X]SDA e 5[ ]|
| |[ ]D8-15 GND[X]|--------------. |[ ]ADD c 4[ ]|
\--|[X]3V3 5V[ ]| \--|[X]GND t 3[ ]|
| +---+ | | r 2[ ]|
|_______|USB|_______| | o 1[ ]|
| MPR121 d 0[ ]|
|_________e_______|
Matériel :
- Des fils dupont
- Un LOLIN (ou Wemos) D1 mini
- Capteur capacitif MPR121
Schéma de l'Arduino en ASCII-ART CC-By http://busyducks.com/ascii-art-arduinos
Sous licence CC-By-Sa (http://creativecommons.org/licenses/by-nc-sa/3.0/)
___
/ ___ \
|_| |
/_/
_ ___ _
|_| |___|_| |_
___|_ _|
|___| |_|
Les petits Débrouillards - février 2023 - CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/
Inspiré de : https://electropeak.com/learn/interfacing-mpr121-capacitive-touch-sensor-module-with-arduino/
Modified by MehranMaleki from Arduino Examples - janvier 2021
*/
#include
#include "Adafruit_MPR121.h"
#ifndef _BV
#define _BV(bit) (1 << (bit))
#endif
// Vous pouvez en avoir jusqu'à 4 MPR121 sur un bus i2c mais un seul suffit pour les tests !
Adafruit_MPR121 cap = Adafruit_MPR121();
// Garde la trace des dernières broches touchés.
// Ainsi, nous savons quand les boutons sont 'relâchés'.
uint16_t precedentTouche = 0;
uint16_t actuelTouche = 0;
void setup () {
Serial.begin(9600);
while (!Serial) { // indispensable pour empêcher un Arduino leonardo/micro de démarrer trop vite !
delay(10);
}
Serial.println("Programme de test du capteur capacitif MPR121 avec la bibliothèque Adafruit MPR121");
// L'adresse par défaut est 0x5A, si elle est liée à 3.3V, elle est 0x5B.
// Si elle est liée à SDA, c'est 0x5C et si elle est liée à SCL, c'est 0x5D.
if (!cap.begin(0x5A)) {
Serial.println("Le MPR121 n'a pas été trouvé, vérifiez le cablage ?");
while (1);
}
Serial.println("MPR121 trouvé !");
}
void loop() {
// récupère les broches actuellement touchés
actuelTouche = cap.touched();
for (uint8_t i = 0; i < 12; i++) {
// si *est* touché et *n'était pas* touché avant, alerte !
if ((actuelTouche & _BV(i)) && !(precedentTouche & _BV(i)) ) {
Serial.print("Broche N° ");Serial.print(i); Serial.print(" touché");
}
// si elle *était* touchée et qu'elle ne l'est plus, alerte !
if (!(actuelTouche & _BV(i)) && (precedentTouche & _BV(i)) ) {
Serial.print("Broche N° ");Serial.print(i); Serial.println("relachée");
}
}
// Mémorisation
precedentTouche = actuelTouche;
}| Généralités | Alimentation | 3 à 5 Vcc |
| Interface | I2C et SPI sur connecteur au pas de 2,54 mm | |
| Dimensions | 30 x 14 x 10 mm | |
| Poids | 10 g | |
| Température | Plage de mesure | - 40 à 85 °C |
| Humidité | Plage de mesure | 0 à 100 % RH |
| Précision relative | ± 3 % RH | |
| Temps de réponse | 8 sec | |
| Pression atmosphérique | Plage de mesure | 300 à 1100 hPa |
| Précision absolue | ± 1 hPa | |
| Qualité de l'air (IAQ) | Plage de mesure | 0 à 500 (valeur de résistance) |
| Temps de réponse | 1 sec |
| Capteur BME 680 | ||
|---|---|---|
| Avant le setup | Importation des bibliothèques | #include "bsec.h" |
| Création de l’objet | Bsec ''objet;'' | |
| Dans le setup | Démarrage de l’objet | Wire.begin(); ''objet''.begin(BME680_I2C_ADDR_SECONDARY, Wire); //Configuration du capteur bsec_virtual_sensor_t sensorList[4] = { BSEC_OUTPUT_RAW_PRESSURE, BSEC_OUTPUT_IAQ, BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_TEMPERATURE, BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_HUMIDITY, }; ''objet''.updateSubscription(sensorList, 4, BSEC_SAMPLE_RATE_LP); |
| Dans le loop | Utilisation | if(''objet''.run()){ // Dès que la mesure est effectuée, on affiche les valeurs ''objet''.temperature; ''objet''.humidity; ''objet''.pressure; ''objet''.iaq; //indice de qualité de l'ai 0 -500 ''objet''.accuracy; // fiabilité des mesures (0 -> calibration 3-> mesures fiables) } |
#include "bsec.h" // ajout de la bibliothèque Bsec de Bosh
Bsec iaqSensor; // creation de l'objet Iaq
void setup(void)
{
Serial.begin(115200); // Initialisation de la connexion série
Wire.begin(); // Démarrage de la connexion I2C avec le capteur
iaqSensor.begin(BME680_I2C_ADDR_SECONDARY, Wire); // démarrage du capteur
bsec_virtual_sensor_t sensorList[4] = { // Configuration du capteur
BSEC_OUTPUT_RAW_PRESSURE,
BSEC_OUTPUT_IAQ,
BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_TEMPERATURE,
BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_HUMIDITY,
};
iaqSensor.updateSubscription(sensorList, 4, BSEC_SAMPLE_RATE_LP); // configuration du capteur
}
void loop(void)
{
if (iaqSensor.run()) { // Dès que l'on reçoit des mesures
Serial.print("temperature : ");
Serial.println(iaqSensor.temperature); // Affichage de la température
Serial.print("humidite : ");
Serial.println(iaqSensor.humidity); // Affichage de l'humidité
Serial.print("pression : ");
Serial.println(iaqSensor.pressure); // Affichage de la pression en Pascal
Serial.print("IAQ : ");
Serial.println(iaqSensor.iaq); // Indice de la qualité de l'air
Serial.print("iAQ accuracy : ");
Serial.println(iaqSensor.iaqAccuracy); // Indice de calibration (attendre qu'il passe à 3 pour exploiter les mesures environ 2h)
}
}| Avant le Setup | Importation de la bibliothèque | #include |
| Création de l’objet | AirGradient monCapteur = AirGradient(DIY_BASIC); | |
| Dans le Setup | Démarrage de l’objet | monCapteur.s8.begin(&Serial); // démarrage du capteur |
| Dans le Loop | Utilisation | int CO2 = monCapteur.s8.getCo2(); |
#include // import de la bibliothèque Air Gradient
AirGradient monCapteur = AirGradient(DIY_BASIC); // Création de l'objet "monCapteur"
void setup(){
Serial.begin(9600); // Démarrage de la liaison série
monCapteur.s8.begin(&Serial); // Démarrage et initialisation de l'objet
}
void loop(){
int CO2 = monCapteur.s8.getCo2(); // mesure brute du CO2 placée dans la variable "CO2"
Serial.print("Taux de CO2 : ");
Serial.println(CO2); // Affichage du CO2 en ppm
delay(5000); // attente de 5 secondes (le temps de mesure du capteur est de 2s)
} _________________
/ D1 mini \
|[ ]RST Tx[ ]| -> UART_RxD
|[ ]A0 -GPIO Rx[ ]| -> UART_TxD
|[ ]D0-16 5-D1[ ]|
|[ ]D5-14 4-D2[ ]|
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]|
|[ ]D8-15 GND[X]| -> G0
|[ ]3V3 . 5V[X]| -> G+
| +---+ |
|_______|USB|_______|
________________________
| |° ° ° ° ° °| | |
+5V <- G+ |[X]| ° ° ° ° °/ |[ ]| DVCC_out
GND <- G0 |[X]|° ° ° ° °/ |[X]| UART_RxD -> Tx
Alarm_OC |[ ]|_°_°_°_°| |[X]| UART_TxD -> Rx
PWM 1Khz |[ ]| |[ ]| UART_R/T
| | SenseAir® S8 |[ ]| bCAL_in/CAL
|___|________________|___|| Potentiomètre | ||
| Avant le Setup | Importation de la bibliothèque | |
| Création de l’objet | ||
| Dans le Setup | Démarrage de l’objet | pinMode(A0,INPUT) ; |
| Dans le Loop | Utilisation | int valeur = analogRead(A0) ; |
int sensorPin = A0; // variable globale broche entrée potentiomètre
void setup() {
Serial.begin(115200); //initialisation du port série (pour voir les valeurs dans la console)
}
void loop() {
// lecture des valeurs de la broche A0
int sensorValue = analogRead(sensorPin);
//affichage des valeurs dans la console
Serial.println(sensorValue);
}| Capteur de distance SR04 | ||
| Avant le Setup | Importation de la bibliothèque | #include |
| Création de l’objet | Ultrasonic ultrasonic(broche trig, broche echo); | |
| Dans le Setup | Démarrage de l’objet | |
| Dans le Loop | Utilisation | int distanceCM = ultrasonic.read(); |
//Ajout de la bibliothèque ultrasonic
#include
//Création de l'objet ultrasonic
Ultrasonic ultrasonic(12, 13);
void setup() {
Serial.begin(9600); // démarrage de la connexion série
}
void loop() {
//utilisation de l'objet
int distance = ultrasonic.read();
// affichage de la distance dans le terminal série
Serial.print("Distance in CM: ");
Serial.println(distance);
delay(1000); //délais d'une seconde
}| TTP223 | ||
| Avant le Setup | Importation de la bibliothèque | |
| Création de l’objet | const int brocheCapteur = D2; | |
| Dans le Setup | Démarrage de l’objet | pinMode(brocheBouton, INPUT); |
| Dans le Loop | Utilisation | digitalRead(brocheCapteur); |
///////////////////////
// Capteur Capacitif //
// TTP223 //
///////////////////////
/*
Ce programme est un exemple de base du capteur capacitif TTP223.
Il écrit "vous avez touché le capetur !" sur le moniteur série lorsque le capteur est activé.
Lolin (Wemos) D1 mini
_________________
/ D1 mini \
|[ ]RST TX[ ]| Capteur capacitif TTP223
|[ ]A0 -GPIO RX[ ]| +-------------+
|[ ]D0-16 5-D1[ ]| .--|[X]VCC /‾‾‾‾\|
|[ ]D5-14 4-D2[X]|-----------|--|[X]I/O| |
|[ ]D6-12 0-D3[ ]| .-----|--|[X]GND \____/|
|[ ]D7-13 2-D4[ ]| / | |_____________|
|[ ]D8-15 GND[X]|---' /
|[ ]3V3 . 5V[X]|----------'
| +---+ |
|_______|USB|_______|
Matériel :
- Des fils dupont.
- Un LOLIN (Wemos) D1 mini
- Capteur capacitif TTP223
Schéma de l'Arduino en ASCII-ART CC-By http://busyducks.com/ascii-art-arduinos
Sous licence CC-By-Sa (http://creativecommons.org/licenses/by-nc-sa/3.0/)
___
/ ___ \
|_| |
/_/
_ ___ _
|_| |___|_| |_
___|_ _|
|___| |_|
Les petits Débrouillards - janvier 2023- CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/
Inspiré de :
TTP223B-Capacitive-Touch-Switch-Module - 08 Nov 2020
by Amir Mohammad Shojaee @ Electropeak
https://electropeak.com/learn/interfacing-ttp223-capacitive-switch-butto-touch-sensor-with-arduino/
*/
const int brocheCapteur = D2;
void setup() {
Serial.begin(9600);
// initialisation de la broche en entrée (INPUT)
pinMode(brocheCapteur, INPUT);
}
void loop() {
if(digitalRead(brocheCapteur) == HIGH){
Serial.println("Vous avez touché le capteur !");
while(digitalRead(brocheCapteur) == HIGH){}
}
}dot_clean /Volumes/ par le nom de volume de votre carte SD.| DFPlayer Mini MP3 | ||
| Avant le Setup | Importation de la bibliothèque | #include #include |
| Création de l’objet | SoftwareSerial mySoftwareSerial(D5, D6); //TX, RX - attention il y a une erreur sur le site de DFRobot DFRobotDFPlayerMini myDFPlayer ; | |
| Dans le Setup | Démarrage de l’objet | mySoftwareSerial.begin(9600) ; myDFPlayer.begin(mySoftwareSerial) ; |
| Dans le Loop | Utilisation | myDFPlayer.setTimeOut(500) ; myDFPlayer.volume(20) ; myDFPlayer.play(1); |
// DFPlayer Code minimal pour test
#include
#include
SoftwareSerial mySoftwareSerial(D5, D6); // TX, RX
DFRobotDFPlayerMini myDFPlayer ;
void setup() {
mySoftwareSerial.begin(9600) ;
myDFPlayer.begin(mySoftwareSerial) ;
}
void loop() {
// Joue la premiere chanson de la carte SD pendant 10 secondes
myDFPlayer.setTimeOut(500) ;
myDFPlayer.volume(10) ; // fixe le son à 10 (peut aller jusqu'à 30 maximum)
myDFPlayer.play(1); // joue le premier fichier son.
delay(10000); //pause de 10 secondes
} | Plage de mesure | 1-500 μg/m³ – Max 1000 μg/m³ |
| Taille des particules | 0,3μm, 0,5μm, 1,0μm, 2,5μm, 5μm, 10μm |
| Cannaux de mesure | PM1,PM2,5, PM10 (μg/m³ , concentration /0,1L) |
| Résolution | 1 μg/m³ |
| Erreur | +/- 10 μg/m³ (25°C 50% humidité) |
| Temps de démarrage | 10 secondes |
| Normes | [https://www.iso.org/fr/standard/53394.html ISO 14644-1] |
| Durée de vie | 2 ans en intérieur |
| Tension d’alimentation | 5V ± 3 % |
| Protocole de communication | I2C / UART série |
| Avant le Setup | Importation de la bibliothèque | #include |
| Création de l’objet | Tomoto_HM330X sensor; | |
| Dans le Setup | Démarrage de l’objet | sensor.begin() |
| Dans le Loop | Utilisation | int pm1 = sensor.std.getPM1(); int pm2_5 = sensor.std.getPM2_5(); int pm10 = sensor.std.getPM10(); |
#include //Import de la bibliothèque HM3301
Tomoto_HM330X sensor; // Création de l'objet capteur
void setup() {
Serial.begin(115200); // Initialisation de la connexion série
delay(100);
Wire.begin(D2, D1); // Démarrage de la connexion I2C (D2 : SDA / D1 : SDL)
if (!sensor.begin()) { // Démarrage du capteur
Serial.println("Probleme de connexion, vérifiez le cablage");
while (1);
}
}
void loop() {
if (!sensor.readSensor()) { // lecture du capteur
Serial.println("Probleme de lecture du capteur HM330X");
} else {
Serial.print("PM1.0 ug/m^3 : ");
Serial.println(sensor.std.getPM1()); // affichage de la concentration de PM1.0 en ug/m³
Serial.print("PM2.5 ug/m^3 : ");
Serial.println(sensor.std.getPM2_5()); // affichage de la concentration de PM2_5 en ug/m³
Serial.print("PM10 ug/m^3 : ");
Serial.println(sensor.std.getPM10()); // affichage de la concentration de PM10 en ug/m³
}
delay(5000);
} | Vibration Sensor SW-420 | ||
| Avant le Setup | Importation de la bibliothèque | Aucunes bibliothèques |
| Création des variables | int Vibration_signal = 7; int Sensor_state = 1; | |
| Dans le Setup | Configuration de la broche | pinMode(Vibration_signal, INPUT); |
| Dans le Loop | Utilisation | Serial.print("État des vibrations : "); Sensor_state = digitalRead(Vibration_signal); if (Sensor_state == 1) { Serial.println("Détection des vibrations"); } else { Serial.println("Pas de vibration"); } delay(50); |
int Vibration_signal = 7;
int Sensor_state = 1;
void setup() {
pinMode(Vibration_signal, INPUT);
Serial.begin(9600);
}
void loop() {
Serial.print("État des vibrations : ");
Sensor_state = digitalRead(Vibration_signal);
if (Sensor_state == 1) {
Serial.println("Détection des vibrations");
} else {
Serial.println("Pas de vibration");
}
delay(50);
}| End-Stop Sensor | ||
| Avant le Setup | Importation de la bibliothèque | #include |
| Création de l'objet et Configuration de la broche | ezButton limitSwitch(7); | |
| Dans le Setup | Configuration du temps de rebond | limitSwitch.setDebounceTime(50); |
| Dans le Loop | Utilisation | limitSwitch.loop(); if(limitSwitch.isPressed()) Serial.println("L'interrupteur de fin de course: NON TOUCHÉ -> TOUCHÉ"); if(limitSwitch.isReleased()) Serial.println("L'interrupteur de fin de course: TOUCHÉ -> NON TOUCHÉ"); int state = limitSwitch.getState(); if(state == HIGH) Serial.println("L'interrupteur de fin de course: NON TOUCHÉ"); else Serial.println("L'interrupteur de fin de course: TOUCHÉ"); |
#include
ezButton limitSwitch(7); // créer un objet ezButton qui s'attache à la broche 7
void setup() {
Serial.begin(9600);
limitSwitch.setDebounceTime(50); // fixer le temps de rebond à 50 millisecondes
}
void loop() {
limitSwitch.loop(); // DOIT appeler la fonction loop() en premier
if(limitSwitch.isPressed())
Serial.println("L'interrupteur de fin de course: NON TOUCHÉ -> TOUCHÉ");
if(limitSwitch.isReleased())
Serial.println("L'interrupteur de fin de course: TOUCHÉ -> NON TOUCHÉ");
int state = limitSwitch.getState();
if(state == HIGH)
Serial.println("L'interrupteur de fin de course: NON TOUCHÉ");
else
Serial.println("L'interrupteur de fin de course: TOUCHÉ");
}| SW-520D | ||
| Avant le Setup | Importation de la bibliothèque | Aucune Librairies |
| Définition des pins et des variables | #define inPin 7 int value = 0 | |
| Dans le Setup | Configuration des pins | pinMode(inPin, INPUT); Serial.begin(9600); |
| Dans le Loop | Utilisation | value = digitalRead(inPin); |
#define inPin 7
int value = 0;
void setup() {
pinMode(inPin, INPUT);
Serial.begin(9600);
}
void loop() {
value = digitalRead(inPin);
Serial.println("Valeur: ");
Serial.println(value);
}| Del RVB | ||
| Avant le Setup | Importation de la bibliothèque | Aucunes bibliothèques |
| Définition des pins | #define LED_RED #define LED_GREEN #define LED_BLUE | |
| Dans le Setup | Configuration des pins | pinMode(LED_RED, OUTPUT); pinMode(LED_GREEN, OUTPUT); pinMode(LED_BLUE, OUTPUT); |
| Dans le Loop | Utilisation | digitalWrite(LED_RED, LOW); //on allume la couleur Rouge digitalWrite(LED_GREEN, HIGH); //on éteint la couleur Verte digitalWrite(LED_BLUE, HIGH); //on éteint la couleur Bleue |
#define LED_BLUE 2 //définition de la pin Bleue
#define LED_GREEN 3 //définition de la pin Verte
#define LED_RED 4 //définition de la pin Rouge
void setup() {
pinMode(LED_BLUE, OUTPUT); //configuration de la pin Bleu en mode Sortie
pinMode(LED_GREEN, OUTPUT); //configuration de la pin Verte en mode Sortie
pinMode(LED_RED, OUTPUT); //configuration de la pin Rouge en mode Sortie
}
void loop() {
digitalWrite(LED_BLUE, HIGH); //extinction de la pin
digitalWrite(LED_GREEN, HIGH); //extinction de la pin
digitalWrite(LED_RED, LOW); //allumage de la pin
delay(1000);
digitalWrite(LED_BLUE, HIGH); //extinction de la pin
digitalWrite(LED_GREEN, LOW); //allumage de la pin
digitalWrite(LED_RED, HIGH); //extinction de la pin
delay(1000);
digitalWrite(LED_BLUE, LOW); //allumage de la pin
digitalWrite(LED_GREEN, HIGH); //extinction de la pin
digitalWrite(LED_RED, HIGH); //extinction de la pin
delay(1000);
}#define LED_BLUE 9 //définition de la pin Bleue
#define LED_GREEN 10 //définition de la pin Verte
#define LED_RED 11 //définition de la pin Rouge
void setup() {
pinMode(LED_BLUE, OUTPUT); //configuration de la pin Bleu en mode Sortie
pinMode(LED_GREEN, OUTPUT); //configuration de la pin Verte en mode Sortie
pinMode(LED_RED, OUTPUT); //configuration de la pin Rouge en mode Sortie
}
void loop() {
analogWrite(LED_BLUE, 0); //extinction de la pin
analogWrite(LED_GREEN, 0); //extinction de la pin
analogWrite(LED_RED, 127); //allumage de la pin à 50%
delay(1000);
analogWrite(LED_BLUE, 0); //extinction de la pin
analogWrite(LED_GREEN, 127); //allumage de la pin à 50%
analogWrite(LED_RED, 0); //extinction de la pin
delay(1000);
analogWrite(LED_BLUE, 127); //allumage de la pin à 50%
analogWrite(LED_GREEN, 0); //extinction de la pin
analogWrite(LED_RED, 0); //extinction de la pin
delay(1000);
}| TCS 3472 | ||
| Avant le Setup | Importation de la bibliothèque | #include #include "Adafruit_TCS34725.h" |
| Initialisation de l'objet | Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_614MS, TCS34725_GAIN_1X); | |
| Dans le Setup | Configuration de l'objet | if (tcs.begin()) { Serial.println("Capteur Trouvé"); } else { Serial.println("Aucun TCS34725 trouvé ... vérifie la connections"); while (1); } |
| Dans le Loop | Utilisation | uint16_t r, g, b, c, colorTemp, lux; tcs.getRawData(&r, &g, &b, &c); colorTemp = tcs.calculateColorTemperature_dn40(r, g, b, c); lux = tcs.calculateLux(r, g, b); Serial.println("Détection des couleurs"); Serial.print("Lux: "); Serial.println(lux, DEC); Serial.print("ROUGE: "); Serial.println(r, DEC); Serial.print("VERT: "); Serial.println(g, DEC); Serial.print("BLEU: "); Serial.println(b, DEC); |
#include
#include "Adafruit_TCS34725.h"
Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_614MS, TCS34725_GAIN_1X);
void setup() {
Serial.begin(9600);
if (tcs.begin()) {
Serial.println("Capteur Trouvé");
} else {
Serial.println("Aucun TCS34725 trouvé ... vérifier la connections");
while (1);
}
}
void loop() {
uint16_t r, g, b, c, colorTemp, lux;
tcs.getRawData(&r, &g, &b, &c);
colorTemp = tcs.calculateColorTemperature_dn40(r, g, b, c);
lux = tcs.calculateLux(r, g, b);
Serial.println("Détection des couleurs");
Serial.print("Lux: ");
Serial.println(lux, DEC);
Serial.print("ROUGE: ");
Serial.println(r, DEC);
Serial.print("VERT: ");
Serial.println(g, DEC);
Serial.print("BLEU: ");
Serial.println(b, DEC);
}| TCS 3200 | ||
| Avant le Setup | Importation de la bibliothèque | Aucune Librairies |
| Définition des pins et des variables | #define S0 4 #define S1 5 #define S2 6 #define S3 7 #define sensorOut 8 int redFrequency = 0; int greenFrequency = 0; int blueFrequency = 0; | |
| Dans le Setup | Configuration des pins & initialisation des valeurs | pinMode(S0, OUTPUT); pinMode(S1, OUTPUT); pinMode(S2, OUTPUT); pinMode(S3, OUTPUT); pinMode(sensorOut, INPUT); digitalWrite(S0,HIGH); digitalWrite(S1,LOW); |
| Dans le Loop | Utilisation | redFrequency = pulseIn(sensorOut, LOW); greenFrequency = pulseIn(sensorOut, LOW); blueFrequency = pulseIn(sensorOut, LOW); |
#define S0 4
#define S1 5
#define S2 6
#define S3 7
#define sensorOut 8
int redFrequency = 0;
int greenFrequency = 0;
int blueFrequency = 0;
void setup() {
pinMode(S0, OUTPUT);
pinMode(S1, OUTPUT);
pinMode(S2, OUTPUT);
pinMode(S3, OUTPUT);
pinMode(sensorOut, INPUT);
digitalWrite(S0,HIGH);
digitalWrite(S1,LOW);
Serial.begin(9600);
}
void loop() {
digitalWrite(S2,LOW);
digitalWrite(S3,LOW);
redFrequency = pulseIn(sensorOut, LOW);
Serial.print("R = ");
Serial.print(redFrequency);
delay(100);
digitalWrite(S2,HIGH);
digitalWrite(S3,HIGH);
greenFrequency = pulseIn(sensorOut, LOW);
Serial.print(" V = ");
Serial.print(greenFrequency);
delay(100);
digitalWrite(S2,LOW);
digitalWrite(S3,HIGH);
blueFrequency = pulseIn(sensorOut, LOW);
Serial.print(" B = ");
Serial.println(blueFrequency);
delay(100);
}| Motion Sensor HC SR-501 | ||
| Avant le Setup | Importation de la bibliothèque | Aucunes bibliothèques |
| Création de l’objet | #define pirPin int val = LOW; bool motionState = false; | |
| Dans le Setup | Démarrage de l’objet | pinMode(pirPin, INPUT); |
| Dans le Loop | Utilisation | val = digitalRead(pirPin); if (motionState == false) |
#define brocheCapteur 2
int val = LOW;
bool etatDetection = false;
void setup() {
Serial.begin(9600);
pinMode(brocheCapteur, INPUT);
}
void loop() {
// la variable etatDetection sert à éviter de "trop boucler".
// cela permet de ne pas écrire en boucle les infos dans le moniteur série.
// et au contraire de n'écrire que lorsqu'il y a un changement d'état de "détecté" à "non détecté"
val = digitalRead(brocheCapteur);
if (val == HIGH) {
if (etatDetection == false) {
Serial.println("Mouvement détecté !");
etatDetection = true;
}
} else if (val == LOW) {
if (etatDetection == true) {
Serial.println("Mouvement non détecté !");
etatDetection = false;
}
}
}#include
#include
Adafruit_BMP280 bmp; // I2C
void setup() {
Serial.begin(9600);
bmp.begin(0x76);
}
void loop() {
Serial.print(F("Temperature = "));
Serial.print(bmp.readTemperature());
Serial.println(" *C");
Serial.print(F("Pressure = "));
Serial.print(bmp.readPressure());
Serial.println(" Pa");
Serial.print(F("Approx altitude = "));
Serial.print(bmp.readAltitude(1013.25)); /* Adjusted to local forecast! */
Serial.println(" m");
Serial.println();
delay(2000);
}| DS18B20 | ||
| Avant le Setup | Importation de la bibliothèque | #include #include |
| Création de l’objet | OneWire oneWire(ONE_WIRE_BUS); // je crée une instance OneWire DallasTemperature sensors(&oneWire); //je passe One Wire à Dallas temperature | |
| Dans le Setup | Démarrage de l’objet | sensors.begin(); |
| Dans le Loop | Utilisation | sensors.requestTemperatures(); //commande pour récupoérer la température //Nous utilisons la fonction ByIndex et, à titre d'exemple, nous obtenons la température du premier capteur uniquement. float tempC = sensors.getTempCByIndex(0); |
// Include the libraries we need
#include
#include
// Data wire is plugged into port 2 on the Arduino
#define ONE_WIRE_BUS 2
// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);
// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);
/*
* The setup function. We only start the sensors here
*/
void setup(void)
{
// start serial port
Serial.begin(9600);
Serial.println("Dallas Temperature IC Control Library Demo");
// Start up the library
sensors.begin();
}
/*
* Main function, get and show the temperature
*/
void loop(void)
{
// call sensors.requestTemperatures() to issue a global temperature
// request to all devices on the bus
Serial.print("Requesting temperatures...");
sensors.requestTemperatures(); // Send the command to get temperatures
Serial.println("DONE");
// After we got the temperatures, we can print them here.
// We use the function ByIndex, and as an example get the temperature from the first sensor only.
float tempC = sensors.getTempCByIndex(0);
// Check if reading was successful
if(tempC != DEVICE_DISCONNECTED_C)
{
Serial.print("Temperature for the device 1 (index 0) is: ");
Serial.println(tempC);
}
else
{
Serial.println("Error: Could not read temperature data");
}
}/*
* Code repris de http://wiki.t-o-f.info/Arduino/%c3%89liminationDuRebondissement
*/
int BUTTON_PIN = 0; //GPIO 0 correspond à la broche D3
int previousButtonState;
int count =0;
unsigned long debounceTimeStamp;
void setup() {
Serial.begin(57600);
pinMode( BUTTON_PIN , INPUT_PULLUP );
previousButtonState = digitalRead( BUTTON_PIN );
}
void loop() {
if ( millis() - debounceTimeStamp >= 5 ) {
int currentButtonState = digitalRead( BUTTON_PIN );
if ( currentButtonState != previousButtonState ) {
debounceTimeStamp = millis();
if ( currentButtonState == LOW ) {
count = count + 1;
Serial.println(count);
}
}
previousButtonState = currentButtonState;
}
}| écran Oled 1,3 pouces | ||
| Avant le Setup | Importation de la bibliothèque | #include #include #include "SH1106Wire.h" |
| Création de l’objet | SH1106Wire display(0x3c, D2, D1); | |
| Dans le Setup | Démarrage de l’objet | display.init(); |
| Dans le Loop | Utilisation | display.clear(); display.drawXbm(0, 0, bitmap_height, bitmap_width, imggrosyeux); display.display(); |
| Photorésistance | ||
| Avant le Setup | Importation de la bibliothèque | |
| Création de l’objet | brochePhotoresistance = A0; (la photorésistance est branchée sur une broche analogique) | |
| Dans le Setup | Démarrage de l’objet | pinMode(brochePhotoresistance, INPUT); |
| Dans le Loop | Utilisation | valeur = analogRead(brochePhotoresistance); |
//////////////////////////////
// La photorésistance //
//////////////////////////////
/*
+-----+
+----[PWR]-------------------| USB |--+
| +-----+ |
| GND/RST2 [ ][ ] |
| MOSI2/SCK2 [ ][ ] A5/SCL[ ] |
| 5V/MISO2 [ ][ ] A4/SDA[ ] |
| AREF[ ] |
| GND[X] |--(led)---|
| [ ]N/C SCK/13[X] |--v230Ωv--|
| [ ]IOREF MISO/12[ ] |
| [ ]RST MOSI/11[ ]~|
| [ ]3V3 +---+ 10[ ]~|
/--(w)---------| [X]5v -| A |- 9[ ]~|
| /--| [X]GND -| R |- 8[ ] |
|--v1kΩv--/ | [ ]GND -| D |- |
| | [ ]Vin -| U |- 7[ ] |
| | -| I |- 6[ ]~|
|___________/--| [X]A0 -| N |- 5[ ]~|
| [ ]A1 -| O |- 4[ ] |
| [ ]A2 +---+ INT1/3[ ]~|
| [ ]A3 INT0/2[ ] |
| [ ]A4/SDA RST SCK MISO TX>1[ ] |
| [ ]A5/SCL [ ] [ ] [ ] RX<0[ ] |
| [ ] [ ] [ ] |
| UNO_R3 GND MOSI 5V ____________/
\_______________________/
Matériel :
- des fils dupont.
- une breadbord
- Arduino
- Une photorésistance,
- une résistance de 1Kiloohms (10, 20, ou 1 kilo-ohms, ajustez la valeur, faites des tests)
Schéma de l'Arduino en ASCII-ART CC-By http://busyducks.com/ascii-art-arduinos
Sous licence CC-By-Sa (http://creativecommons.org/licenses/by-nc-sa/3.0/)
___
/ ___ \
|_| |
/_/
_ ___ _
|_| |___|_| |_
___|_ _|
|___| |_|
Les petits Débrouillards 2023 - CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/
*/
const int brochePhotoresistance = A0; // la photorésistance est branchée sur la broche analogique A0
const int seuil = 300; // c'est la valeur donnée par la photorésistance lorsqu'on l'éclaire au max
// (ça dépend de l'endroit où vous placez votre montage).
int valeur; // mémoriser la valeur de la photorésistance (entre 0-1023)
void setup(){
Serial.begin(9600); // On ouvre la communication série
pinMode(LED_BUILTIN, OUTPUT); // On utilise la led embarquée sur la carte
pinMode(brochePhotoresistance, INPUT); // la broche analogique A0 est configurée en entrée
}
void loop(){
valeur = analogRead(brochePhotoresistance);
int intensiteLed = 1023-valeur; // La uminosité de la led est l'inverse de la lumière reçue par la photorésistance
intensiteLed = intensiteLed-seuil; // On s'assure que la led soit éteinte quand la lumière est maximum
if (intensiteLed<0) intensiteLed=0;// Correction d'une éventuelle d'erreur sur le seuil.
Serial.print("La photoresistance mesure : "); Serial.println(valeur);
Serial.print("La luminosité de la Led est fixée à : "); Serial.println(intensiteLed);
analogWrite(LED_BUILTIN, intensiteLed); // Allume la Led à l'intensité souhaitée
delay(100);// pause
}| BME280 | ||
| Avant le Setup | Importation de la bibliothèque | #include "Seeed_BME280.h" #include |
| Création de l’objet | BME280 bme280; // je crée l'objet "bme280" (qui est un BME280) | |
| Dans le Setup | Démarrage de l’objet | bme280.init(); // ou bme280.init(0x76); ou bme280.init(0x77); |
| Dans le Loop | Utilisation | bme280.getTemperature() |
| Fonction | |
|---|---|
| bme280.getPressure() | Récupère la pression en pascal |
| bme280.getHumidity() | Récupère l'humidité en % |
#include "Seeed_BMP280.h" // import de la bibliothèque BMP280
#include // Import de la bibliothèque I2C
BMP280 bmp280; // création de l'objet
void setup()
{
Serial.begin(9600); //initialisation de la liaison série
bmp280.init(); //initialisation du capteur
}
void loop()
{
float temp = bmp280.getTemperature(); //récupération de la température
Serial.print("Température : "); // affichage de la température dans le terminal série
Serial.println(temp);
} | Servo moteur | ||
| Avant le Setup | Importation de la bibliothèque | #include |
| Création de l’objet | Servo monservo; | |
| Dans le Setup | Démarrage de l’objet | monservo.attach(broche du servo); |
| Dans le Loop | Utilisation | monservo.write(180); |
#include //importation de la bibliothèque servo
Servo monservo; // Création de l'objet monservo
void setup() {
monservo.attach(12); //Démarrage de l'objet
}
void loop() {
monservo.write(180); // En avant toute !
delay(1000); // pendant une seconde
monservo.write(0); // En arrière toute !
delay(1000); // pendant une seconde
} | WS2812B | ||
| Avant le Setup | Importation de la bibliothèque | #include |
| Création de l’objet | #define NUM_LEDS * (* indique le nombre de Led à allumer), #define DATA-PIN 3 (borne de la carte sur laquelle est branchée le ruban de Led, CRGBleds [NUM_LEDS]; | |
| Dans le Setup | Démarrage de l’objet | FastLED.addLeds |
| Dans le Loop | Utilisation | FastLED.show() ; |
#include
// How many leds in your strip?
#define NUM_LEDS 1
// For led chips like WS2812, which have a data line, ground, and power, you just
// need to define DATA_PIN. For led chipsets that are SPI based (four wires - data, clock,
// ground, and power), like the LPD8806 define both DATA_PIN and CLOCK_PIN
// Clock pin only needed for SPI based chipsets when not using hardware SPI
#define DATA_PIN D3
// Define the array of leds
CRGB leds[NUM_LEDS];
void setup() {
// Uncomment/edit one of the following lines for your leds arrangement.
// ## Clockless types ##
FastLED.addLeds(leds, NUM_LEDS); // GRB ordering is assumed
// FastLED.addLeds(leds, NUM_LEDS); // GRB ordering is typical
}
void loop() {
// Turn the LED on, then pause
leds[0] = CRGB::Red;
FastLED.show();
delay(500);
// Now turn the LED off, then pause
leds[0] = CRGB::Black;
FastLED.show();
delay(500);
} | BME280 | ||
| Avant le Setup | pas de bibliothèque | |
| Variable pour un moteur | #define moteurA_1A 15 #define moteurA_2A 13 int vitesse = 128; // 0 à 255 | |
| Dans le Setup | configuration des broches | pinMode(moteurA_1, OUTPUT); pinMode(moteurA_2, OUTPUT); |
| Dans le Loop | Utilisation | digitalWrite(moteurA_1, LOW); analogWrite(moteurA_2, vitesse); |
//////////////////////////
// Contrôleur de moteur //
// L9110 //
// pont en H //
//////////////////////////
/*
_________________
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]|
|[ ]D5-14 4-D2[ ]|
|[ ]D6-12 0-D3[ ]|
A-1B - |[ ]D7-13 2-D4[ ]| LED_BUILTIN
A_1A - |[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
#define moteurA_1A 15
#define moteurA_1B 13
int vitesse = 128; // 0 à 255
void setup() {
// Configuration des ports en mode "sortie"
pinMode(moteurA_1A, OUTPUT);
pinMode(moteurA_1B, OUTPUT);
}
void loop() {
digitalWrite(moteurA_1A, LOW);
analogWrite(moteurA_1B, vitesse);
delay(1000);
analogWrite(moteurA_1A, vitesse);
digitalWrite(moteurA_1B, LOW);
delay(1000);
digitalWrite(moteurA_1A, LOW);
digitalWrite(moteurA_1B, LOW);
delay(1000);
}| MAX9814 | ||
| Avant le Setup | pas de bibliothèque | |
| Création d'une variable | int valeurCapteur; // On prépare une variable pour stocker les valeurs du capteur | |
| Dans le Setup | Démarrage de l’objet | Serial.begin(9600); // on démarre la communication série |
| Dans le Loop | Utilisation | valeurCapteur = analogRead(A0); // On lit la valuer mesurée par le capteur sur la broche A0 Serial.println(valeurCapteur); // On publie sur le moniteur série la valeur récupérée |
/////////////////
// Microphone //
// MAX9814 //
/////////////////
/*
* Un programme pour tester le fonctionnement du microphone MAX9814
* Il utilise le traceur série pour visualiser les signaux récupérés
* pour utiliser le traceur série : cliquez sur Outils/Traceur série
___
/ ___ \
|_| | |
/_/
_ ___ _
|_| |___|_| |_
___|_ _|
|___| |_|
Les petits Débrouillards - Novembre 2022 - CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/
*/
int valeurCapteur; // On prépare une variable pour stocker les valeurs du capteur
void setup() {
// on démarre la communication série
Serial.begin(9600);
}
void loop() {
// On lit la valeur mesurée par le capteur sur la broche A0
valeurCapteur = analogRead(A0);
// On publie sur le traceur série la valeur récupérée
Serial.println(valeurCapteur);
}| Composant | Rôle | Détails |
|---|---|---|
| '''ESP32 (6)''' | Microcontrôleur principal | Gère moteur + LEDs + API en wifi |
| ⚙️ '''Moteur pas à pas / Servo SG90 (4)''' | Action mécanique du socle | 3 positions (basse, moyenne, haute) |
| 💡 '''Bandeau LED NeoPixel (3)''' | Lumière d’ambiance | 12 LEDs RGB |
| 📜 Papier rugueux et épais (1) | décorer et refléter la lumière | environ 60cmx15cm selon la taille du POGL |
| Papier réfléchissant perforer(2) | laisse passer plus ou moins la lumière | 15cm de diamètre, trou aléatoire 1cm de diamètre |
Adafruit_NeoPixel.h → gestion des LEDs avec fil piloteServo.h ou Stepper.h → contrôle du moteur (selon le modèle choisi)main.ino
├── [CONFIG] constantes moteur + LEDs
├── [DOMAIN] types (enum Densite, Color, TramPoint)
├── [DATA] scénario de simulation tram
├── [STATE] variables d'état (couleurs, index, timer)
├── [API HW] moteurs/LEDs (tournerMoteur, setTargetColor, smoothTransition, showColor)
├── [LOGIC] mapping densité → angle/couleur + traitement changement
├── [APP] setup(), loop() non-bloquante (tick simulation)| Potentiomètre | ||
| Avant le Setup | pas besoin de bibliothèque | |
| Déclaration de la broche | int brocheLED =13; | |
| Dans le Setup | Démarrage de l’objet | pinMode(brocheLED, OUTPUT) ; |
| Dans le Loop | Utilisation | analogWrite(brocheLED, ); |
int brocheLED = 13; // variable globale broche sur laquelle est branchée la LED
void setup() {
pinMode(brocheLED, OUTPUT); //la broche est configurée en sortie
}
void loop() {
// la LED peut prendre des valeurs de 0 à 255 (valeur d'intensité lumineuse).
analogWrite(brocheLED,255);
}| Statut (mettre OK + URL ou liens si images dispos sur Wikideb), ou « A ajouter » | |
| Photos | |
| Vidéo | |
| Niveau scolaire (Classes où la notion est étudiée) |
| Spécification | MG90S | MG90D | SG92R | SG90 |
|---|---|---|---|---|
| Poid (g) | 13 | 13,4 | 12 | 9 |
| Couple (Kg) (4,8v) | 2,1 | 1,8 | 2,5 | 1,8 |
| Vitesse (sec/60deg) | 0,1 | 0,1 | 0,1 | 0,1 |
| A(mm) | 32,5 | 32,5 | 34,5 | 34,5 |
| B(mm) | 22,6 | 22,8 | 22,8 | 22,8 |
| C(mm) | 28,5 | 28,4 | 26,7 | 26,7 |
| D(mm) | 12 | 12,4 | 12,6 | 12,6 |
| E(mm) | 31,5 | 32,1 | 32,5 | 32,5 |
| F(mm) | 19,8 | 18.5 | 16 | 16 |
6H5-R) donc de 6 atomes de carbone reliés par une chaîne de 3 atomes de carbone (anneau de pyrane oxygéné = cycle pyrone). Les flavonoïdes sont souvent liés à une molécule de glucide (glucose, arabinose ou rhamnose) pour former des glucosoïdes (flavonoïdes glycosides), mais certaines flavonoïdes sont aglycones (non reliées à une glucides (comme les flavanols).
* Une tasse de thé peut en contenir jusqu'à 80 à 200 mg de polyphénols (selon le type de thé et la technique de préparation de l'infusion).
* Dans 100 grammes de thé vert séché on retrouve : (16 grammes) de polyphénols totaux dont 14.2 g de cathéchines (dont 4,7 g d'EGCG) et 0,0 g de Théaflavines et théarubigénines.
* Dans 100 grammes de thé noir séché on retrouve : (15,6 grammes) de polyphénols totaux dont 4.0 g de cathéchines (dont 2,0 g d'EGCG) et 0,94 g de Théaflavines et 1,8 g de théarubigénines.
*Les flavonoïdes sont des antioxydants pouvant piéger les radicaux libres (antiradicalaires) et protéger les cellules des agressions :
* préviennent certains cancers par inhibition l'urokinase, nécessaire à la progression des tumeurs ;
* l’activité antioxydant de ces polyphénols explique l'action préventive du thé contre le vieillissement cellulaire.
* Les flavonoïdes peuvent chélater le fer non hématique contenu dans les plantes, le lait et les médicaments (l'intègre dans leur structure en anneau), donc diminuent son absorption au niveau du tube digestif d'environ 70 %.au), donc diminuent son absorption au niveau du tube digestif d'environ 70 %.)Vous avez entré un nom de page invalide, avec un ou plusieurs caractères suivants :
< > @ ~ : * € £ ` + = / \ | [ ] { } ; ? #