Clase de primer año STI2D

TP Arduino
Tabla de contenidos
1. Instalación y configuración de la tarjeta Arduino..............................................................................................................2
1.1. Tarjeta Arduino...........................................................................................................................................................2
1.2. El escudo de expansión E/S.........................................................................................................................................2
1.3. Estructura de un programa.......................................................................................................................................3
1.4. Interface de développement.....................................................................................................................................3
2. Utilización de la salida digital.....................................................................................................................................4
2.1. Parpadeo de un LED..........................................................................................................................................4
2.2. Parpadeo de 2 LED...........................................................................................................................................5
3. Utilización de la entrada digital......................................................................................................................................6
3.1. Detección de un Botón de Presión...............................................................................................................................6
4. Utilización de la entrada analógica.....................................................................................................................................7
4.1. Medida de la iluminancia...........................................................................................................................................7
4.2. Telemetría................................................................................................................................................................9
4.2.1. Sensor SRF05...........................................................................................................................................................9
4.2.2. Sensor Ultrasonido Ranger
4.3. Simulación tienda eléctrica.....................................................................................................................................11
5. Utilización de la salida MLI.............................................................................................................................................14
5.1. Mando de un motor de corriente continua............................................................................................................14
5.2. Control de un motor mediante un potenciómetro..................................................................................16
5.3. Programación de un motor...................................................................................................................................17
5.4. Servo motor..........................................................................................................................................................19
6. Pantalla LCD................................................................................................................................................................21
7. Módulos..........................................................................................................................................................................23
escudos...........................................................................................................................................................................23
8. Referencias......................................................................................................................................................................24

5-TP_arduino.odt 1
 Clase de primero STI2D

1. Instalación y configuración de la placa Arduino

1.1. Tarjeta Arduino
Utilizaremos una placa Arduino Uno. Emplea un microcontrolador ATMEGA328P alimentado a 5 V. Hay 14
entradas/salidas digitales de las cuales 6 son utilizables en PWM1Hay 6 entradas analógicas. El microcontrolador tiene un
PUEDO2con 10 bits de resolución. En la placa, hay un circuito que permite gestionar fácilmente el USB3quién puede alimentar
la tarjeta.

• Memoria Flash de 32 ko
• Memoria RAM 2 ko
• Memoria EEPROM 1 kilo
• Frecuencia de reloj 16 MHz
• Corriente máx. E/S 40 mA
Para saber más, consulte la página:[Link]

1.2. El shield de expansión E/S

El escudo de extensión E/S proporciona un
método fácil de conectar sensores
o servos para la tarjeta Arduino. Él
aumenta el número de E/S digitales y
analógicos. También proporciona unos
broches PWM distintas que son
compatibles con el conector de servo
estándar. La toma de comunicación
proporciona un medio extremadamente fácil para
conectar un módulo inalámbrico, como el
módulo APC220 RF o el
módulo DF-Bluetooth. Dispone de una
entrada de potencia individual para los
servos.

1 Modulación por Ancho de Pulso (o MLI por modulador de ancho de pulso)

2 Convertidor Analógico Digital
3 Bus Universal en Serie
5-TP_arduino.odt 2
 Clase de primera STI2D

1.3. Estructura de un programa

Un ejemplo de programa se da a continuación.

• El comentario de descripción del programa, llamado sketch, comienza con /* y termina con */.
• Luego se coloca la definición de las constantes y variables con las instrucciones const e int.
• Luego viene la configuración de las entradas / salidas con la instrucción void setup(). La secuencia de instrucciones es
précédé de { et se termine par }.
• Se define por la instrucción void loop() la programación de las interacciones y comportamientos. La secuela
d’instructions está precedido de { y terminado por }.

1.4. Interfaz de desarrollo

Para utilizar la interfaz de desarrollo:

1. Lanza el software Arduino

.
2. Verifica que la tarjeta Arduino Uno esté bien reconocida en: Herramientas > Tipo de tarjeta > Arduino U

5-TP_arduino.odt 3
 Clase de primera STI2D
3. Conectar la tarjeta a un puerto USB. Verificar que el puerto COM esté bien configurado. Herramientas > Puerto serie > COM

