1

Informe de laboratorio No.3-4

Anderson Julián Ortiz Olaya
Duvan Darío Cárdenas Villanueva
[email protected]
[email protected]

ITFIP – Institución de Educación Superior

información de una fuente, como puede ser un teclado,

Resumen — en el sigiente informe realizaremos los y convertir la información en una acción como puede ser
ejercicios dejados por el docente con el fin de comprendeer encender una luz y pasar por un display lo tecleado.
el funcionamiento del arduino el cual nos sirve para la
realizacion de multiples proyectos durante la carrera de
ingenieria, en estos ejercicios encontramos de un nivel
superor a los dos talleres anteriores.

I. INTRODUCCIÓN
E N esta actividad pondremos en prectica el
conociminiento adquirido en clase acerca de
arduino una plataforma libre que se utiliza para la
realizacion de proyectos, encontramos dos talleres los
cuales contienen ejercicios basicos que montaremos
demanea fisica y el codigo del controlador sera creado
en el mismo sotfware arduino, luego procedemos a
pasarlo para asi unirlo con el montaje fisico y ver su
correcto funcionemiento.
El objetivo de esta experiencia es comprender las
basesde arduino y como de diferentes maneras de
programar podremos lograr las mismas cosas todo
esto realizado por nosotros msmos para
enriquesernos de experiencia, estos ejercicios son Imagen1: Arduino mega 2560.
probados en el laboratorio .
Arduino es una plataforma de hardware libre, basada III. LABORATORIO
en una placa con un microcontrolador y un entorno de
desarrollo, diseñada para facilitar el uso de la Para esta práctica se utilizó protoboard, resistencias
electrónica en proyectos multidisciplinares. foto-resistencias, leds, parlantes, pulsadores, placa
Arduino, instalación del software Arduino y guías
didácticas.

II. MARCO TEORICO.

Arduino nos proporciona un software consistente en un

entorno de desarrollo (IDE) que implementa el lenguaje
de programación de arduino y el bootloader ejecutado
en la placa. La principal característica del software de
programación y del lenguaje de programación es su
sencillez y facilidad de uso

Arduino se puede utilizar para desarrollar elementos

autónomos, conectándose a dispositivos e interactuar
tanto con el hardware como con el software. Nos sirve
tanto para controlar un elemento, pongamos por ejemplo
un motor que nos suba o baje una persiana basada en Imagen 2: Software-herramientas.
la luz existente es una habitación, gracias a un sensor
de luz conectado al Arduino, o bien para leer la
 2

Se busca la placa de Arduino que se está utilizando en

nuestro caso es la placa Arduino mega y se configura al
conectar de manera automática el puerto com12 para
que reconozca la placa Arduino y luego en el mismo
software configuramos en el puerto con el fin de una 2. FOR LOOP ITERATION (AKA THE
correcta comunicación y traslado de la información a la KNIGHT RIDER)
placa.

Taller No.4

1. ARRAYS

Imagen 2: circuito con Arduino.

Utilizamos el FOR como función principal la cual hace Imagen 3: Conexión LED Arduino.
que las luces conectadas sigan una secuencia
programada esto para aprender el uso y la aplicabilidad Utilizamos la función FOR para realizar la secuencia de
de esta función.
luces del auto fantástico en la cual los leds prende y
apangan en secuencia y luego se regresan
Codigo arduino:
int timer = 100;
int ledPins[] = { 2, 7, 4, 6, 5, 3 };
int pinCount = 6; Codigo arduino:
int timer = 100;
void setup() {
for (int thisPin = 0; thisPin < pinCount; thisPin++) void setup() {
{ for (int thisPin = 2; thisPin < 8; thisPin++)
pinMode(ledPins[thisPin], OUTPUT); { pinMode(thisPin, OUTPUT); }
} }
}
void loop() {
void loop() {
for (int thisPin = 2; thisPin < 8; thisPin++) {
for (int thisPin = 0; thisPin < pinCount; thisPin++) digitalWrite(thisPin, HIGH);
{ delay(timer);
digitalWrite(ledPins[thisPin], HIGH); digitalWrite(thisPin, LOW); }
delay(timer);
digitalWrite(ledPins[thisPin], LOW); for (int thisPin = 7; thisPin >= 2; thisPin--) {
} digitalWrite(thisPin, HIGH);
for (int thisPin = pinCount - 1; thisPin >= 0; thisPin--) delay(timer);
{ digitalWrite(ledPins[thisPin], HIGH);
digitalWrite(thisPin, LOW);
delay(timer);
digitalWrite(ledPins[thisPin], LOW); }
}} }
 3

