PROGRAMACION

Arduino entradas salidas digitales, los bornes (los llamaremos pines) de la placa arduino mega 2560 que
vienen identificados con la palabra digital son los que se pueden programar como entradas o salidas
digitales utilizando código arduino, mediante código en C se pueden utilizar otros pines como entradas
salidas digitales, pero se dará preferencia al código arduino.

En la imagen se puede ver que para el arduino entradas salidas digitales en el mega 2560 van de los bornes
22 al 53 lo cual da un total de 31 pines que se pueden utilizar como entradas o salidas digitales.

Salidas digitales:

La programación para que un pin sea salida digital se hace mediante la siguiente línea de código arduino:

pinMode(número_de_pin,OUTPUT); //terminando en punto y coma, debe respetarse el uso de las

mayúsculas.

Por ejemplo

pinMode(26,OUTPUT); //El pin 26 será una salida digital

a los pines se les puede dar nombres mediante variables, por ejemplo si en un pin programado como
salida se conecta un led se puede crear una variable llamada led a la cual se le asigna el número del pin
utilizado, por ejemplo si se programa el pin 26 como salida digital se puede proceder así para darle un
nombre

byte led=26; //con lo cual donde se utilice la variable pulsador en la compilación esta se reemplazará por 26

Luego para declarar este pin como salida se procederá así:

pinMode(led,OUTPUT);///El pin 26 será una salida digital

Para indicar si por el pin programado como salida digital se quiere que salga un 1 o un 0 se procede así:

digitalWrite(número_de_pin,HIGH);//la salida será un 1 también puede ser así

digitalWrite(número_de_pin,1);

digitalWrite(número_de_pin,LOW);//la salida será un 0 también puede ser así

digitalWrite(número_de_pin,0);

Si se sigue con el ejemplo anterior para enviar un uno sería así

digitalWrite(26,HIGH);// o también digitalWrite(26,1) y si se usa la variable digitalWrite(led,HIGH) o

digitalWrite(26,1)

Mientras que para enviar un cero será algo así:

digitalWrite(26,LOW);// o también digitalWrite(26,0) y si se usa la variable digitalWrite(led,LOW) o

digitalWrite(26,0)

Entradas digitales:

La programación para que un pin sea entrada digital se hace mediante la siguiente línea de código arduino:
pinMode(número_de_pin,INPUT); //terminando en punto y coma

ademas debe respetarse el uso de las mayúsculas.

Por ejemplo

pinMode(53,INPUT); //El pin 26 será una entrada digital

Si al pin 53 se le da un nombre por ejemplo pulsador se haría así

byte pulsador=53; //con lo cual donde se utilice la variable pulsador en la compilación esta se reemplazará
por 53

Luego para declarar este pin como entrada digital se procederá así:

pinMode(pulsador,INPUT);//El pin 53 será una entrada digital

Para conocer si por el pin programado como entrada digital está llegando un 1 o un 0 se procede así:

digitalRead(número_de_pin);//la entrada puede ser un 1 o un 0;

Si se sigue con el ejemplo anterior para leer lo que llega en la entrada sería así

digitalRead(53);// o también digitalRead(pulsador)

Arduino entradas salidas digitales proyecto 1: control de un Contactor.

En este caso se utilizarán 3 pines del arduino mega 2560 como salidas digitales, una de las salidas será
utilizada para que por medio de un transistor bipolar o bjt se pueda controlar un contactor, otra salida se
usará para parpadear un led el cual indicará que el arduino está funcionando correctamente, la otra salida
se usará para hacer parpadear otro led cada vez que el contactor se active, la forma de proceder para
lograr todo esto es la que se comenta en el siguiente vídeo:
…..video…..
En la siguiente imagen se tiene el código realizado, en el se puede ver la utilización de sentencias
if else para toma de desiciones y la sentencia de control for del lenguaje de programación C++,
las condicionales if else son utilizadas para hacer que las salidas cambien sus valores de 0 a 1
o de 0 a 1 logrando que el led verde parpadee si el contactor se activa y que el transistor bjt
conmute actuando como switch, la sentencia de control for se utiliza para conseguir retardos de
5s junto con la instrucción de arduino para las pausas delay(tiempo_en_ms), es dentro de la
sentencia for que se hacen parpadear los leds.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Ejemplos de código
Salida digital
En este ejemplo el LED conectado al pin 13 parpadea cada segundo.

