TC3: Robótica

Códigos de programación para experimentación con

ARDUINO

● Parpadeo de un LED
Enlace a la práctica (LED)
https://www.tinkercad.com/things/aAhFE1F88RZ-ingenious-blad
Código ARDUINO:

int LED=12; // pin 12 se conecta el LED

void setup()
{
pinMode (LED, OUTPUT); //pin 12 es de salida
}

void loop()
{
digitalWrite (LED, HIGH);
delay(500);
digitalWrite (LED, LOW);
delay (500);
}

Enlace a la práctica (LED secuenciados):

https://www.tinkercad.com/things/lEko3guES5P-funky-trug-sango
Código ARDUINO:

int LED1=3;
int LED2=4;
int LED3=5;
int LED4=6;
int LED5=7;
int LED6=8;

void setup()
{
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
}

void loop()
{
digitalWrite (LED6, HIGH);
delay(300);
digitalWrite (LED5, HIGH);
delay(300);
digitalWrite (LED4, HIGH);
delay(300);
digitalWrite (LED3, HIGH);
delay(300);
digitalWrite (LED2, HIGH);
delay(300);
digitalWrite (LED1, HIGH);
delay (300);
digitalWrite (LED1, LOW);
delay(300);
digitalWrite (LED2, LOW);
delay(300);
digitalWrite (LED3, LOW);
delay(300);
digitalWrite (LED4, LOW);
delay(300);
digitalWrite (LED5, LOW);
delay(300);
digitalWrite (LED6, LOW);
delay (300);
}
 ● Lectura de un potenciómetro
Enlace a la práctica:
https://www.tinkercad.com/things/5LqfsnShTXk
Código ARDUINO:

// Crear variables globales (variables que se pueden usar en cualquier parte de nuestro código)

// Aquí estamos creando una variable llamada "sensorPin" de tipo "int"

// e inicializándolo para que tenga el valor "0", que es el pin A0 de
//entrada analógica al que se conecta el pot.
int sensorPin = 0;
// Variable para almacenar el número de pin al que está conectado el LED
int ledPin = 13;
// esta función se ejecuta una vez cuando se inicia el código
void setup()
{
// establece ledPin (13) como una SALIDA
pinMode(ledPin, OUTPUT);
}
// esta función se ejecuta repetidamente una vez que finaliza la configuración ()
void loop()
{
// crea una variable local (variable que solo se puede usar dentro del bucle () para almacenar
// un valor del sensor (potenciometro) llamado sensorValue
int sensorValue;
// usa la función analogRead () para leer sensorPin y almacenar el valor en sensorValue
sensorValue = analogRead(sensorPin);
// Enciende el LED
digitalWrite(ledPin, HIGH);
delay(sensorValue);
// Apaga el LED
digitalWrite(ledPin, LOW);
// retraso (delay) para el valor de sensorValue
delay(sensorValue);
// vuelve al principio
}
 ● Conducción de un LED RGB
Enlace a la práctica:
https://www.tinkercad.com/things/iZW5i7rIkh2
Código ARDUINO:

// crea variables para números de pin. Aquí los estamos haciendo constantes, porque nunca cambian.
const int RED_PIN = 5;
const int GREEN_PIN = 6;
const int BLUE_PIN = 9;

// Qué tan rápido planeamos recorrer los colores en milisegundos

int DISPLAY_TIME = 10;

void setup()
{
// establece las tres variables pin como salidas
pinMode(RED_PIN, OUTPUT);
pinMode(GREEN_PIN, OUTPUT);
pinMode(BLUE_PIN, OUTPUT);
}

void loop()
{
// Hemos escrito una función personalizada llamada mainColors () que recorre los ocho colores.
//Solo estamos "llamando" a la función aquí (diciéndole que se ejecute).
mainColors();

// Aquí está la función personalizada mainColors () que hemos escrito.

void mainColors()
{
// Apagado (todos los LED apagados):
digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, LOW);

//por un segundo
delay(1000);

// Rojo (enciende solo el LED rojo):

digitalWrite(RED_PIN, HIGH);
 digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, LOW);

//por un segundo
delay(1000);

// Verde (encienda solo el LED verde):

digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, HIGH);
digitalWrite(BLUE_PIN, LOW);

//por un segundo
delay(1000);

// Azul (enciende solo el LED azul):

digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, HIGH);

//por un segundo
delay(1000);

// Amarillo (activar rojo y verde):

digitalWrite(RED_PIN, HIGH);
digitalWrite(GREEN_PIN, HIGH);
digitalWrite(BLUE_PIN, LOW);

//por un segundo
delay(1000);

// Cian (activar verde y azul):

digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, HIGH);
digitalWrite(BLUE_PIN, HIGH);

//por un segundo
delay(1000);

// Púrpura (enciende rojo y azul):

digitalWrite(RED_PIN, HIGH);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, HIGH);

//por un segundo
delay(1000);

// Blanco (enciende todos los LED):

digitalWrite(RED_PIN, HIGH);
digitalWrite(GREEN_PIN, HIGH);
digitalWrite(BLUE_PIN, HIGH);
 //por un segundo
delay(1000);
}

● Conducción de múltiples LED

Enlace a la práctica:
https://www.tinkercad.com/things/lgo8TSaEtos
Código ARDUINO:

// Para realizar un seguimiento de todos los pines LED, usaremos una "matriz".
// Una matriz le permite almacenar un grupo de variables y referirse a ellas
// por su posición o "índice". Aquí estamos creando una serie de
// seis varibles enteras:

int ledPins[] = {4,5,6,7,8,9};

void setup()
{
// crea una variable local para almacenar el índice de qué pin queremos controlar
int index;

// Para el ciclo for () a continuación, estas son las tres declaraciones:

// 1. index = 0; Antes de comenzar, haga index = 0.

// 2. índice <= 5; Si el índice es menor o igual a 5, ejecute el siguiente código
// 3. index ++ Poner "++" después de una variable significa "agregarle una".

// Cuando la prueba en la declaración 2 es finalmente falsa, el código

// continuará.

// Este ciclo for () hará que index = 0, luego ejecute pinMode ()

// más la declaración entre paréntesis. Entonces hará lo mismo
// para index = 2, index = 3, etc. hasta index = 5.

for(index = 0; index <= 5; index++)

{
pinMode(ledPins[index],OUTPUT);
}
}

void loop()
{
// Este loop () llama funciones que hemos escrito más abajo.
// Hemos desactivado algunos de estos al comentarlos (poniendo "//" en frente de ellos).
 // Para probar diferentes pantallas LED, elimine el "//"
// delante de los que te gustaría ejecutar, y agrega "//"
// delante de los que no comentar (y deshabilitar) aquellos líneas.

// Ilumina todos los LED a su vez

oneAfterAnotherNoLoop();

// Igual que oneAfterAnotherNoLoop

//oneAfterAnotherLoop();

// Enciende un LED a la vez, desplazándote por la línea

//oneOnAtATime();

// Enciende los LED en el medio de los bordes

//pingPong();

//marquee();

// Parpadea los LED al azar

//randomLED();
}

/*
oneAfterAnotherNoLoop()
Esta función encenderá un LED, uno a uno, luego se enciende
el siguiente LED y repite hasta que todos los LED estén encendidos.
Y los apagará en el orden inverso.
*/