3. SI DECLARACIÓN (DECLARACIÓN
CONDICIONAL) IF 4.Switch (case) Statement, used
with sensor input

Imagen 4: conexión de pulsador.

Imagen 6: conexión de modulación de pulsos.
Con la funcion if la cual es la que pone a realizar una tarea si Con la funcion if calibramos una fotoresistencia para que mida
es no verdadera la accion, con ella trabajamos con un distintos parametros y ai se vea reflejada en el puerto serial
potenciometro y declaramos que cuando el puerto serie mida del arduino esto varia a media que acercamos eldedo al
mas de 400 encienda el pin 13. fotoresistor.
Codigo arduino: Codigo arduino:
const int analogPin = A0; const int sensorMin = 0;
const int ledPin = 13; const int sensorMax = 600;
const int threshold = 400; void setup() {
Serial.begin(9600);
void setup() { }
pinMode(ledPin, OUTPUT);
Serial.begin(9600); void loop() {
} int sensorReading = analogRead(A0);
int range = map(sensorReading, sensorMin,
void loop() { sensorMax, 0, 3);
int analogValue = analogRead(analogPin); switch (range) {
if (analogValue > threshold) case 0:
{ digitalWrite(ledPin, HIGH); } Serial.println("dark");
else break;
{ digitalWrite(ledPin, LOW); } case 1:
Serial.println(analogValue); Serial.println("dim");
delay(1000); break;
} case 2:
Serial.println("medium");
break;
case 3:
Serial.println("bright");
break;
}
delay(100);
}

Imagen 5: visualización de pulsos.

 4

if (Serial.available() > 0) {
int inByte = Serial.read();

switch (inByte) {
case 'a':
digitalWrite(2, HIGH);
break;
case 'b':
digitalWrite(3, HIGH);
break;
case 'c':
digitalWrite(4, HIGH);
break;
case 'd':
Imagen 7: visualization serial. digitalWrite(5, HIGH);
break;
case 'e':
5. witch (case) Statement, used digitalWrite(6, HIGH);
break;
with serial input default:
// turn all the LEDs off:
for (int thisPin = 2; thisPin < 7; thisPin++) {
digitalWrite(thisPin, LOW);
}
}
}
}

6. While Loop

Imagen 8: circuito a arduino Imagen 9: conexion de LED y fotoresisitor

Con un ciclo if ponemos en una secuencia ordenada 5 leds los Es un circuito en el cual por medio del fotoresistor graduamos
cuales siguen un parametro establecido en la programacion la la luminosidad del led y si pulsamos el swich corta circuito y el
cual con el teclado del portatil selecciono el led que pienso led enciende con toda su potencia.
encender el arduino lo interpreta y prende el led indicada.
Código Arduino:

const int sensorPin = A2;