int ledPin = 13; // LED que se encuentra en el pin 13

void setup(){
pinMode(ledPin, OUTPUT); // El p1n 13 será una salida digital
}
void loop(){
digitalWrite(ledPin, HIGH); // Enciende el LED
delay(1000); // Pausa de 1 segundo
digitalWrite(ledPin, LOW); // Apaga el LED
delay(1000); // Pausa de 1 segundo
}

Salida digital II
En este ejemplo el LED conectado al pin 13 parpadea en un intervalo de tiempo variable que depende
del número de veces que se ejecuta el programa (función loop)

int ledPin = 13; // LED que se encuentra en el pin 13

int n = 0; //Entero que contará el paso por la función loop
void setup(){
pinMode(ledPin, OUTPUT); // El p1n 13 será una salida digital
}
void loop(){
digitalWrite(ledPin, HIGH); // Enciende el LED
delay(1000); // Pausa de 1 segundo
digitalWrite(ledPin, LOW); // Apaga el LED
n++; //Incrementamos n
delay(delayVal(n)); //Pausa de un tiempo variable
}

//Función que devuelve un valor tipo entero según el parámetro pasado

int delayVal(int f){
return f*100;
}

Entrada digital
Este ejemplo lee el valor de un interruptor conectado en el pin 2. Cuando el interruptor está cerrado
en el pin de entrada habrá un estado alto (HIGH) y se encenderá el LED.

int ledPin = 13; // Pin de salida para el LED

int inPin = 2; // Pin de entrada (donde está conectado el interruptor)
void setup() {
pinMode(ledPin, OUTPUT);
pinMode(inPin, INPUT);
}
void loop() {
if (digitalRead(inPin) == HIGH){ // Si se activa interruptor
digitalWrite(ledPin, HIGH); // Enciende el LED
delay(1000); // Pause de 1 segundo
digitalWrite(ledPin, LOW); // Apaga el LED
delay(1000); // Pausa de 1 segundo
}
}
Salida PWM
Modulación por ancho de pulso (PWM) puede emplearse, por ejemplo, para establecer el brillo de un
led o controlar un servomotor. En el siguiente ejemplo se va aumentando y decrementando el brillo
del pin 9 mediante PWM.

int ledPin = 9; // Pin controlado por PWM

void setup(){}
void loop() {
for (int i=0; i<=255; i++){
analogWrite(ledPin, i); // Establece el brillo a i
delay(100); // Pausa de 100 ms
}
for (int i=255; i>=0; i--) {
analogWrite(ledPin, i);
delay(100);
}
}

Entrada a partir de un potenciómetro

En el siguiente código se emplea arduino para controlar la frecuencia de parpadeo de un LED.

int potPin = 0; // Pin de entrada para el potenciómetro

