¿Que es Arduino?
Arduino es una plataforma de hardware y software libre que sirve para crear proyectos de electrónica sin necesidad de muchos conocimientos
¿Que puedo hacer con Arduino?
Con Arduino se pueden crear una infinidad de proyectos ya que solo depende de la imaginación de quien lo utiliza, unos cuantos ejemplos de proyectos, irrigadores automáticos, huertos urbanos automatizados, impresoras 3D, sistema de iluminación automática, estaciones meteorológicas, drones, navegadores GPS, Robots, entre tantas opciones.
¿Puedo trabajar con Arduino sin saber Programación?
La verdad es que No, pero con este tutorial aprenderás a programar ya que solo siguiendo unas instrucciones básicas, aprenderás como funciona y tendrás una buena introducción a la programación.
¿Porque usar Arduino?
Arduino posee un hardware que podemos utilizar para conectar casi cualquier tipo de sensor y actuadores completamente documentados y ademas posee un lenguaje de programación muy simple y similar a lo que usaríamos con python, C, etc. , lo que hace que no tengamos que aprender otro lenguaje de programación.
¿Que Chips Utiliza Arduino?
Arduino fue creado con chips Atmel de la marca Microchip y actualmente también están desarrollando placas con ST Microsystem que son los chip que utilizan las controladoras de vuelo de los drones.
¿Como Puedo empezar a utilizar Arduino?
La mejor manera de aprender Arduino es practicando con ejemplos simples tanto en el montaje del Hardward ( placas y accesorio) como practicando en su programación.
¿Que Herramientas Necesito para trabajar con Arduino?
Una de las principales Herramientas que necesitas es un ordenador para poder utilizar su plataforma Arduino IDE( el programa en el cual escribimos el codigo y es el que traduce nuestro programa al chip). una herramienta muy util es una PCB o protoboard ya que nos permitira crear circuitos electronicos de una forma simple, cables de conexiones, tambien depende de que proyecto queramos hacer el modulo correpondiente. en proyectos mas avanzados podemos utlizar soldador, alicates de corte, etc.
¿Necesito tener conocimientos de electrónica para trabajar con Arduino?
gracias a los módulos de Arduino es necesario saber algo básico pero a lo largo de estos tutoriales los aprenderas.
¿Que conocimientos previos de programación ayudan con Arduino?
Cualquier conocimiento en programación ayuda pero como menciono anteriormente el lenguaje de programación es muy similar a otros lenguajes y es muy simple de aprender.
¿Es muy caro hacer proyectos con Arduino?
La verdad es que no, hay packs que vienen con muchos módulos y realmente son muy económicos, como también por separado, hay que recordar que son totalmente re utilizables por lo que los podremos usar en varios proyectos sin necesidad de volver a comprar
¿Desde que edad se puede utilizar Arduino?
Si bien no hay una edad establecida, a partir de que se sabe leer y escribir se puede empezar con proyectos simples e interactivos, que a muchos niños les encanta ya que pueden crear proyectos asombrosos, pero a pesar que se pueden utilizar por niños es muy aconsejable que tengan supervicion de un adulto
Introduccion a la Programacion de Arduino
Arduino tiene su propio lenguaje de programación muy similar a otros,
como todo lenguaje de programación cuenta con una estructura a la hora de hacer el programa. dicha estructura tiene que ser respetada en todo momento si no nos dará fallo y nuestro programa no funcionara
Programar con Arduino
La forma mas simple de entender como se programa y como este programa lo interpreta el micro contolador es la de un libro y un lector(El libro puede tener 1 o varias paginas).
El lector comienza a leer el libro e interpreta linea a linea el texto, el microcontrolador hace lo mismo lee 1 linea y ejecuta su contenido, con la diferenciara que al terminar el libro lo vuelve a leer una y otra ves.
Hay una forma de controlar lo que lee y en que orden lee el libro el microcontrolador llamadas funciones. Para ponernos en materia descargaremos la herramienta
Herramienta Arduino IDE
Primero que nada necesitaremos el Programador de Arduino llamado Arduino IDE podemos descargarlo gratuitamente desde su pagina web https://www.arduino.cc/en/Main/Software , aqui encontroremos las versiones para distintos tipos de sistema operativo como asi tambien para tipos de maquina.
Como se ve en la imagen tenemos distintos tipo de instalacion o paquete para windows, si queremos instalar en windows podemos utilizar la primera opción o la tercera.
En caso que tengamos un Mac tendremos que descargar el archivo dmg que figura como Mac OS X.
y en caso que usemos linux PC podemos optar por descargar 32 o 64 bits o simplemente desde consola podemos intalar la ulima version con el comando sudo apt-get install arduinoide
En el caso que utilicemos micro pc como raspberry pi utilizaremos las versiones de Linux ARM
Una vez descargado e instalado el programa lo abrimos y nos aparece asi:
podemos ver que nos muestra 2 funciones:
void setup() {
// put your setup code here, to run once:
}
void loop() {
// put your main code here, to run repeatedly:
}
setup: esta función es para configurar los pines y puertos de nuestro Arduino. Esta función se llama una sola vez al empezar el programa.
uno ejemplo de como se rellena:
void setup()
{
pinMODE(pin, OUTPUT); //configuramaos el pin como salida
pinMODE(pin, INPUT); //configuramaos el pin como entrada
}
loop: en esta función es donde pondremos el código de nuestro programa que queremos que se ejecute repetidamente.
void loop() {
digitalWrite(pin, HIGH); //enciende el pin
delay(1000); //espera 1 segundo
digitalWrite(pin, LOW); //apaga el led
delay(1000); //espera 1 segundo, y vuelve a empezar a leer loop de nuevo desde el innicio
}
Funciones
¿Que es una función y para que sirve?
Las funciones son un bloque de código o instrucciones que son contenidas por un nombre, como vimos anteriormente setup() y loop(), de las cuales podemos crear y llamar en cualquier punto de nuestro programa.
Existen 2 tipos de funciones:
Las que solo ejecutan un código sin ínteractuar con con el resto llamadas vacias (void).
Las que devuelve un valor al terminar su ejecución llamadas (type).
Sirven para poder desviar o ejecutar a distintos códigos mediante condicionantes y así poder conducir el programa como sea necesario. de otro modo Arduino leería y ejecutaría todo el código escrito linea por linea.
Debemos tener en cuenta la forma de escribir las funciones correctamente
/* esto es un blouqe de comentario que puede
ocupar
varias lineas de ser necesario */
tipo nombre() {
codigo; //Comenterio si se desea agregar alguno
}
primero asignamos el tipo de Función, si es type o void, luego el nombre de la función() y abrimos llaves para colocar el contenido de la función{}. dentro de las llaves, colocamos el código, al terminar cada linea de código dentro de las llaves colocamos ;
NOTA: cuando nos referimos a una función type, es una función que nos devuelve un valor según el tipo de variable que pueden ser: byte, int, long, float, etc.
Si queremos hacer uno comentario de varias lineas lo podemos hacer con: /* el comentario */.
si queremos hacer un comentario en la linea donde esta el código utilizamos //
Ejemplo de funciones:
Función Vacia
void setup()
{
// Puede contener un codigo o no
}
Funcion Type
En este ejemplo utilizamos la función pote() para que lea el valor de un potenciómetro y nos devuelva su valor
int pote()
{
int i; // crea una variable temporal llamada "i"
i= analogRead(pot); // lee el valor del potenciómetro
i /= 4; // convierte 0-1023 a 0-255
return i; // devuelve el valor final
}
funciones
Constantes
Aduino IDE tiene unos valores predeterminados reservados, que se utilizan para que el programa sea mas facil de leer y escribir y se dividen en grupos:
Constantes
| HIGH | INPUT | SERIAL | PI |
| LOW | OUTPUT | DISPLAY | HALF_PI |
| LSBFISRT | MSBFIRST | CHANGE | TWO_PI |
| FALIING | RISING | ||
| false | true | null |
Variables de asignación de puertos y constantes
| DDRB | DDRC | DDRD |
| PINB | PINC | PIND |
| PORTB | PORTC | PORTD |
| PB0 | PC0 | PD0 |
| PB1 | PC1 | PD1 |
| PB2 | PC2 | PD2 |
| PB3 | PC3 | PD3 |
| PB4 | PC4 | PD4 |
| PB5 | PC5 | PD5 |
| PB6 | PC6 | PD6 |
| PB7 | PC7 | PD7 |
Tipo de datos
| boolean | byte | char | class | default |
| do | double | int | long | delayMicroseconds |
| micros | / | /** | . | else |
| == | exp | false | float | floor |
| for | < | <= | HALF_PI | if |
| ++ | != | || | ! | && |
Entradas y salidas digitales (I/O)
| digitalRead() | digitalWrite() | pinMode() |
Entradas y Salidas analógicas
| analogRead() | analogReference() | analogWrite() |
Entradas y salidas Avanzado
| noTone() | tone() | shiftIn() |
| pulseIn() | pulseInLong() | shiftOut() |
Tiempo
| delay() | micros() |
| delayMicroseconds() | milis() |
Matematicos
| abs() | constain() | map() | pow() |
| max() | min() | sq() | sqrt() |
Trigonométrica
| tan() | atan() | atan2() |
| sin() | asin() | PI |
| cos() | acos() | TOW_PI |
Interrupciones Externas
| attachInterrupt() | detachInterrupt() |
Números aleatorios
| random() | randomSeed() |
Bits y Bytes
| bit() | bitClear() | bitRead() | bitSet() |
| bitWrite() | highByte() | lowByte() |
Comunicacion
| read() | write() | print() | peek() |
| flush() | begin() | println() | avalible() |
| serial() | Steam() | serialEvent() | parseInt() |
Un tipo de constante que normalmente utilizaremos son las booleanas:
Al comenzar a programar Arduino en la sección de void Setup() tendremos que definir que pines serán entradas y cuales salidas, para ello utilizaremos 2 constante INPUT para las entradas y OUTPUT para las salidas. Ejemplo
void setup() {
pinMode(11, OUTPUT); //asignamos el pin 11 como salida
pinMode(12, INPUT); //asiganmos el pin 12 como entrada
}
void loop() {
// put your main code here, to run repeatedly:
}
pìnMode: es una instrucción que se utiliza para asignar el modo de trabajo de los pines si es entrada o salida(por defecto Arduino tiene configurado todos los pines como entrada(INPUT) por lo que al configurar en void Setup() solo configuraríamos las salidas «pinMode(x, OUTPUT);» x es el numero del pin que queremos asignar como salida.
Cunado nos referimos a una Consulta TRUE( verdadero) el valor que obtenemos puede ser 1, -1, 2 o -200. mientras que si es FALSE(falso) el valor que se recibe de la consulta es 0.
if (x == TRUE); //en un condicionante if preguntamos si el valor de x es igual a verdadero
{
ejecutas el codigo;
}
Cuando nos referimos al estado de un pin o salida digital las llamamos HIGH y LOW, HIGH es cuando la salida esta activa (5 Volts) y LOW cuando esta desactivada(0 Volts).
digitalWrite(11, HIGH) // activamos el pin digital 11 = 5Volts
delay (1000) // espera 1 segundo
digitalWrite(11, LOW) // desactiva el pin 11 = 0Volts
Variables
Una variable es una forma de almacenar un dato y darle nombre a un valor para usarlo en el programa. a su ves este nombre que se le asigna también puede ser actualizado, cambiando su valor constantemente. tenemos 5 tipos de Variables:
byte
byte es una variable de 8 bits enteros (sin decimales) que puede almacenar un valor entre 0 y 255. ejemplo:
byte lavariable = 125; //agrega una variable llama "lavariable" con un valor de 125
int
Almacenas números enteros de 16bits sin decimales en un rango entre 32767 y -32768. ejemplo de como se declara:
int lavariable = 2000; //agrega una variable llama "lavariable" con un valor de 2000
long
Almacena números enteros de 32bits sin decimales el rango es 2147483647 a -2147483648
long lavariable = 80000; //agrega una variable llama "lavariable" con un valor de 2000
float
Float almacena valores de punto flotante son numeros decimales comprendidos entre 3.4028235E +38 a +38 -3.4028235E.
Las variables float a pesar de tener mas resolucion que los datos de 32bits no son valores exactos y su calculo es un proceso mucho mas lento que con otro tipo de variable, por lo que de ser posible debemos evitar usar este tipo de variable.
float pi = 3.14159265; //agrega una variable llama "pi" con un valor de 3,14159265
char
char almacena caracteres de la tabla ASCII, lo guardara de forna numérica.
gracias a la característica de este tipo de variable podemos hacer operaciones aritméticas con los caracteres
char var = A; //agrega una variable llama "var" con un valor de A que corresponde a 65 en la tabla
array
Una variable array almacena diversos valores dentro de una misma variable, a dichos valores se les asigna una posición ( a esta posición se le llama indice). El índice siempre empieza desde la posición 0, ejemplo:
int miArray[] = {0, 1, 2 ,3, 4, 5, 6}; //agrega una variable llamada "miArray" con un valor en el indice 0 = 0, en el indice 1 = 1, en el indice 2 = 2,... , en el inice 6 = 6
modo e uso:
int miArray[] = {0, 1, 2 ,3, 4, 5, 6}; //agrega una variable llamada "miArray" con un valor en el indice 0 = 0, en el indice 1 = 1, en el indice 2 = 2,... , en el inice 6 = 6
int miArray[7]; //indicamos que la variable miArray sus valores son enteros(int) y que tiene 7 posiciones 0,1,2,3,4,5,6 (7).
int x; // declaramos la variable x
int y; // declaramos la variable y
x = miArray[7] //a la variable x le asignamos el valor del indice 6 de la varible miArray
y = miArray[6] //a la variable y le asignamos el valor del indice 5 de la varible miArray
/* como es una variable también podemos cambiar cualquier valor que este asignado a uno de sus índices*/
int z = 10; // declaramos la variable z con un valor entero de 10
int v = 15; // declaramos la variable v con un valor entero de 25
miArray[0] = z+v //asignamos al indice 0 de la variable miArray el resultado de la suma de z+v
podemos asignar una variable al inicio del programa antes de la función setup(), o dentro de una función. Ejemplo:
int resultado; //es una variable llamada resultado que no tiene ningun valor asignado
int pot = 2; //es una variable llamada pot que asigna el pin 2
/*
Ambas variables al ser asignadas al inicio del programa
son visible desde cualquier parte o proceso del programa
*/
void setup() {
// ejemplo de setup vacio:
}
void loop() {
for (int i=0; i<5;) // solo podemos usar el valor de i detro del blucle de for:
{
i++;
}
float z; //z solo es visible dentro del bucle loop
}
Aritmética
Las operaciones aritméticas que se utilizan en el entorno de programación son: suma, resta, multiplicación y división. Estos estos devuelven la suma, diferencia, producto o cociente (respectivamente) de 2 operandos
y = y + 4; //suma x = x - 1; //resta v = u * 3; // multiplicacion q = q / 2; // divicion
Asignaciones compuestas
Las asignaciones compuestas combinan las operaciones aritméticas con una variable asignada. Estas se utilizan comúnmente en bucles como veremos posteriormente. Las asignaciones son:
x ++ // X es igual que el valor de x + 1 (incrementa en 1 el valor de x) x -- // X es igual que el valor de x - 1 (decrementa en 1 al valor de x) x += y // x es igual a la suma del valor de x + y (incrementa el valor de y a x) x-= y //x es igual a la resta del valor de x menos el valor de y (decrementa el valor de y en x) x *= y //x es igual a x por y ( multiplica el valor de x popr la cantidad de veces de y) x /= y //x es igual al valor de x dividido el valor de y (divide x por y)Por ejemplo si quiero que el bucle sume automaticamente el valor 3 a la variable x utilizaria el siguiente codigo
x += 3; //esto hace que del valor actual de la variable x suma 3 /* en un bucle lo repetira hasta que se cumpla un valor que haga que cambie de estado el bucle */
Operaciones de comparación
Las operaciones de comparación se utilizan para comparar una variable o constante en condicionantes como if para saber si se cumple la condición. Las operaciones son:
x == y //x es igual a y x != y //x no es igual a y x < y //x es menor que y x > y //x es mayor que y x <= y // x es menor o igual que y x >= y //x es mayor o igual que y
Operaciones lógicas
Las operaciones lógicas son la forma de obtener un verdadero o falso por medio de dos operaciones de comparación. Las operaciones que se pueden utilizar son: AND(&&), OR(||) y NOT(!), normalmente utilizadas en los condicionantes if . ejemplo de uso:
/* Lógica AND = el resultado sera verdadero solo si se cumplen las dos condiciones: X es mayor a 0 pero menor que 5 */ if (x > 0 && x < 5) /* Lógica OR = el resultado es verdadero si unas de estas dos condiciones se cumple: x es mayor que 0, o y es mayor que 0 */ if(x > 0 || y > 0) /* Logica NOT = el resultado es verdadero si no se cumple: x no es mayor que 0 */ if(!x > 0)
Control de estructura
Se utilizan para comprobar una condición o hacer que se cumpla una condición, también nos sirven para hacer que el programa ejecute unas instrucciones u otras.
Estructuras de Condicionantes:
if: Este condicionante lo utilizamos para comprobar si una condición se cumple. si se cumple puede ejecutar un instrucción o devolver un valor.
/* La mejor forma de leer este condicionante es:
if (Varible ?? valor)
si (la Varible cumple la condición con respecto al valor) ejecuta las instrucciones que tiene entre llaves{}
?? = Operaciones de comparación
*/
if (Varible ?? valor)
{
ejecutaUnaInstruccion;
}
if else: Utilizamos este condicionante cuando al hacer una consulta queremos que ejecute una instrucción y si no se cumple que ejecute otra instrucción. Ejemplo:
/* La mejor forma de leer este condicionante es:
if (Varible ?? valor)
si (la Varible cumple la condición con respecto al valor)
{
ejecutaPrimeraInstruccion.
}
sin no se cumple la condición
{
ejecutaSegundaInstruccion
}
?? = Operaciones de comparación
*/
if (Varible ?? valor)
{
ejecutaPrimeraInstruccion;
}
else
{
ejecutaLaSegundaInstruccion;
}
Podemos generar una cadena de consultas tanto si se cumple el condicionante o no, Ejemplo:
int x = 5; // declaramos la variable X y le asingnamos el valor 5
int ledRojo = 13; // declaramos la variable ledRojo al pin 13
int ledAmarillo = 12; // declaramos la variable ledAmarillo al pin 12
int ledVerde = 11; // declaramos la variable ledVerde al pin 11
void setup() {
pinMode(ledRojo, OUTPUT); // configuramos como salida el pin de la varible ledRojo
pinMode(ledAmarillo, OUTPUT); // configuramos como salida el pin de la varible ledAmarillo
pinMode(ledVerde, OUTPUT); // configuramos como salida el pin de la varible ledVerde
}
void loop() {
if (x > 0) // preguntamos SI X es mayor que 0
{
digitalWrite(ledVerde, HIGH); //si es mayor que 0 enciende el led verde
}
else if (x < 10) // preguntamos SI X es menor que 10
{
digitalWrite(ledRojo, HIGH); //si es menor que 10 enciende el led rojo
if (x == 5) // preguntamos si el valor de X es 5
{
digitalWrite(ledAmarillo, HIGH); // si el valor de x es 5 se enciende el led amarillo
}
}
else // si x no es mayor que 0
{
digitalWrite(ledVerde, LOW); // apaga los leds
digitalWrite(ledRojo, LOW);
digitalWrite(ledAmarillo, LOW);
}
}
while: es un bucle que se ejecuta la misma cadena de instrucciones mientras la variable que esta a prueba no cambie. para salir del bucle tiene que cambiar la variable
/* La mejor forma de leer este condicionante es:
while (Varible ?? valor)
mientras (la Varible cumple la condición con respecto al valor) ejecuta las instrucciones que tiene entre llaves{}
?? = Operaciones de comparación
*/
while (Varible ?? valor)
{
ejecutaUnaInstruccion;
}
Un ejemplo: si queremos que una variable reste de 1 en 1 su valor de 100 hasta llegar a 5
int x = 100; // valor de la variable al iniciar
int ledVerde = 12;
void setup() {
pinMode(ledVerde, OUTPUT);
}
void loop() {
while (x >= 6) // se ejecutara el bucle while hata que el valor sea inferior a 6
{
digitalWrite(ledVerde, HIGH); // enciende el led verde
delay (500); // espera 1/2 segundo
digitalWrite(ledVerde, LOW); // apaga el led verde
delay (500); // espera 1/2 segundo
x = x--; // resta 1 al valor de X
}
}
do while: trabaja igual que while pero primero se ejecutan las instrucciones antes que la comprobación. Ejemplo:
int x = 100; // valor de la variable al iniciar
int ledVerde = 12;
void setup() {
pinMode(ledVerde, OUTPUT);
}
void loop() {
do
{
digitalWrite(ledVerde, HIGH); // enciende el led verde
delay (500); // espera 1/2 segundo
digitalWrite(ledVerde, LOW); // apaga el led verde
delay (500); // espera 1/2 segundo
x = x--; // resta 1 al valor de X antes de la comprobación
} while (x >= 6); // se ejecutara el bucle while hata que el valor sea inferior a 6
}
switch case
switch case como if es una forma de dirigir el programa según el valor de una variable, pero en con esta forma ejecutara el código hasta que encuentre la constante break
este método se puede utilizar con una variable int o char
switch (var) { //esta variable es la que decide que caso se aplicara
case label1: //label1 es el valor de la variable
// Aqui va el codigo que queremos ejecutar
break; // Para el proceso y vuelve una lina por debajo desde donde se llama a switch
case label2: // label2 es otro valor de la variable var
// Aqui va el codigo que ejecuta cuando la variable es label2
break;
default: // si las variable no son iguales a ningunos de los casos
// se ejecuta este codigo
break;
}
for
for es un bucle que ejecuta un código un numero determinado de veces hasta que la que la condición de una variable no se cumpla. a diferencia de if a for se le indica un valor de la variable con el que inicia el bucle, la condición que debe cumplir para que se ejecute el bucle y la aritmética que debe seguir al cumplirse. Ejemplo:
for (variable al inicio; condicion; aritmética)
{
código a repetir
}
for (int i=0; i<10; i++) //la variable i se declara como int con valor 0
//la condicion es que i tinene que ser menor a 10
// al aritmética es que el valor de i aumente 1 cada vez que se ejecuta el código.
{
digitalWrite(ledRojo, HIGH);
delay(100);
digitalWrite(ledRojo, LOW);
delay(100);
Trabajando con operaciones y variable
podemos trabajar con operación básicas suma, resta, multiplicación y división pero tambien tenemos la posibilidad de modificar el valor de una varia entre 2 valores asignar el valor minimo y el valor maximo, o obtener un valor aleatorio. para eso usaremos min(x,y) para calcular el valor minimo, max(x,y) el maximo y random()
Puero serie en Arduino
Dependiendo de que Arduino estemos usando podemos tener 1 o varios puertos series UART, lo primero que debemos tener en cuenta son las velocidades en baudios que lo utilizaremos ya que si tenemos un programa muy largo la velocidad con la que trabajemos retrasara el tiempo que se ejecute el código que esta por debajo de la linea la cual pedimos enviar un dato o recibir un dato.
las velocidad de trabajo pueden ser:
300, 1200, 2400, 4800, 9600, 19200, 38400, 57600, 74880, 115200, 230400, 250000, 500000, 1000000, 2000000.
también debemos tener en cuenta que hay velocidades muy altas que solo algunos procesadores trabajan normalmente se utilizan 9600, 57600 y 115200. estas configuraciones se colocan con su respectivas contantes en la funcion de configuracion void setup() de la siquiente forma:
void setup() {
Serial.begin(9600);
}
En la funcion loop() es donde podemos leer o escribir el puerto serie
void setup() {
Serial.begin(9600);
}
void loop() {
if (Serial.available()) { // comprueba si hay datos en el puerto serie
int inByte = Serial.read(); // crea la variable inByte y coloca el valor que lee del puerto serie
Serial.write(inByte); // escribe en el pueto serie el valor que recibio
}
También podemos enviar texto
void setup() {
Serial.begin(9600);
}
void loop() {
Serial.print(" esto es un texto ");
delay(500);
}
al recibirlo por el puerto serie se veria asi:
esto es un texto esto es un texto esto es un texto esto es un texto
las repeticiones del texto se debe a que no hay salto de linea y que al estar solo en el loop lo envia repedirdamnete
para hacer un salto de linea utilizamos Serial.println
void setup() {
Serial.begin(9600);
}
void loop() {
Serial.println(" esto es un texto ");
delay(500);
}
esto es un texto esto es un texto esto es un texto esto es un texto
también podemos enviar un valor convertido en distinto tipos de datos
void setup() {
Serial.begin(9600);
}
void loop() {
int valor = 10;
Serial.println(valor); // envia la variable en ASCII
delay(500);
Serial.println(valor, DEC); // envia la variable en Decimal
delay(500);
Serial.println(valor, HEX); // envia la variable en Hexadecimal
delay(500);
Serial.println(valor, OCT); // envia la variable en Octal
delay(500);
Serial.println(valor, BIN); // envia la variable en Binario
delay(500);
Serial.println(valor, BYTE); // envia la variable en Byte
delay(500);
}
¿Como Crear un programa en Arduino?
Bien ya teniendo las explicaciones de cada cosa y pudiendo consultarlas para que son y como se usan podemos pasara a explicar como hacer nuestro programa.
Lo primero que tenemos que entender que todo lo hacemos a base de matemáticas, de los valores de nuestras constantes y los valores de variables que pueden cambiar ya sea por el valor de un sensor o de un calculo.
El comportamiento de nuestro programa lo dirigiremos mediante controles de estructura y funciones, para ello la mejor forma es hacer un diagrama de como se comportara nuestro programa
teniendo un diagrama de como queremos que se comporte nuestro programa podremos saber si es mejor usar switch en ves de if, o que calculo debemos tener en cuenta para que active o desactive un pin.
Nuestro Primer programa
/*
Programa de inicio con lecturas a traves del puerto serie
*/
void setup() {
// iniciamos el puerto serie:
Serial.begin(9600);
}
void loop() {
int Variable = 0;
Serial.write("Inicio del Programa");
}
Con este simple programa podemos ver el funcionamiento de nuestro arduino, al utilizar los calculos y al agregar funciones, en los sitios que necesitamos saber si funciona de forma correcta podemos colocar "Serial.println("untexto");"para saber en que parte del progrtama se encuentra.
lo primero que vamos hacer es cargar el pequeño programa de ejemplo copiamos el programa en nuestro arduino ide
una vez copiado el programa utilizamos compilar para comprobar que esta correctamente copiado
si esta correctamente copiado nos mostrara en la parte inferior del programa lo siguiente:
A continuación podemos seleccionar que placa arduino tenemos y que puerto utilizaremos para comunicar con Arduino
En la parte superior del Programa vamos a Herramientas -> Placa -> Arduino UNO
Nosotros para hacer este tutorial comenzaremos utilizando Arduino UNO ya que es uno de los mas versátiles y simples del mercado, Luego seleccionaremos el puerto de nuestra placa Arduino UNO Conectada al Ordenador
En la parte superior del Programa vamos a Herramientas -> Puerto -> En micaso es el COM9 y al estar conectado al Ordenador Me muestra que es el Arduino UNO
Ya tenemos Configurada Nuestra Placa Arduino Con el puerto correcto y comprobado el programa a cargar, ahora solo queda subir el programa al microchip desde el botón subir.
Con este botón cargamos el programa al Arduino que volvera a compilar
El programa ya esta en el Arduino y si queremos ver que funciona correctamente podemos ir a Herramientas -> Monitor Serie
Tambien podemos Utilizar las teclas Ctrl+Mayús+M o
De cualquiera de las 3 maneras abriríamos el monitor del puerto serie.
esto nos mostrara gracias a la linea Serial.write("Inicio del Programa"); una comunicanion con arduino
si queremos verlo de una manera mas ordenada podemos cambiar la linea Serial.write("Inicio del Programa"); por Serial.println("Inicio del Programa");
/*
Programa de inicio con lecturas a traves del puerto serie
*/
void setup() {
// iniciamos el puerto serie:
Serial.begin(9600);
}
void loop() {
int Variable = 0;
Serial.write("Inicio del Programa");
}
y el resultado seria este
Fuentes Utilizadas:
https://playground.arduino.cc/ArduinoNotebookTraduccion/Appendix7/
https://www.arduino.cc/reference/en/