4. Verificar que el puerto COM X es reconocido por Windows: Panel de Control > Sistema y seguridad >
Administrador de dispositivos > Puertos: Arduino Uno (COM X).

2. Utilización de la salida digital

2.1. Parpadeo de un LED
Abrir el archivo Blink por: Archivo > Ejemplos > [Link] > Blink
Para comprender la sintaxis y el papel de una instrucción, utilizar la página:[Link]
1. Realizar el esquema de montaje a continuación (tener cuidado con elsentido de polarización del LED).
Broche 12: módulo LED

con escudo
extensión I/O
2. Modificar el programa de tal manera que la salida a la que conectaremos el LED sea la salida 12.
3. Modificar las instrucciones para que el período sea de 1 s y la duración de encendido del LED sea de 100 ms.
4. Inicie la ejecución del programa haciendo clic en el botón debajo de Edición:

/*
parpadeo de diodo
*/

const int led = 12; // pin 12 para el LED

// esta función solo se ejecuta una vez

vacío configuración()
{
pinMode(led, SALIDA); // se define el pin como salida
}

// esta función se ejecuta indefinidamente

vacío bucle()
{
digitalWrite(led, HIGH); // led encendida

5-TP_arduino.odt 4
 Clase de primer año STI2D

delay(100); // allumé 100ms

digitalWrite(led, LOW); // led apagada
delay(100); // apaga 100ms
}

2.2. Parpadeo de 2 LED

1. Modificar el programa para que dos LED se enciendan en oposición de fase como en la siguiente tabla:

LED 1 Broche 11 Allumée Apagada

LED 2 Broche 12 Apagada Encendida

2. Modificar el esquema de montaje como se indica a continuación:

Broche 11 : módulo LED1
Broche 12 : módulo LED2

/*
parpadeo de 2 diodos alternos
*/

const int led1 = 11; // conector 11 para el LED 1

const int led2 = 12; // broche 12 para el LED 2

// esta función solo se ejecuta una vez

vacío configuración()
{
pinMode(..., SALIDA); se define el LED 1 como salida
pinMode(..., SALIDA); // se define el LED 2 como salida
}

// esta función buclea indefinidamente

vacío bucle()
{
// a completar
// ...
delay(1000); // duración 1s

// a completar
// ...
delay(1000); // duración 1s
}

5-TP_arduino.odt 5
 Clase de primer año STI2D

Para ver el resultado, haga clic en la imagen

3. Utilización de la entrada digital

3.1. Detección de un Botón Pulsador
1. Realizar el esquema de montaje a continuación (prestar atención asentido de polarización del LED).
Se usará un botón pulsador (BP) que controlará un LED a través de la placa Arduino.
Broche 4: módulo LED
Broche 3 : módulo BP

2. Modificar este programa para que la tarjeta Arduino controle el LED al presionar el botón.
/*

5-TP_arduino.odt 6
 Classe de première STI2D

detección de botón pulsador

*/

const int led = ...; // broche 4 para el LED

const int boton = 3; broche 3 para el botón pulsador

// la función de configuración se ejecuta una vez cuando presionas reiniciar o enciendes la placa
vacío configuración()
{
pinMode(led, ...); se define el LED como salida
pinMode(boton, ...); definimos el botón de entrada
}

la función de bucle se ejecuta una y otra vez para siempre

vacío bucle()
{
// botón de conferencia
si ( digitalRead(boton) == ... )
digitalWrite(led, ...); // led encendida
otro
digitalWrite(led, ...); // led apagada

retraso(...); // estabilización 200 ms

}

Para ver el resultado, haga clic en la imagen

4. Utilización de la entrada analógica

4.1. Medida de la illuminación
El sensor de luminosidad utilizado es el LDR VT935G (o equivalente de la serie VT900).

5-TP_arduino.odt 7
 Clase de primer STI2D

Por efecto fotovoltaico, la energía radiante se transforma en energía eléctrica.

La resistencia interna del sensor es inversamente proporcional a la luminosidad en una escala logarítmica.
1. Realizar el esquema de montaje a continuación:
Broche 9 : módulo LED
Broche A0 : módulo sensor de luminosidad

2. Visualizar la luminosidad medida.

1. abrir una terminal