int ledPin = 13; // Pin de salida para el LED
void setup() {
pinMode(ledPin, OUTPUT); // Declara el pin del LED como de salida
}
void loop() {
digitalWrite(ledPin, HIGH); // Enciende el LED
delay(analogRead(potPin)); // Lee el valor del potenciómetro
digitalWrite(ledPin, LOW); // Apaga el LED
delay(analogRead(potPin));
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
/*
------ Tutorial Motor Paso a Paso ---------------
*/

#define STEP 11
#define DIR 12
void setup(){

pinMode(DIR,OUTPUT); //Indicamos que los pines son de salida

pinMode(STEP,OUTPUT);

digitalWrite(DIR,HIGH); //Fijamos una direción

for(int i=0;i<2000;i++){ //Mandamos pulsos al motor en concreto 2000

digitalWrite(STEP,HIGH);
delay(1);
digitalWrite(STEP,LOW);
delay(1);
}

delay(500); //Esperamos medio segundo

digitalWrite(DIR,LOW); //Cambiamos la dirección de giro

for(int i=0;i<2000;i++){ //Hacemos 2000 pasos en sentido contrario

digitalWrite(STEP,HIGH);
 delay(1);
digitalWrite(STEP,LOW);
delay(1);
}
}

void loop(){

//No hacemos nada para ejecutar el programa de nuevo pulsamos el boton de

reset.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

/*
------ Tutorial Motor Paso a Paso display ultrasonico ---------------
*/
/* Ping))) Sensor

This sketch reads a PING))) ultrasonic rangefinder and returns the

distance to the closest object in range. To do this, it sends a pulse
to the sensor to initiate a reading, then listens for a pulse
to return. The length of the returning pulse is proportional to
the distance of the object from the sensor.

The circuit:
* +V connection of the PING))) attached to +5V
* GND connection of the PING))) attached to ground
* SIG connection of the PING))) attached to digital pin 7

http://www.arduino.cc/en/Tutorial/Ping

created 3 Nov 2008

by David A. Mellis
modified 30 Aug 2011
by Tom Igoe

This example code is in the public domain.

*/
// include the library code:
#include <LiquidCrystal.h>
#include <AccelStepper.h>
// this constant won't change. It's the pin number
// of the sensor's output:
const int pingPinOUT = 4;
const int pingPinIN = 5;

//const int stepsPerRevolution = 100; // change this to fit the number of steps per revolution
// for your motor

// initialize the stepper library on pins 8 through 11:

AccelStepper stepper2(AccelStepper::FULL4WIRE, 31, 35, 33, 37);
AccelStepper stepper3(AccelStepper::FULL4WIRE, 46, 50,48, 52);

// initialize the library with the numbers of the interface pins

//LiquidCrystal lcd(12, 11, 10, 9, 8, 7);
void setup() {
// initialize serial communication:
//Serial.begin(9600);
//lcd.begin(16, 2); //seteamos la LCD a usar.
//lcd.setCursor(0,0); // enviamos la coordenada de impresión
//lcd.print("Distancia: "); // se imprime
// set the speed at 80 rpm:
stepper2.setMaxSpeed(500.0);
stepper2.setAcceleration(10000.0);
stepper2.moveTo(-10000000);

stepper3.setMaxSpeed(500.0);
stepper3.setAcceleration(10000.0);
stepper3.moveTo(10000000);

pinMode(pingPinOUT, OUTPUT);
pinMode(pingPinIN, INPUT);
}

void loop()
{
// establish variables for duration of the ping,
// and the distance result in inches and centimeters:
float duration, inches, cm;

// The PING))) is triggered by a HIGH pulse of 2 or more microseconds.

// Give a short LOW pulse beforehand to ensure a clean HIGH pulse:

digitalWrite(pingPinOUT, LOW);
delayMicroseconds(2);
digitalWrite(pingPinOUT, HIGH);
delayMicroseconds(3);
digitalWrite(pingPinOUT, LOW);

// The same pin is used to read the signal from the PING))): a HIGH
// pulse whose duration is the time (in microseconds) from the sending
// of the ping to the reception of its echo off of an object.

duration = pulseIn(pingPinIN, HIGH, 700);

// convert the time into a distance

//inches = microsecondsToInches(duration);
cm = microsecondsToCentimeters(duration);

if(cm>6||cm==0){

stepper2.run();

stepper3.run();
}

//Retroceso
else{
stepper2.stop(); // Stop as fast as possible: sets new target
stepper2.setMaxSpeed(450.0);
 stepper2.setCurrentPosition(0);
stepper2.moveTo(4500);
stepper3.stop();
stepper3.setMaxSpeed(450.0);
stepper3.setCurrentPosition(0);
stepper3.moveTo(4500);

while (stepper2.currentPosition() < 3000){ // Full speed basck to 0

stepper2.run();
stepper3.run();
}
stepper2.moveTo(-100000);
stepper3.moveTo(100000);
stepper2.setMaxSpeed(500.0);
stepper3.setMaxSpeed(500.0);
}

////lcd.setCursor(0,1); // enviamos la coordenada de impresión

//Serial.print(inches);
//Serial.print("in, ");
////lcd.print(cm);
////lcd.setCursor(5,1);
////lcd.print(" cm");
//Serial.print(cm);
//Serial.print("cm");
//Serial.println();

delay(2);
}

float microsecondsToInches(float microseconds)

{
// According to Parallax's datasheet for the PING))), there are
// 73.746 microseconds per inch (i.e. sound travels at 1130 feet per
// second). This gives the distance travelled by the ping, outbound
// and return, so we divide by 2 to get the distance of the obstacle.
// See: http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
return microseconds / 74.00 / 2.00;
}

float microsecondsToCentimeters(float microseconds)

{
// The speed of sound is 340 m/s or 29 microseconds per centimeter.
// The ping travels out and back, so to find the distance of the
// object we take half of the distance travelled.
return microseconds / 29.00 / 2.00;
}

/* Prueba de Motor Paso a Paso con Driver ULN200

Gira hacia la derecha e izquierda en 8 Pasos
luego Gira a la derecha e izquierda en 4 pasos

Arduino Driver
8 IN1
9 IN2
10 IN3
11 IN4
Tienda en Linea: http://dinastiatecnologica.com/
*/
int retardo=4;
int cont = 0;
int cont2 = 0;

void setup() {

pinMode(11, OUTPUT); // Pin 11 conectar a IN4

pinMode(10, OUTPUT); // Pin 10 conectar a IN3
pinMode(9, OUTPUT); // Pin 9 conectar a IN2
pinMode(8, OUTPUT); // Pin 8 conectar a IN1
}

void loop() {

for (cont=1; cont<=255;cont++){ //secuencia reloj EN 8 PASOS

digitalWrite(11, LOW);
digitalWrite(10, LOW);
digitalWrite(9, LOW);
digitalWrite(8, HIGH);
delay(retardo);
digitalWrite(11, LOW);
digitalWrite(10, LOW);
digitalWrite(9, HIGH);
digitalWrite(8, HIGH);
delay(retardo);
digitalWrite(11, LOW);
digitalWrite(10, LOW);
digitalWrite(9, HIGH);
digitalWrite(8, LOW);
delay(retardo);
digitalWrite(11, LOW);
digitalWrite(10, HIGH);
digitalWrite(9, HIGH);
digitalWrite(8, LOW);
delay(retardo);
digitalWrite(11, LOW);
digitalWrite(10, HIGH);
digitalWrite(9, LOW);
digitalWrite(8, LOW);
delay(retardo);
digitalWrite(11, HIGH);
digitalWrite(10, HIGH);
digitalWrite(9, LOW);
digitalWrite(8, LOW);
delay(retardo);
digitalWrite(11, HIGH);
digitalWrite(10, LOW);
digitalWrite(9, LOW);
digitalWrite(8, LOW);
delay(retardo);
digitalWrite(11, HIGH);
digitalWrite(10, LOW);
digitalWrite(9, LOW);
digitalWrite(8, HIGH);
delay(retardo);
}
delay(500);

for (cont=1; cont<=255;cont++){ //secuencia CONTRARIA reloj EN 8 PASOS

digitalWrite(11, HIGH);
digitalWrite(10, HIGH);
digitalWrite(9, LOW);
digitalWrite(8, LOW);
delay(retardo);
digitalWrite(11, LOW);
digitalWrite(10, HIGH);
digitalWrite(9, LOW);
digitalWrite(8, LOW);
delay(retardo);
digitalWrite(11, LOW);
digitalWrite(10, HIGH);
digitalWrite(9, HIGH);
 digitalWrite(8, LOW);
delay(retardo);
digitalWrite(11, LOW);
digitalWrite(10, LOW);
digitalWrite(9, HIGH);
digitalWrite(8, LOW);
delay(retardo);
digitalWrite(11, LOW);
digitalWrite(10, LOW);
digitalWrite(9, HIGH);
digitalWrite(8, HIGH);
delay(retardo);
digitalWrite(11, LOW);
digitalWrite(10, LOW);
digitalWrite(9, LOW);
digitalWrite(8, HIGH);
delay(retardo);
digitalWrite(11, HIGH);
digitalWrite(10, LOW);
digitalWrite(9, LOW);
digitalWrite(8, HIGH);
delay(retardo);
digitalWrite(11, HIGH);
digitalWrite(10, LOW);
digitalWrite(9, LOW);
digitalWrite(8, LOW);
delay(retardo);
}
delay(500);

for (cont=1; cont<=255;cont++){ //secuencia total reloj EN 4 PASOS

digitalWrite(11, LOW);
digitalWrite(10, LOW);
digitalWrite(9, HIGH);
digitalWrite(8, HIGH);
delay(retardo);

digitalWrite(11, LOW);
digitalWrite(10, HIGH);
digitalWrite(9, HIGH);
digitalWrite(8, LOW);
delay(retardo);

digitalWrite(11, HIGH);
digitalWrite(10, HIGH);
digitalWrite(9, LOW);
digitalWrite(8, LOW);
delay(retardo);

digitalWrite(11, HIGH);
digitalWrite(10, LOW);
digitalWrite(9, LOW);
digitalWrite(8, HIGH);
delay(retardo);
}
delay(500);

for (cont=1; cont<=255;cont++){ //secuencia CONTRARIA reloj EN 4 PASOS

digitalWrite(11, HIGH);
digitalWrite(10, HIGH);
digitalWrite(9, LOW);
digitalWrite(8, LOW);
delay(retardo);

digitalWrite(11, LOW);
digitalWrite(10, HIGH);
digitalWrite(9, HIGH);
digitalWrite(8, LOW);
delay(retardo);
digitalWrite(11, LOW);
digitalWrite(10, LOW);
digitalWrite(9, HIGH);
digitalWrite(8, HIGH);
delay(retardo);

digitalWrite(11, HIGH);
digitalWrite(10, LOW);
digitalWrite(9, LOW);
digitalWrite(8, HIGH);
delay(retardo);
}
delay(500);
}

__-----
 SERVOMOTOR CON ARDUINO TUTORIAL DE PROGRAMACIÓN PASO A PASO

En este artículo te voy a enseñar cómo utilizar un servomotor con Arduino. Antes de continuar es
importante saber qué es un servomotor o servo. Es un motor eléctrico, pero con dos características
especiales.
Por un lado, nos permite mantener una posición que indiquemos, siempre que esté dentro del rango
de operación del propio dispositivo. Por otro lado nos permite controlar la velocidad de giro,
podemos hacer que antes de que se mueva a la siguiente posición espere un tiempo.

El ejemplo más típico es un coche teledirigido, esos que

utilizan los niños y no tan niños. Estos juguetes suelen tener un
mando a distancia donde podemos controlar la velocidad y el
giro del coche. Precisamente el giro se suele hacer con un
servomotor donde indicamos, en cada momento, la posición o
el ángulo de giro que queremos que tenga en un preciso
momento.

Características técnicas de un servomotor con Arduino

Hay varios modelos de servomotor con Arduino. En este caso
vamos a utilizar un Micro Servo 9g SG90 de Tower Pro. Como
siempre digo, hay que mirar la ficha técnica del producto.
Todos tienen un funcionamiento muy parecido y la programación puede variar muy poco.

Cosas a tener en cuenta con este dispositivo. Lo primero, el ángulo de giro, en este caso nos permite
hacer un barrido entre -90º y 90º. Lo que viene a ser un ángulo de giro de 180º.
Aunque el servo puede moverse con una resolución de más de 1 grado, este es el máximo de
resolución que vamos a conseguir debido a la limitación de la señal PWM que es capaz de generar
Arduino UNO.

Estos motores funcionan con una señal PWM, con un pulso de trabajo entre 1 ms y 2 ms y con un
periodo de 20 ms (50 Hz). ¿Qué quiere decir todo esto? Este dato nos indica la velocidad máxima
a la que podemos mover el servomotor con Arduino. Solo podremos cambiar de posición cada 20
ms. Esto dependerá del tipo y marca de nuestro servo.
El elegir una salida PWM u otra da lo mismo, todas las salidas de este tipo funcionan igual.

Conexionado con Arduino

Las conexiones dependerán del tipo de
servomotor con Arduino que estemos
utilizando.

Todos deben tener 3 cables. Uno irá a

tierra, otro a la alimentación de 5
Voltios y el tercero a un pin PWM.
También puedes utilizar un shield para
controlar servomotores, como el de
Adafruit.
¿Cómo programar un servo
desde el entorno de Arduino?

Ahora vamos a ir a lo
interesante, la programación.
Para ello tenemos que hacer
uso de una librería externa para
poder controlar el servo desde
Arduino. Para incorporar la
librería tenemos que ir a
Programa/Include Library/Servo.

El código para girar el motor de 0º a 180º

Esta acción ya nos ha hecho un include en nuestro código que nos permite controlar el servo.
Un código básico para posicionar el servo en los ángulos 0º, 90º y 180º.

//Creado: Luis del Valle (ldelvalleh@programarfacil.com)

#include <Servo.h> // Incluímos la librería para poder controlar el servo
Servo servoMotor; // Declaramos la variable para controlar el servo
void setup() { // Iniciamos el monitor serie para mostrar el resultado
Serial.begin(9600);
// Iniciamos el servo para que empiece a trabajar con el pin+ 9
servoMotor.attach(9);
}
void loop() {
servoMotor.write(0); // Desplazamos a la posición 0º
delay(1000); // Esperamos 1 segundo
// Desplazamos a la posición 90º
servoMotor.write(90);
// Esperamos 1 segundo
delay(1000);
// Desplazamos a la posición 180º
servoMotor.write(180);
// Esperamos 1 segundo
delay(1000);
}

//---------------------------------

De la librería Servo.h hemos declarado un objeto o variable servoMotor y hacemos uso de dos
métodos. Por un lado el attach, que nos permite indicar en que pin tenemos conectado nuestro
servo, y por otro lado el write, donde indicamos en qué ángulo queremos posicionar nuestro
servomotor.
Girando grado a grado el servomotor

Vamos a realizar otro ejemplo un poco más complicado, en este caso queremos que el servo haga
un barrido desde el 0 al 180º y luego en sentido contrario. Vamos a utilizar los mismos métodos
pero incorporamos dos bucles for, uno para cada sentido.

Girando grado a grado el servomotor

Vamos a realizar otro ejemplo un poco más complicado, en este caso queremos que el servo haga
un barrido desde el 0 al 180º y luego en sentido contrario. Vamos a utilizar los mismos métodos,
pero incorporamos dos bucles for, uno para cada sentido.

1 //Creado: Luis del Valle (ldelvalleh@programarfacil.com)

2 https://programarfacil.com
3 // Incluímos la librería para poder controlar el servo
4 #include <Servo.h>
5 // Declaramos la variable para controlar el servo
6 Servo servoMotor;
7 void setup() {
8 // Iniciamos el monitor serie para mostrar el resultado
9 Serial.begin(9600);
10 // Iniciamos el servo para que empiece a trabajar con el pin 9
11 servoMotor.attach(9);
12 // Inicializamos al ángulo 0 el servomotor
13 servoMotor.write(0);
14 }
15 void loop() {
16 // Vamos a tener dos bucles uno para mover en sentido positivo y otro en sentido negativo
17 // Para el sentido positivo
18 for (int i = 0; i <= 180; i++)
19 {
20 // Desplazamos al ángulo correspondiente
21 servoMotor.write(i);
22 // Hacemos una pausa de 25ms
23 delay(25);
24 }
25 // Para el sentido negativo
26 for (int i = 179; i > 0; i--)
27 {
28 // Desplazamos al ángulo correspondiente
29 servoMotor.write(i);
30 // Hacemos una pausa de 25ms
31 delay(25);
32 }
33 }
Conclusión

Controlar un servo desde Ardunino es una tarea muy sencilla gracias al uso de la librería Servo.h.
Te recomiendo que sigas practicando con esta librería. Si te ha gustado el artículo, compártelo.
Si tienes alguna duda, deja un comentario abajo de este artículo.

Solo programando se aprende a programar.

https://programarfacil.com/tutoriales/fragmentos/servomotor-con-arduino/