void oneAfterAnotherNoLoop()
{
// tiempo (milisegundos) para pausar entre cada LED
int delayTime = 100;

// enciende todos los LED:

digitalWrite(ledPins[0], HIGH); // Enciende el LED # 0 (pin 4)

delay(delayTime); // espera delayTime milisegundos
digitalWrite(ledPins[1], HIGH); // Enciende el LED # 1 (pin 5)
delay(delayTime); // espera delayTime milisegundos
digitalWrite(ledPins[2], HIGH); // Enciende el LED # 2 (pin 6)
delay(delayTime); // espera delayTime milisegundos
digitalWrite(ledPins[3], HIGH); // Enciende el LED # 3 (pin 7)
delay(delayTime); // espera delayTime milisegundos
digitalWrite(ledPins[4], HIGH); // Enciende el LED # 4 (pin 8)
delay(delayTime); // espera delayTime milisegundos
digitalWrite(ledPins[5], HIGH); // Enciende el LED # 5 (pin 9)
delay(delayTime); // espera delayTime milisegundos
 // apaga todos los LED:

digitalWrite(ledPins[5], LOW); // Apaga el LED # 5 (pin 9)

delay(delayTime); // espera delayTime milisegundos
digitalWrite(ledPins[4], LOW); // Apaga el LED # 4 (pin 8)
delay(delayTime); // espera delayTime milisegundos
digitalWrite(ledPins[3], LOW); // Apaga el LED # 3 (pin 7)
delay(delayTime); // espera delayTime milisegundos
digitalWrite(ledPins[2], LOW); // Apaga el LED # 2 (pin 6)
delay(delayTime); // espera delayTime milisegundos
digitalWrite(ledPins[1], LOW); // Apaga el LED # 1 (pin 5)
delay(delayTime); // espera delayTime milisegundos
digitalWrite(ledPins[0], LOW); // Apaga el LED # 0 (pin 4)
delay(delayTime); // espera delayTime milisegundos
}

/*
oneAfterAnotherLoop()

Esta función hace exactamente lo mismo que oneAfterAnotherNoLoop (),

pero aprovecha los ciclos for () y la matriz para hacerlo con menor
líneas de código
*/

void oneAfterAnotherLoop()
{
int index;
int delayTime = 100; // milisegundos para pausar entre cada LED
//haga esto más pequeño para un cambio más rápido

// Encienda todos los LED:

// Este ciclo for () aumentará el índice de 0 a 5

// (poner "++" después de una variable significa agregarle una)
// y luego usará digitalWrite () para encender ese LED.

for(index = 0; index <= 5; index++)

{
digitalWrite(ledPins[index], HIGH);
delay(delayTime);
}

// Apague todos los LED:

// Este ciclo for () aumentará el índice de 5 a 0

// (poner "-" después de una variable significa restarle una)
// y luego usará digitalWrite () para apagar ese LED.
 for(index = 5; index >= 0; index--)
{
digitalWrite(ledPins[index], LOW);
delay(delayTime);
}
}

/*
oneOnAtATime()

Esta función pasará por los LED,

iluminando solo uno a la vez.
*/

void oneOnAtATime()
{
int index;
int delayTime = 100; // milisegundos para pausar entre LED
// haga esto más pequeño para un cambio más rápido

// paso a través de los LED, de 0 a 5

for(index = 0; index <= 5; index++)

{
digitalWrite(ledPins[index], HIGH); // encienda el LED
delay(delayTime); // pausa para frenar
digitalWrite(ledPins[index], LOW); // apaga el LED
}
}

/*
pingPong()

Esta función pasará por los LED,

iluminando uno a la vez en ambas direcciones.
*/

void pingPong()
{
int index;
int delayTime = 100; // milisegundos para pausar entre LED
// haga esto más pequeño para un cambio más rápido

// paso a través de los LED, de 0 a 5

for(index = 0; index <= 5; index++)

{
digitalWrite(ledPins[index], HIGH); // encienda el LED
 delay(delayTime); // pausa para frenar
digitalWrite(ledPins[index], LOW); // apaga el LED
}

// paso a través de los LED, de 5 a 0

for(index = 5; index >= 0; index--)

{
digitalWrite(ledPins[index], HIGH); // encienda el LED
delay(delayTime); // pausa para frenar
digitalWrite(ledPins[index], LOW); // apaga el LED
}
}

/*
marquee()

Esta función imitará "luces de persecución" como las de los letreros.

*/

void marquee()
{
int index;
int delayTime = 200; // milisegundos para pausar entre LED
// Hazlo más pequeño para un cambio más rápido

// Recorre los primeros cuatro LED

// (Iluminaremos uno en los 3 inferiores y uno en los 3 superiores)

for(index = 0; index <= 2; index++) // Paso de 0 a 3

{
digitalWrite(ledPins[index], HIGH); //Enciende un LED
digitalWrite(ledPins[index+3], HIGH); // Omita cuatro y encienda ese LED
delay(delayTime); // Pausa para ralentizar la secuencia.
digitalWrite(ledPins[index], LOW); // Apaga el LED
digitalWrite(ledPins[index+3], LOW); // Salta cuatro y apaga ese LED
}
}