Codigo arduino: const int ledPin = 9;
const int indicatorLedPin = 13;
void setup() { const int buttonPin = 2;
// initialize serial communication:
Serial.begin(9600); int sensorMin = 1023;
// initialize the LED pins: int sensorMax = 0;
for (int thisPin = 2; thisPin < 7; thisPin++) { int sensorValue = 0;
pinMode(thisPin, OUTPUT);
} void setup() {
} pinMode(indicatorLedPin, OUTPUT);
pinMode(ledPin, OUTPUT);
void loop() { pinMode(buttonPin, INPUT);
// read the sensor:
 5

Serial.begin(9600);
}

void loop() {
while (digitalRead(buttonPin) == HIGH) {
calibrate();
}
digitalWrite(indicatorLedPin, LOW);

sensorValue = analogRead(sensorPin);
sensorValue = map(sensorValue, sensorMin,
sensorMax, 0, 255);
sensorValue = constrain(sensorValue, 0, 255);

Serial.println(sensorValue);
analogWrite(ledPin, sensorValue);
}

void calibrate() { Imagen 11: cerrar cesión

digitalWrite(indicatorLedPin, HIGH);
sensorValue = analogRead(sensorPin);

if (sensorValue > sensorMax) { Código Arduino:

sensorMax = sensorValue;
} #define OSX 0
#define WINDOWS 1
if (sensorValue < sensorMin) { #define UBUNTU 2
sensorMin = sensorValue; #include "Keyboard.h"
} #include "HID.h"
} int platform = WINDOWS;
void setup() {
pinMode(2, INPUT_PULLUP);
Keyboard.begin();
Taller No.4 }
void loop() {
while (digitalRead(2) == HIGH) {
1. Keyboard Logout delay(500);
}
delay(1000);
switch (platform) {
case OSX:
Keyboard.press(KEY_LEFT_GUI);
// Shift-Q logs out:
Keyboard.press(KEY_LEFT_SHIFT);
Keyboard.press('Q');
delay(100);
Keyboard.releaseAll();
Keyboard.write(KEY_RETURN);
break;
case WINDOWS:
Keyboard.press(KEY_LEFT_CTRL);
Keyboard.press(KEY_LEFT_ALT);
Keyboard.press(KEY_DELETE);
delay(100);
Keyboard.releaseAll();
delay(2000);
Keyboard.press(KEY_LEFT_ALT);
Imagen 10 Conexión de potenciómetro y LED Keyboard.press('l');
Keyboard.releaseAll();
El circuito se consta de un pulsador el cual envía una break;
señal la cual suspende cesión en el computador y case UBUNTU:
cambia el puerto com. Keyboard.press(KEY_LEFT_CTRL);
Keyboard.press(KEY_LEFT_ALT);
Keyboard.press(KEY_DELETE);
delay(1000);
Keyboard.releaseAll();
Keyboard.write(KEY_RETURN);
 6

break; Keyboard.print("You pressed the button ");

} Keyboard.print(counter);
while (true); Keyboard.println(" times.");
} }
previousButtonState = buttonState;
2. Keyboard Message }

3. Keyboard Reprogram

Imagen 12: Conexión de foto-resistor

El puerto serial lee las veces que el botón ha sido

presionado apareciendo en pantalla el mensaje de al
software arduino. Imagen 13: Conexiòn a pulsador

Al pulsar el botón crea una nueva hoja en para

programar en el software de arduino permitiéndonos
trabajar

Imagen 13: puerto serie

Código Arduino:

#include "Keyboard.h" . Imagen 14: Conexiòn a pulsador

#include "HID.h"
const int buttonPin = 4; Código arduino:
int previousButtonState = HIGH;
int counter = 0; #include "Keyboard.h"
void setup() { #include "HID.h"
pinMode(buttonPin, INPUT); char ctrlKey = KEY_LEFT_CTRL;
Keyboard.begin();
} void setup() {
void loop() { pinMode(2, INPUT_PULLUP);
int buttonState = digitalRead(buttonPin); Keyboard.begin();
if ((buttonState != previousButtonState) }
&& (buttonState == HIGH)) { void loop() {
counter++;
 7

while (digitalRead(2) == HIGH) { Codigo Arduino:

delay(500);
} #include "Keyboard.h"
delay(1000); #include "HID.h"
Keyboard.press(ctrlKey); void setup() {
Keyboard.press('n'); // open the serial port:
delay(100); Serial.begin(9600);
Keyboard.releaseAll(); Keyboard.begin();
delay(1000); }
Keyboard.press(ctrlKey); void loop() {
Keyboard.press('a'); // check for incoming serial data:
delay(500); if (Serial.available() > 0) {
Keyboard.releaseAll(); char inChar = Serial.read();
Keyboard.write(KEY_BACKSPACE); Keyboard.write(inChar + 1);
delay(500); }
Keyboard.println("void setup() {"); }
Keyboard.press(KEY_RETURN);
Keyboard.println("pinMode(13, OUTPUT);");
Keyboard.println("}"); 5. Keyboard and Mouse Control
Keyboard.println();
Keyboard.println("void loop() {");
Keyboard.println("digitalWrite(13, HIGH);");
for (int keystrokes = 0; keystrokes < 6;
keystrokes++) {
delay(500);
Keyboard.write(KEY_BACKSPACE);
}
Keyboard.println("1000);");
Keyboard.println("digitalWrite(13, LOW);");
Keyboard.println("delay(1000);");
Keyboard.println("}");
Keyboard.press(ctrlKey);
Keyboard.press('t');
delay(100);
Keyboard.releaseAll();
delay(3000);
Keyboard.press(ctrlKey);
Keyboard.press('u');
delay(100);
Keyboard.releaseAll();
while (true);
} Imagen 16: circuito pulsadores

4. Keyboard Serial En el siguiente circuito depende que pulsador

oprimamos y se envía al puerto serie una respues la
cual es configurada en la programación.

Imagen 15: puerto serial.

El puerto serial devuelve la respuesta 1 cuando por el Imagen 17: puerto serial.
puerto seria le envió un 0
 8

}
}
Código Arduino:

#include "Keyboard.h" 6. Button Mouse Control

#include "Mouse.h"
#include "HID.h"
const int upButton = 2;
const int downButton = 3;
const int leftButton = 4;
const int rightButton = 5;
const int mouseButton = 6;

void setup() {
pinMode(upButton, INPUT);
pinMode(downButton, INPUT);
pinMode(leftButton, INPUT);
pinMode(rightButton, INPUT);
pinMode(mouseButton, INPUT);
Serial.begin(9600);
Mouse.begin();
Keyboard.begin();
}
void loop() {
if (Serial.available() > 0) {
char inChar = Serial.read(); Imagen 18: puerto serial.
switch (inChar) {
case 'u': El siguiente circuito trabaja como un reemplazo del
Mouse.move(0, -40); mouse haciendo uso de los pulsadores
break;
case 'd': Código Arduino:
Mouse.move(0, 40);
break; #include "Mouse.h"
case 'l': #include "HID.h"
Mouse.move(-40, 0); const int upButton = 2;
break; const int downButton = 3;
case 'r': const int leftButton = 4;
Mouse.move(40, 0); const int rightButton = 5;
break; const int mouseButton = 6;
case 'm': int range = 5;
Mouse.click(MOUSE_LEFT); int responseDelay = 10;
break; void setup() {
} pinMode(upButton, INPUT);
} pinMode(downButton, INPUT);
pinMode(leftButton, INPUT);
// use the pushbuttons to control the keyboard: pinMode(rightButton, INPUT);
if (digitalRead(upButton) == HIGH) { pinMode(mouseButton, INPUT);
Keyboard.write('u'); // initialize mouse control:
} Mouse.begin();
if (digitalRead(downButton) == HIGH) { }
Keyboard.write('d'); void loop() {
} int upState = digitalRead(upButton);
if (digitalRead(leftButton) == HIGH) { int downState = digitalRead(downButton);
Keyboard.write('l'); int rightState = digitalRead(rightButton);
} int leftState = digitalRead(leftButton);
if (digitalRead(rightButton) == HIGH) { int clickState = digitalRead(mouseButton);
Keyboard.write('r'); int xDistance = (leftState - rightState) * range;
} int yDistance = (upState - downState) * range;
if (digitalRead(mouseButton) == HIGH) { if ((xDistance != 0) || (yDistance != 0)) {
Keyboard.write('m'); Mouse.move(xDistance, yDistance, 0);
 9

} Mouse.begin();
if (clickState == HIGH) { }
if (!Mouse.isPressed(MOUSE_LEFT)) { void loop() {
Mouse.press(MOUSE_LEFT); } // read the switch:
int switchState = digitalRead(switchPin);
} if (switchState != lastSwitchState) {
else { if (switchState == HIGH) {
if (Mouse.isPressed(MOUSE_LEFT)) { mouseIsActive = !mouseIsActive;
Mouse.release(MOUSE_LEFT); digitalWrite(ledPin, mouseIsActive);
} }
} }
delay(responseDelay); lastSwitchState = switchState;
} int xReading = readAxis(A0);
int yReading = readAxis(A1);
if (mouseIsActive) {
7. Button Mouse Control Mouse.move(xReading, yReading, 0);
}
if (digitalRead(mouseButton) == HIGH) {
if (!Mouse.isPressed(MOUSE_LEFT)) {
Mouse.press(MOUSE_LEFT);
}
}
else {
if (Mouse.isPressed(MOUSE_LEFT)) {
Mouse.release(MOUSE_LEFT);
}
}

delay(responseDelay);
}
int readAxis(int thisAxis) {
int reading = analogRead(thisAxis);
reading = map(reading, 0, 1023, 0, range);
int distance = reading - center;

if (abs(distance) < threshold) {

distance = 0;
}
return distance;
}

Imagen 19: puerto serial.

8. ASCII Table
En este circuito el arduino se encarga de hacer el
reemplazo de mouse a través de un joystick el cual se
encarga de moverse por la pantalla de Windows

Código Arduino:

#include "Mouse.h"
#include "HID.h"
const int switchPin = 2;
const int mouseButton = 3;
const int xAxis = A0;
const int yAxis = A1;
const int ledPin = 5;
int range = 12;
int responseDelay = 5; Imagen 20: puerto serial.
int threshold = range / 4;
int center = range / 2; Imprime en el puerto serial las tabas de conversión
boolean mouseIsActive = false;
int lastSwitchState = LOW;
void setup() {
Código Arduino:
pinMode(switchPin, INPUT);
pinMode(ledPin, OUTPUT);
// take control of the mouse: void setup() {
 10

Serial.begin(9600);
while (!Serial) {
}
Serial.println("ASCII Table ~ Character Map"); Código Arduino:
}
int thisByte = 33; const int ledPin = 9;
void loop() { void setup() {
Serial.write(thisByte); Serial.begin(9600);
Serial.print(", dec: "); pinMode(ledPin, OUTPUT);
Serial.print(thisByte); }
Serial.print(", hex: "); void loop() {
Serial.print(thisByte, HEX); byte brightness;
Serial.print(", oct: "); if (Serial.available()) {
Serial.print(thisByte, OCT); brightness = Serial.read();
Serial.print(", bin: "); analogWrite(ledPin, brightness);
Serial.println(thisByte, BIN); }
}
if (thisByte == 126) {
while (true) { Código procesing:
continue;
} import processing.serial.*;
} Serial port;
thisByte++; void setup()
} { size(256, 150);
println("Available serial ports:");
9. Dimmer en este ejercicio printArray(Serial.list());
port = new Serial(this, "COM9", 9600);
necesitan processing }

void draw() {
for (int i = 0; i < 256; i++) {
stroke(i); line(i, 0, i, 150); }
port.write(mouseX);
}

10. Graph

Imagen 21: circuito

En el siguiente circuito podemos ver como en

processing se crea una ventada en la cual según
deslizamos el ratón aumenta o disminuye la intensidad
de luz arrojada por el led.

Imagen 23: circuito

En este circuito el arduino se prepara para leer por su puerto
análogo y processing en su ventana muestra una línea que
hace referencia a la cantidad de voltaje que esta leyendo el
puerto serie.

Imagen 22: ventana de processing

 11

11. MIDI Note Player

Imagen 24: ventana de processing

Código arduino:

void setup() {
Serial.begin(9600);
}
void loop() {
Serial.println(analogRead(A0));
delay(2); Imagen 25: circuito
} En este circuito vemos como envía notas midi desde nuestra
placa arduino a un instrumento a través de una clavija din de 5
Código processing: pines usando el puerto TX e imprime en el puerto serie la
lectura.
import processing.serial.*;
Serial myPort;
int xPos = 1;
void setup () {
printArray(Serial.list());
size: size(400, 300);
myPort = new Serial(this, Serial.list()[1], 9600);
myPort.bufferUntil('\n');
background(0); }
void draw () {}
void serialEvent (Serial myPort) {
String inString = myPort.readStringUntil('\n');
if (inString != null) {
inString = trim(inString); Imagen 26: puerto serie
float inByte = float(inString);
inByte = map(inByte, 0, 1023, 0, height);
stroke(127,34,255); Código arduino:
line(xPos, height, xPos, height - inByte);
if (xPos >= width) { void setup() {
Serial.begin(31250);
xPos = 0;
}
background(0); } void loop() {
else { for (int note = 0x1E; note < 0x5A; note ++) {
xPos++; } } } noteOn(0x90, note, 0x45);
delay(100);
noteOn(0x90, note, 0x00);
delay(100);
}
}
void noteOn(int cmd, int pitch, int velocity) {
Serial.write(cmd);
Serial.write(pitch);
Serial.write(velocity);
}
 12

12. MultiSerialMega 13. Physical Pixel

Imagen 29: prosessing

Imagen 27: puerto serie Cuando el cursor esta sobre la ventana creada en prosesing el
El circuito hace uso del puerto tx rx del arduino para led prende o apaga.
trasmicion serial conectamos el modulo bluetooth.

Imagen 28: trasmisión del módulo HC-05

Imagen 30: circuito a arduino
Codigo Arduino: Codigo Arduino:

void setup() { const int ledPin = 13;

Serial.begin(9600); int incomingByte;
Serial1.begin(9600); void setup() {
} Serial.begin(9600);
void loop() { pinMode(ledPin, OUTPUT);
if (Serial1.available()) { }
void loop() {
int inByte = Serial1.read();
if (Serial.available() > 0) {
Serial.write(inByte); incomingByte = Serial.read();
} if (incomingByte == 'H') {
if (Serial.available()) { digitalWrite(ledPin, HIGH);
int inByte = Serial.read(); }
Serial1.write(inByte); if (incomingByte == 'L') {
} digitalWrite(ledPin, LOW);
} }
 13

} }
}
void loop() {
Codigo prosessing: while (Serial.available() > 0) {
int red = Serial.parseInt();
void setup() { int green = Serial.parseInt();
size(200, 200); int blue = Serial.parseInt();
boxX = width/2.0;
boxY = height/2.0; if (Serial.read() == '\n') {
rectMode(RADIUS); red = 255 - constrain(red, 0, 255);
printArray(Serial.list()); green = 255 - constrain(green, 0, 255);
port = new Serial(this, "COM3", 9600); } blue = 255 - constrain(blue, 0, 255);
void draw()
{ background(0); analogWrite(redPin, red);
if (mouseX > boxX-boxSize && analogWrite(greenPin, green);
mouseX < boxX+boxSize && mouseY > boxY- analogWrite(bluePin, blue);
boxSize && mouseY < boxY+boxSize) {
mouseOverBox = true; Serial.print(red, HEX);
stroke(255); Serial.print(green, HEX);
fill(153); Serial.println(blue, HEX);
port.write('H'); } }
else { }
stroke(153); }
fill(153);
port.write('L');
mouseOverBox = false; } 15. SerialEvent
rect(boxX, boxY, boxSize, boxSize); }
Código arduino :