2. Ajustar la velocidad de
comunicación a 9600 baudios
3. Cubrir el detector
4. Relevar los valores:
con luz
- sin luz
5. Deduzca el valor umbral

3. Modificar el programa a continuación para ajustar el umbral de detección que encenderá el LED.
/*
detección de luminosidad
*/

const int led = 9; // broche 9 para el LED

const int lux = ...; broche analógica A0 para el sensor

// esta función solo se ejecuta una vez

vacío configuración()
{
pinMode(...); // definimos el pin 9 como salida

[Link](9600); // inicializa la velocidad del puerto serie

}

// esta función se ejecuta indefinidamente

5-TP_arduino.odt 8
 Clase de primer año STI2D

void bucle()
{
int valor = analogRead(...); // sensor lecture
[Link](valor); // mostrar valor en el terminal serie

si ( valor < 0 ) // detección del umbral de luminosidad

digitalWrite(led, ...); led encendida
else
digitalWrite(led, ...); led apagada

retraso(10); // stabilisation 10 ms
}

4.2. Telemetría
Se quiere medir una distancia por telemetría ultrasónica.

4.2.1. Sensor SRF05

El sensor SRF05 es un emisor receptor de ultrasonido (40 kHz), con un alcance que teóricamente va de 1 a 400 cm en un
ángulo de 30°. Permite el uso de 1 o 2 pines para la emisión/receptión (la segunda solución acelera el
tratamiento).
1. Realiza el diagrama de montaje a continuación:
Broche 4 : Trigger
Broche 7 : Eco
Broche 8 : LED

2. Modificar el programa para que el LED se encienda cuando la distancia a un obstáculo sea inferior a 20 cm.
/*
Telemetría por ultrasonido
*/

constante int led = ...; // broche 8 para el LED

const int emetteur = ...; // broche 7 para envío de señal
const int receptor = ...; // broche 4 para recepción de señal

/* Routine d'initialisation */
vacío configuración()
{
[Link](9600); // Inicialización del puerto COM

pinMode(...); LED en salida

pinMode(...); // señal en salida
pinMode(...); // eco en entrada

5-TP_arduino.odt 9
 Clase de primer STI2D

digitalWrite(emetteur, BAJO);
}

vacío bucle()
{
// envío de salve (impulsión emisora)
digitalWrite(emetteur, ALTO);
retrasarMicrosegundos(10);
digitalWrite(emetteur, BAJO);

Tratamiento del rebote de la impulsión

distancia larga = pulseIn(receptor, ALTO);
distancia /= 58; //Traducción en cm

// mostrar distancia en el terminal serie

[Link]("Distancia : ");
[Link](...);
cm

si ( distancia < ... ) // umbral de distancia mínima (en cm)

digitalWrite(...); // led allumée
else
digitalWrite(...); led apagada

retraso(50);
}

4.2.2. Sensor de Rango Ultrasonico

1. Conectar el sensor según el montaje a continuación:

2. Modificar el programa para que el LED se encienda cuando la distancia a un obstáculo sea inferior a 20 cm.
/*
Télémétrie por ultrasonido con biblioteca ultrasonic
*/

#include <Ultrasonido.h>// [Link]

Estudio/Grove_Ranger_Ultrasonido

const int led = ...; broche 8 para la LED

const int capteur = 7;// pin 7 para sensor US

Ultrasonido ultrasonido(capteur); // inicialización del sensor US

/* Rutina de inicialización */
vacío configurar()
{
[Link](9600); // Inicialización del puerto COM

5-TP_arduino.odt 10
 Clase de primera STI2D

pinMode(...); // LED en salida

}

vacío bucle()
{
distancia_larga = [Link]ímetros();

// mostrar distancia en terminal serie

[Link]("Distancia : ");
[Link](...);
[Link](" cm");

si ( distancia < ... ) umbral de distancia mínima

digitalWrite(...); led encendida
else
digitalWrite(...); // led apagada

retraso(50);
}

4.3. Simulación de tienda eléctrica

Vamos a simular el funcionamiento de un toldo eléctrico automático.
A partir de un cierto umbral de luminosidad, el programa activa un motor (LED) que deberá detenerse cuando llegue a
buté (BP).
1. Realiza el esquema de montaje a continuación:
Broche 4 : módulo BP
Broche 9: módulo LED
Broche A0: módulo sensor de luminosidad