/*
randomLED()

Esta función encenderá LED aleatorios. ¿Puedes modificarlo para que

también los enciende por momentos aleatorios?
*/

void randomLED()
{
int index;
int delayTime;

//La función random () devolverá un número semialeatorio cada

index = random(5); // elige un número aleatorio entre 0 y 5

delayTime = 100;

digitalWrite(ledPins[index], HIGH); // enciende el LED

delay(delayTime); // pausa para frenar
digitalWrite(ledPins[index], LOW); // Apaga el LED
}
 ● Lectura de un botón presionado
Enlace a la práctica:
https://www.tinkercad.com/things/isOmMEVVaxe
Código ARDUINO:

//Primero configuraremos las constantes para los pines a los que conectaremos las terminales del RGB
// Esto nos permitirá identificar cada color en el código de abajo.

// Pin de botón (pushbutton)

const int buttonPin = 3;

// Pines del led RGB

const int redPin = 11;
const int greenPin = 10;
const int bluePin = 9;

// Crea una variable para almacenar un contador y ponerlo en 0

int counter = 0;
void setup()
{

// Configura los pines del pushbutton para que sean una Entrada:
pinMode(buttonPin, INPUT);

// Configura los pines del led RGB para que sea Salidas:
pinMode(redPin, OUTPUT);
pinMode(greenPin,OUTPUT);
pinMode(bluePin,OUTPUT);
}

void loop()
{
// Varible local para guardar el estado del pushbutton
int buttonState;

// Lee el estado digital del buttonPin con la función digitalRead() y almacena

// el valor en la variable buttonState
buttonState = digitalRead(buttonPin);
 // Si el botón es presionado, incrementa el contador y espera un poco para
// darle tiempo a que el botón se libere.
if (buttonState == LOW) // Prende el LED
{
counter++;
delay(150);
}

// Utiliza el ciclo IF para revisar el valor del contador .

// Si el contador es igual a 0, todos los pines se apagarán
if(counter == 0)
{
digitalWrite(redPin,LOW);
digitalWrite(greenPin,LOW);
digitalWrite(bluePin,LOW);
}

// si el contador es igual a 1, el redPin está en estado algo (encendido)

else if(counter == 1)
{
digitalWrite(redPin,HIGH);
digitalWrite(greenPin,LOW);
digitalWrite(bluePin,LOW);
}

// si el contador es igual a 2, el greenPin está en estado algo (encendido)

else if(counter ==2)
{
digitalWrite(redPin,LOW);
digitalWrite(greenPin,HIGH);
digitalWrite(bluePin,LOW);
}

// si el contador es igual a 3, el bluePin está en estado algo (encendido)

else if(counter ==3)
{
digitalWrite(redPin,LOW);
digitalWrite(greenPin,LOW);
digitalWrite(bluePin,HIGH);
}

// de lo contario, reinicia el contador a 0 (lo cual apagará todos los pins)

else
{
counter =0;
}
}
● Lectura de un Fotoresistor
Enlace a la práctica:
https://www.tinkercad.com/things/08td6XuRzEA
Código ARDUINO:

int sensorValue = 0;

void setup()
{
pinMode(A0, INPUT);
Serial.begin(9600);

pinMode(9, OUTPUT);
}

void loop()
{
// leer el valor del sensor
sensorValue = analogRead(A0);
// imprime la lectura del sensor para que sepas su rango
Serial.println(sensorValue);
// mapear la lectura del sensor a un rango
analogWrite(9, map(sensorValue, 0, 1023, 0, 255));
delay(100); // esperar 100 mili segundos
}
 ● Mezcla de colores con RGB
Enlace a la práctica:
https://www.tinkercad.com/things/9chU0p9GvU0
Código ARDUINO:

//Crea constantes para las tres entradas analógicas de los potenciometros

const int redPot = 0;
const int greenPot = 1;
const int bluePot = 2;

//Crea constantes para las tres entradas de pulso del Led RGB
const int redPin = 5;
const int greenPin = 6;
const int bluePin = 9;

//Crea variables para almacenar los valores de los colores rojo, verde y azul
int redVal;
int greenVal;
int blueVal;