14. Read ASCII String String inputString = "";

boolean stringComplete = false;
void setup() {
Serial.begin(9600);
inputString.reserve(200);
}
void loop() {
serialEvent();
if (stringComplete) {
Serial.println(inputString);
inputString = "";
stringComplete = false;
}
}
void serialEvent() {
while (Serial.available()) {
char inChar = (char)Serial.read();
inputString += inChar;
if (inChar == '\n') {
stringComplete = true;
}
}
Imagen 31: circuito a arduino
}
Circuito parecido al anterior en el cual dependiendo de
la posición del cursor cambia de color el led 16. Virtual Color Mixer
Codigo Arduino:
const int redPin = 3;
const int greenPin = 5;
const int bluePin = 6;

void setup() {
Serial.begin(9600);
// make the pins outputs:
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT); Imagen 32: circuito a arduino
pinMode(bluePin, OUTPUT);
 14

En el siguiente circuito depende de que sensor de

presión oprimas en prosessing crea un color distinto.

Imagen 33: colores en prosessing

Codigo Arduino:

const int redPin = A0;

const int greenPin = A1;
const int bluePin = A2;

void setup() {
Serial.begin(9600);
}
void loop() {
Serial.print(analogRead(redPin));
Serial.print(",");
Serial.print(analogRead(greenPin));
Serial.print(",");
Serial.println(analogRead(bluePin));
}

IV. CONCLUSIONES
I. Ardino es una herramienta muy
necesaria para la realización de proyevtos
universitarios ya que nos ofrece una
plataforma libre en la cual podemos aplicar
nuestra creatividad.

II. Por medio de este ejercicos aprendimos

las bases de la programación en arduino