2. Modificar el programa de la medida de la iluminancia para que el LED se apague cuando el BP está presionado.
Utilizando la tabla de abajo.

Seuil atteint BP enfoncé LED

sí sí APAGADO
sí no EN
no sí APAGADO
no no APAGADO
/*

5-TP_arduino.odt 11
 Clase de primera STI2D

simulación tienda eléctrica

*/

const int BP = ...;// broche 4 para el BP

const int led = ...;// pin 9 para el LED
const int lux = ...;// broche analógica A0 para el sensor

// esta función se ejecuta solo una vez

vacío configurar()
{
...; // se define el pin 4 como entrada
...; se define el pin 9 como salida

[Link](9600); // inicializa la velocidad del puerto serie

}

// esta función buclea indefinidamente

vacío bucle()
{
int bouton = ...; // lectura BP
int valor = ...; // lectura sensor
[Link](valor); // visualización de valor en el terminal serie

si ( ... && ... ) { // detección del umbral de luminosidad

...; // led encendida
sino
...; // led apagada

retraso(10); // estabilización 10 ms
}
3. En caso de viento demasiado violento, el motor no debe ser activado, incluso si la luz es demasiado intensa.
Modificar la tabla para tener en cuenta el viento medido con un anemómetro que será simulado con
de un potenciómetro.
4. Realiza el esquema de montaje a continuación:
Broche 4: módulo BP
Broche 9 : módulo LED
Broche A0 : módulo
sensor de luminosidad
Broche A3 : potenciómetro

5. Modificar el programa anterior para que el LED se apague cuando se gira el potenciómetro más de uno
media vuelta.
/*
simulación tienda eléctrica - v2
*/

5-TP_arduino.odt 12
 Clase de primera STI2D

const int BP = ...;// broche 4 para el BP

const int led = ...; // broche 9 para el LED
const int lux = ...;// pin analógico A0 para el luxómetro
constante int vent = ...;// broche analógica A3 para el potenciómetro

// esta función se ejecuta solo una vez

vacío configurar()
{
...; // on définit la broche 4 en entrée
...; // se define el pin 9 como salida

[Link](9600); // inicializa la velocidad del puerto serie

}

// esta función bucle indefinidamente

vacío bucle()
{
int boton = ...; // lectura BP
int valor = ...; // lectura luxómetro
int velocidad = ...; // lectura anemómetro
[Link](vitesse); // mostrar valor en el terminal serie

si ( ... detección del umbral de luminosidad

... // détection du seuil de vitesse
... ) // detección BP
...; // led encendida
else
...; // led apagada

retrasar(10); // estabilización 10 ms
}

5-TP_arduino.odt 13
 Clase de primer año STI2D

5. Utilización de la salida MLI

5.1. Comando de un motor de corriente continua
La placa Arduino solo puede proporcionar 40mA por salida, lo que puede resultar insuficiente o dañar el hardware si el
el motor provoca un pico de intensidad al arrancar o bajo carga.
Para remediar esto, utilizaremos una interfaz de potencia cuyo papel será hacer el enlace entre la parte de mando,
representada por la tarjeta Arduino, y la parte de potencia: el motor.
Conectar la interfaz a la placa Arduino y al servomotor
respetando las conexiones como se indica a continuación.
Lado del servomotor Côté Arduino

1. Realizar la conexión como se indica en el esquema anterior.

Broche 2 : interfaz TACHY
Broche 6 : interfaz PWM
Broche 5V : interfaz de +5V
Broche GND : interfaz GND

2. Modificar el programa de abajo para imponer una velocidad al motor (de 0 a 255).
/*
MLI por interfaz serie
*/

constante int MOTEUR = 6;// Pin digital 6 para comando del motor

char buffer[8] ="";

int i = 0;

/* Rutina de inicialización */
vacío configurar()
{
[Link](...); // Inicialización del puerto COM

5-TP_arduino.odt 14
 Clase de primer año STI2D

...; // Salida del motor

}

/* Función principal */
vacío bucle()
{
si ( [Link]() > 0 ) {
char c = [Link]();

si ( c == '\r' ) {
buffer[i] = 0;
int velocidad = atoi(buffer);
si ( velocidad >= 0 && velocidad <= 255 ) {
analogWrite(...);
[Link]("velocidad : ");
[Link](...);
}
de lo contrario
[Link]("valor incorrecto");
i = 0;
}
sino si ( (int) c != -1 )
buffer[i++] = c;
}
}
Pour piloter le moteur en vitesse, respecter les consignes suivantes :
1. Lanzar el terminal
2. Cocher Défilement automatique
3. Seleccionar carácter de Retorno
4. Seleccionar la velocidad correcta
5. Ingrese la velocidad (0 a 255) en el área de texto

5-TP_arduino.odt 15
 Clase de primer año STI2D

5.2. Control de un motor mediante un potenciómetro

Un potenciómetro es una resistencia variable.
1. Modificar el montaje anterior para conectar el potenciómetro como se indica a continuación:
Broche 2 : interfaz TACHY
Broche 6 : interfaz PWM
Broche 5V : interfaz de +5V
Broche GND : interfaz GND
Broche A0: módulo potenciómetro

2. Modificar el programa para que la velocidad sea impuesta por el potenciómetro.

3. Iniciar y configurar el terminal para mostrar la velocidad del motor (número de ticks de la rueda codificadora de
el árbol motor).
/*
MLI por potenciómetro
*/

#incluir <SimpleTimer.h>[Link]

const int POTAR = ...;// broche A0 para potenciómetro

const int MOTEUR = ...;// Pin digital para el control del motor
const int TACHY = ...;// interrupción 0 = pin2 arduino Uno/mega
/*
Placa Pines digitales utilizables para interrupciones
Uno, Nano, Mini, otros basados en 328
Mega, Mega2560, MegaADK 2, 3, 18, 19, 20, 21
*/

SimpleTimer temporizador; // Temporizador para muestreo

sin firmar int delai_timer = 100;// Compteur de tick de la codeuse
sin signo int tick_codeuse = 0;// Compteur de tick de la codeuse

/* Routine d'initialisation */
vacío configurar()
{
[Link](...); // Inicialización del puerto COM

...; Entrada del potenciómetro

...; Salida del motor

// Interrupción en el tick del codificador

attachInterrupt(TACHY, compteur, CAMBIO);

// Interrupción para mostrar velocidad

[Link](delai_timer, vitesse);
}

/* Función principal */
vacío bucle()
{
[Link]();

5-TP_arduino.odt 16
 Clase de primer STI2D

Normalización y control del motor

int velocidad = ...;
si ( velocidad >= 0 && velocidad <= 255 )
...;

retrasar(10);
}

/* Interrupción en tick de la codificadora */

vacío contador()
{
// Se incrementa el número de ticks de la codificadora
tick_codeuse++;
}

/* Interrupción para el cálculo del PID */

vacío velocidad()
{
int tick = tick_codeuse;
tick_codeuse = 0; // Réinitialisation du nombre de tick de la codeuse

// visualización de la velocidad del motor

[Link](tick);
}

5.3. Programación de un motor

Queremos que un motor realice el siguiente ciclo:
1. salida detenida
2. aceleración hasta la velocidad máxima en 1s
3. mantenimiento de la velocidad durante 2s

4. desaceleración hasta el paro en 2s

5. motor detenido durante 1s
6. rebouclage al principio
A partir de la actividad 5.1.:
1. Modificar el programa para obtener el cronograma de arriba.
2. Hacer que se muestre la velocidad del motor en el terminal serie.
3. Copiar/pegar los valores de la velocidad medida y trazar el gráfico asociado utilizando una hoja de cálculo.
4. Verificar el resultado obtenido con el ciclo del pliego de condiciones.
/*
programación de motor de CC
*/

#incluir <SimpleTimer.h>// [Link]

const int POTAR = ...;// broche A0 para potenciómetro

const int MOTEUR = ...;// Pin digital para el control del motor
const int TACHY = ...;// interrupción 0 = pin2 arduino Uno/mega
/*
Board Digital Pins Usable For Interrupts
Uno, Nano, Mini, otros basados en 328 2, 3
Mega, Mega2560, MegaADK 2, 3, 18, 19, 20, 21
*/

SimpleTimer temporizador; // Temporizador para muestreo

sin firmar int delai_timer = 100;// tiempos de muestreo
sin signo int tick_codeuse = 0;// Contador de ticks del codificador

/* Rutina de inicialización */

5-TP_arduino.odt 17
 Clase de primer año STI2D

vacío configuración()
{
[Link](...); // Inicialización del puerto COM

...; Entrada potenciómetro

...; Salida del motor

motor apagado
...;

// Interrupción en el tick del codificador

attachInterrupt(TACHY, compteur, CAMBIO);

// Interrupción para mostrar velocidad

[Link](delai_timer, vitesse);
}

/* Función principal */
vacío bucle()
{
[Link]();

const int tempo = 10;// 10 ms

// aceleración del motor 1s = 1000ms

... acc = 255 * tempo / 1000;
por (float velocidad(0); velocidad <= 255; velocidad += acc) {
...;
retrasar(tempo);
}

// mantener velocidad 2s
retraso(2000);

décélération moteur 2s = 2000ms

... dec = 255 * tempo / 2000;
para (float velocidad(255); velocidad >= 0; velocidad -= dec) {
...;
retraso(tempo);
}

// parada 1s
delay(1000);
}

/* Interrupción sobre el tick de la codificadora */

vacío contador()
{
Se incrementa el número de ticks del codificador
tick_codigo++;
}

/* Interrupción para el cálculo del PID */

vacío vitesse()
{
int tick = tick_codeuso;
tick_codeuse = 0; // Réinitialisation du nombre de tick de la codeuse

// visualización de la velocidad del motor

[Link](tick);
}

5-TP_arduino.odt 18
 Clase de primer año STI2D

5.4. Servomotor
Un servomotor es un sistema motorizado capaz de alcanzar posiciones predeterminadas y luego mantenerlas.
la posición es: en el caso de un motor rotativo, un valor de ángulo y, en el caso de un motor lineal, una distancia.
Queremos pedir 2 servomotores.
Un servomotor principal debe realizar el ciclo
ci-contre.
El segundo debe estar en oposición de fase.

1. Realizar el montaje a continuación.

Broche 9 : servo 1
Broche 10 : servo 2

2. Modificar el programa para cumplir con el pliego de condiciones anterior.

/*
comando de servomotores
*/

#incluir <Servo.h>

const int pin_servo1 = ...;// pin 9 servo 1

const int pin_servo2 = ...;// broche 10 servo 2
const int botón = ...; // broche 3 para el botón pulsador

//Creación de objetos servo para controlarlos

Servo servo1, servo2;

vacío configuración()
{
Conectamos los pines a los servos
[Link](pin_servo1);
[Link](pin_servo2);

// inicialización de la posición de los motores servo

iniciarServo();
}

5-TP_arduino.odt 19
 Clase de primera STI2D

vacío bucle()
{
si ( ... )
iniciar();
else {
const int tempo = 10;// 10 ms

// position 90° pensant 1s

retraso(...);

// aceleración servo 2s = 2000ms

... acc = 90 * tempo / 2000;
para (... ángulo(0); ángulo <= 90; ángulo += acc) {
[Link](90 ... (int) ángulo);
[Link](90 ... (int) ángulo);
delay(tempo);
}

// ciclo 3
acc = 180 * tempo / 2000;
para (... ángulo(0); ángulo <= ...; ángulo += acc) {
[Link](...);
[Link](...);
retraso(tempo);
}

// ciclo 8
acc = 90 * tempo / 1000;
para (... ángulo(0); ángulo <= ...; ángulo += acc) {
[Link](...);
[Link](...);
delay(tempo);
}
}
}

vacío iniciarServo()
{
// inicialización de las posiciones de los servomotores a 90°
[Link](90);
[Link](90);

delay(500); // espera 500ms para que los servos se coloquen en posición

}

5-TP_arduino.odt 20
 Clase de primer año STI2D

6. Pantalla LCD
On souhaite afficher la température et le taux d'humidité contenue dans une pièce sur une afficheur LCD4.
1. Conectar el visualizador al bus I²C según el esquema a continuación.
Broche A0 : sensor de temperatura
Broche A2: sensor de humedad
Bus I²C : LCD

2. Détecter l'adresse utilisée par l'afficheur LCD à l'aide du programme ci-dessous :

//
// escáner I2C
//

#incluir <Wire.h>

vacío configuración()
{
[Link]();

[Link](9600);
while ( !Serial);// Leonardo: espera por el monitor serie
Escáner I2C
}

vacío bucle()
{
Escaneando...

int nDispositivos(0);
para (int dirección(1); dirección < 127; dirección++) {
// El escáner i2c utiliza el valor de retorno de
// the [Link] to see if
un dispositivo reconoció la dirección.
[Link](dirección);
int error = [Link]();

si ( error == 0 ) {
[Link]("dispositivo I2C detectado en la dirección : 0x");
si ( dirección < 16 )
[Link]("0");
[Link](dirección, HEX);

nDispositivos++;

4 Pantalla de Cristal Líquido

5-TP_arduino.odt 21
 Clase de primero STI2D

}
}

si ( nDispositivos == 0 )
No se encontró ningún dispositivo I2C
else
[Link]("terminada\n");

delay(5000); // espera 5 segundos para el próximo escaneo

}

3. Modificar el programa para que las mediciones se muestren en 2 líneas (t° luego % de humedad) y se actualicen
todas las segundos.
/*
Medir t° y humedad
*/

#incluir <wire.h>
#incluir <LiquidCrystal_I2C.h>// [Link]
cristal líquido/descargas

const int TEMP = ...;// sensor de t° en el pin A0

const int HUMID = ...;// sensor de humedad en el pin A2

const int I2C_ADDR = ...;// dirección I2C del LCD

inicialización del objeto LCD

LiquidCrystal_I2C lcd(I2C_ADDR);

vacío configurar()
{
[Link](16, 2); // inicializa el lcd a 16 caracteres 2 líneas

// ------- 3 destellos -------------

for(int i(0); i < 3; i++) {
lcd. retroiluminación();
retrasar(250);

[Link]ón();
retraso(250);
}

[Link](); // retroiluminación activada

}

vacío bucle()
{
// limpiar la pantalla
[Link]();

//-------- Escribir caracteres en la pantalla ------------------

// NOTA: La posición del cursor: (CARÁCTER, LÍNEA) comienza en 0
[Link](0, 0); //Comenzar en el carácter 4 en la línea 0
[Link]("Temp : ");
... t = (... * 500) / 1024;
[Link](t);
[Link]("°C");

[Link](0, 1);
[Link]("Hum : ");
... h = ...;
[Link](h);
[Link]("%");

retrasar(1000);

5-TP_arduino.odt 22
 Clase de primer año STI2D
}

7. Módulos
• Medida de distancia por ultrasonido
• Infrarrojo distancia GP2Y0A21
• Divisor de tensión DFR 0051
• Módulo relé de potencia 24V
• Botón pulsador
• Receptor infrarrojo DFR 0094
• Sensor de temperatura DFR 0023
• Potenciómetro
• Medición del sonido

• Zumbador
• Sensor infrarrojo de 10 cm SEN 0024

• Sensor de corriente 30A phjidget

• Transmisor IR
• Sensor capacitivo
• Commande motor
• Sensor de humedad
• Medida de luminosidad
• ruedas codificadoras

• Pantalla LCD 4x16

• Pantalla LCD 2x16
• Central inercial 6DOF
• LED
• sensor sensible

escudos
• Escudo de Relé para Arduino V2.1
• Escudo Base Grove
• escudo motor 2A
• escudo Xbee
• escudo wifi
• escudo NFC
• escudo I/O V7
• escudo I/O V6
• escudo GSM
• escudo de bus CAN
• tarjeta SD de escudo

• escudo ethernet
• escudo cargador solar

5-TP_arduino.odt 23
 Classe de première STI2D

8. Referencias
• Tutorial de Arduino
• Manuel de referencia Aduino
• lenguaje C
• lenguaje C++
• la resistencia
• el diodo
• el Transistor
• Trabajos Prácticos de Arduino

• Referencia Lenguaje Arduino

5-TP_arduino.odt 24