void setup()
{
//Configura los pines RGB como salidas
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT);
pinMode(bluePin, OUTPUT);
}

void loop()
{
//Lee las tres entradas analógicas y almacena el valor cada una
// de las las variables de colores
redVal = analogRead(redPot);
greenVal = analogRead(greenPot);
blueVal = analogRead(bluePot);

//Usa la función map() para escalar la entrada analógica de 10 bits(0-1023) a 8 bits(0-255)

//Luego almacena el nuevo valor obtenido nuevamente en la variable del color
redVal = map(redVal, 0, 1023, 0, 255);
greenVal = map(greenVal, 0, 1023, 0, 255);
 blueVal = map(blueVal, 0, 1023, 0, 255);

// Usa la función analogWrite() para escribir las variables de color con sus
// respectivos pines RGB
analogWrite(redPin, redVal);
analogWrite(greenPin, greenVal);
analogWrite(bluePin, blueVal);
}

● Lectura de un sensor de temperatura

Enlace a la práctica:
https://www.tinkercad.com/things/8oShxAssvKj
Código ARDUINO:

// constante de pin de entrada analógica

const int tempPin = 0;

// variable de lectura
int tempVal;

// voltaje variable
float volts;

// variables de temperatura final

float tempC;
float tempF;

void setup()
{
// inicia el puerto serie a 9600 baudios
Serial.begin(9600);
}

void loop()
{
// lee el sensor de temperatura y guárdalo en tempVal
tempVal = analogRead(tempPin);

// imprime el valor 10 de analogRead

Serial.print("TempVal = ");
Serial.print(tempVal);

// imprime un espaciador
Serial.print(" **** ");

// convertir esa lectura a voltaje multiplicando la lectura por 5v

volts = tempVal * 5;
volts /= 1023.0;

// imprime el voltaje bruto sobre el puerto serie

Serial.print("volts: ");
Serial.print(volts, 5);

// imprime un espaciador
Serial.print(" **** ");

// calcular la temperatura en grados centígrados a partir del voltaje

// la ecuación se encontro en las especificaciones del sensor
tempC = (volts - 0.5) * 100 ;

// imprime la temperatura celcius sobre el puerto serie

Serial.print(" grados C: ");
Serial.print(tempC);

// imprime un espaciador
Serial.print(" **** ");

// Convertir de celcius a fahrenheit

tempF = (tempC * 9.0 / 5.0) + 32.0;

// imprime la temperatura Fahrenheit sobre el puerto serie

Serial.print(" grados F: ");
Serial.println(tempF);

// espera un poco antes de tomar otra lectura

delay(1000);
}
 ● Conducción de un servomotor
Enlace a la práctica:
https://www.tinkercad.com/things/f6P7NCybFnK
Código ARDUINO:

#include <Servo.h>

//crear un servo objeto llamado servo1

Servo servo1;

void setup()
{
// conecta el servo1 al pin 9 en el Arduino
servo1.attach(9);
}

void loop()
{
// crea una variable local para almacenar la posición del servo.
int position;

// Para controlar un servo, se indica el ángulo al que se desea posicionar

// Los servos no pueden girar 360 grados completos
// pero puedes indicarles que se mueva entre 0 y 180 grados.

// Cambiar posición a toda velocidad:

// Dile al servo que vaya a 90 grados

servo1.write(90);

// Pausa para tener tiempo de moverse

delay(1000);

// Dile al servo que vaya a 180 grados

servo1.write(180);
 // Pausa para tener tiempo de moverse
delay(1000);

// Dile al servo que vaya a 0 grados

servo1.write(0);

// Pausa para tener tiempo de moverse

delay(1000);

// Dile al servo que vaya a 180 grados, avanzando dos grados

for(position = 0; position < 180; position += 2)
{
// Moverse a la siguiente posición
servo1.write(position);
// Pausa corta para permitir que se mueva
delay(20);
}

// Dile al servo que vaya a 0 grados, avanzando un grado

for(position = 180; position >= 0; position -= 1)
{
// Moverse a la siguiente posición
servo1.write(position);
// Pausa corta para permitir que se mueva
delay(20);
}
}