Cosas Interesantes que se pueden Hacer con Arduino

Arduino es una plataforma muy versartil la cual perimite la realizacion de varias aplicaciones la cuales se pueden controlar mediante un telofono inteligente como en el encendido de luces de tu casa,colocacion de sensores que automaticamten abriran y cerreran las puertas de tu casa entre otras
les dejo varios videos los cuales encontre en youtube de gente inovando con arduino
https://www.youtube.com/watch?v=UULS4CB_j3A
https://www.youtube.com/watch?v=keV1S3VqW-0
https://www.youtube.com/watch?v=hc0wBjrO2WY
https://www.youtube.com/watch?v=n21y1fTE_MY

analogWrite(pin, value)

Esta instrucción sirve para escribir un pseudo-valor analógico utilizando el procedimiento de modulación por ancho de pulso (PWM) a uno de los pin´s de Arduino marcados como “pin PWM”. El más reciente Arduino, que implementa el chip ATmega168, permite habilitar como salidas analógicas tipo PWM los pines 3, 5, 6, 9, 10 y 11. Los modelos de Arduino más antiguos que implementan el chip ATmega8, solo tiene habilitadas para esta función los pines 9, 10 y 11. El valor que se puede enviar a estos pines de salida analógica  puede darse en forma de variable o constante, pero siempre con un margen de 0-255. 
analogWrite(pin,  valor);  //  escribe 'valor' en el 'pin' definido como  analógico  Si enviamos el valor 0 genera una salida de 0 voltios en el pin especificado; un valor de 255 genera una salida de 5 voltios de salida en el pin especificado. Para valores de entre 0 y 255, el pin saca tensiones entre 0 y 5 voltios - el valor HIGH de salida equivale a 5v (5 voltios). Teniendo en cuenta el concepto de señal PWM , por ejemplo, un valor de 64
equivaldrá a mantener 0 voltios de tres cuartas partes del tiempo y  5 voltios a una cuarta parte del tiempo; un valor de 128 equivaldrá a mantener la salida en 0 la mitad del tiempo y 5 voltios  la otra mitad del tiempo, y un valor de 192 equivaldrá a mantener en la salida 0 voltios una cuarta parte del tiempo y de 5 voltios de tres cuartas partes del tiempo restante.  
Debido a que esta es una función de hardware, en el  pin de salida analógica (PWN) se generará una onda constante después de ejecutada la instrucción analogWrite hasta  que se llegue a ejecutar otra instrucción analogWrite  (o una llamada a digitalRead o digitalWrite en el mismo pin).  
Nota: Las salidas analógicas a diferencia de las digitales,  no necesitan ser declaradas como INPUT u OUTPUT..  

analogRead(pin)

Lee el valor de un determinado pin definido como entrada analógica con una resolución de 10 bits. Esta instrucción sólo funciona en los pines (0-5). El rango de valor que podemos leer oscila de 0  a 1023. 
valor  =  analogRead(pin);  //  asigna a valor  lo que lee en la entrada ´pin'  
Nota: Los pins analógicos (0-5) a diferencia de los pines digitales, no necesitan ser declarados como INPUT u OUPUT ya que son siempre INPUT´s.

digitalWrite(pin, value)

Envía al ´pin´ definido previamente como OUTPUT el valor HIGH o LOW (poniendo en 1 o 0 la salida). El pin se puede especificar ya sea como una variable o como una constante (0-13).  
digitalWrite(pin,  HIGH); //  deposita en el 'pin' un valor HIGH (alto o 1) 
El siguiente ejemplo lee el estado de un pulsador conectado a una entrada digital y lo escribe en el ´pin´de salida LED: 
digitalRead(pin) 
digitalWrite(pin, value)
    Arduino: Manual de Programación  
 21
int  led =  13; //  asigna a LED el valor 13 int  boton = 7; //  asigna a botón el valor  7 int  valor  = 0; //  define el valor y le asigna el valor 0  
void  setup() { pinMode(led,  OUTPUT); //  configura el led (pin13) como salida pinMode(boton,  INPUT); // configura botón (pin7) como entrada } 
void  loop() { valor  =  digitalRead(boton); //lee el estado de la entrada botón digitalWrite(led,  valor); // envía a la salida ´led´el valor leído } 
a continuacion les dejo un turial de youtube de como utilizar este tipo de sentenciahttps://www.youtube.com/watch?v=QvGsbzu0YGY

digitalRead(pin) en Arduino

Lee el valor de un pin (definido como digital) dando un resultado HIGH (alto) o LOW (bajo). El pin se puede especificar ya sea como una variable o una constante (0-13).  
valor  =  digitalRead(Pin); // hace que 'valor sea igual al estado leído  en ´Pin´  

pinMode(pin, mode) en Arduino

Esta instrucción es utilizada en la parte de configuración setup () y sirve para configurar el modo de trabajo de un PIN pudiendo ser INPUT (entrada) u OUTPUT (salida). 
pinMode(pin,  OUTPUT);  //  configura ‘pin’ como salida  
Los terminales de Arduino, por defecto, están configurados como entradas, por lo tanto no es necesario definirlos en el caso de que vayan a trabajar como entradas. Los pines
configurados como entrada quedan, bajo el punto de vista eléctrico, como entradas en estado de alta impedancia.  
Estos pines tienen a nivel interno una resistencia de 20 KΩ a las que se puede acceder mediante software. Estas resistencias se accede de la siguiente manera:  
pinMode(pin,  INPUT); // configura el ‘pin’ como entrada digitalWrite(pin,  HIGH); //  activa las resistencias internas 
Las resistencias internas normalmente se utilizan para conectar las entradas a interruptores. En el ejemplo anterior no se trata de convertir un pin en salida, es simplemente un método para activar las resistencias interiores.  
Los pins configurado como OUTPUT (salida) se dice que están en un estado de baja impedancia estado y pueden proporcionar 40 mA (miliamperios) de corriente a otros dispositivos y circuitos. Esta corriente es suficiente para alimentar un diodo LED (no olvidando poner una resistencia en serie), pero no es lo suficiente grande como para alimentar cargas de mayor consumo como relés, solenoides, o motores.  
Un cortocircuito en las patillas Arduino provocará una corriente elevada que puede dañar o destruir el chip Atmega. A menudo es una buena idea conectar en la OUTUPT (salida) una resistencia externa de 470 o de 1000  Ω.

do While en Arduino

El bucle do while funciona de la misma manera que el bucle while, con la salvedad de que la condición se prueba al final del bucle, por lo que el bucle siempre se ejecutará al menos una vez. 
do 
{
Instrucciones;  }
 while  (unaVariable  ??  valor); 
El siguiente ejemplo asigna el valor leído leeSensor() a la variable 'x', espera 50 milisegundos, y luego continua mientras que el valor de la 'x' sea inferior a 100:  
do  {
x  =  leeSensor(); delay(50);
 }  while  (x  <  100);

While en Arduino y su utilizacion

Un bucle del tipo while es un bucle de ejecución continua mientras se cumpla la expresión colocada entre paréntesis en la cabecera del bucle. La variable de prueba tendrá que cambiar para salir del bucle. La situación podrá cambiar a expensas de una expresión dentro el código del bucle o también por el cambio de un valor en una entrada de un sensor  
while  (unaVariable  ??  valor)
{ 
ejecutarSentencias;
} 
El siguiente ejemplo testea si la variable "unaVariable” es inferior a 200 y, si es verdad, ejecuta las declaraciones dentro de los corchetes y continuará ejecutando el bucle hasta que 'unaVariable' no sea inferior a 200.  
While  (unaVariable  <  200)   //  testea si es menor que 200  {  instrucciones;   //  ejecuta las instrucciones entre llaves unaVariable++;   //  incrementa la variable en 1 }

Como Utilizar for en Arduino

La declaración for se usa para repetir un bloque de sentencias encerradas entre llaves un número determinado de veces. Cada vez que se ejecutan las instrucciones del bucle se
if… else  (si….. sino ..)
for 

vuelve a testear la condición. La declaración for tiene tres partes separadas por (;)  vemos el ejemplo de su sintaxis:  
for  (inicialización;  condición;  expresión)  {  ejecutaInstrucciones; } 
La inicialización de una variable local se produce una sola vez y la condición se testea cada vez que se termina la ejecución de las instrucciones dentro del bucle. Si la condición sigue cumpliéndose, las instrucciones del bucle se vuelven a ejecutar. Cuando la condición no se cumple, el bucle termina.  
El siguiente ejemplo inicia el entero i en el 0, y la condición es probar que el valor es inferior a 20 y si es cierto i se incrementa en 1 y se vuelven a ejecutar las instrucciones que hay dentro de las llaves:  
for  (int  i=0;  i<20;  i++)  //  declara  i,  prueba que es menor que 20,
 incrementa  i en  1 {  digitalWrite(13,  HIGH);   //  envía un 1 al pin 13 delay(250);   //
espera ¼ seg. digitalWrite(13,  LOW); // envía un 0 al pin 13 delay(250);   // espera ¼ de seg.
}  

if… else (si….. sino ..) como Usarlos en Arduino

if… else viene a ser un estructura que se ejecuta en respuesta a la idea “si esto no se cumple haz esto otro”. Por ejemplo, si se desea probar una entrada digital, y hacer una cosa si la entrada fue alto o hacer otra cosa si la entrada es baja, usted escribiría que de esta manera:

if  (inputPin  ==  HIGH) // si el valor de la entrada inputPin es alto 
{
  instruccionesA; //ejecuta si se cumple la condición
 } 
else 
{
 instruccionesB; //ejecuta si no se cumple la condición 
}  

Else puede ir precedido de otra condición de manera que se pueden establecer varias estructuras condicionales de tipo unas dentro de las otras (anidamiento) de forma que sean mutuamente excluyentes pudiéndose ejecutar a la vez. Es incluso posible tener un número ilimitado de estos condicionales. Recuerde sin embargo qué sólo un conjunto de declaraciones se llevará a cabo dependiendo de la condición probada:

if (si) como Utilizarlo en Arduino

if es un estamento que se utiliza para probar si una determinada condición se ha alcanzado, como por ejemplo averiguar si un valor analógico está por encima de un cierto número, y ejecutar una serie de declaraciones (operaciones) que se escriben dentro de llaves, si es verdad. Si es falso (la condición no se cumple) el programa salta y no ejecuta las operaciones que están dentro de las llaves, El formato para if es el siguiente: 
if  (unaVariable  ??  valor)  {  ejecutaInstrucciones; } 
En el ejemplo anterior se compara una variable con un valor, el cual puede ser una variable o constante. Si la comparación, o la condición entre paréntesis se cumple (es cierta), las declaraciones dentro de los corchetes se ejecutan. Si no es así, el programa salta sobre ellas y sigue.  
Nota: Tenga en cuenta el uso especial del símbolo '=', poner dentro de if (x = 10), podría parecer que es valido pero sin embargo no lo es ya que esa expresión asigna el valor 10 a la variable x,  por eso dentro de la estructura if se utilizaría X==10 que en este caso lo que hace el programa es comprobar si el valor de x es 10.. Ambas cosas son distintas por lo tanto dentro de las estructuras if, cuando se pregunte por un valor se debe poner el signo doble de igual “==”

Input/Output en Arduino

Estas constantes son utilizadas para definir, al comienzo del programa, el modo de funcionamiento de los pines mediante la instrucción pinMode de tal manera que el pin puede ser una entrada INPUT o una salida OUTPUT.  
pinMode(13,  OUTPUT); // designamos que el PIN 13 es una salida  

High y Low en arduino

Estas constantes definen los niveles de salida altos o bajos y se utilizan para la lectura  o la escritura digital para las patillas. ALTO se define como en la lógica de nivel 1, ON, ó 5 voltios, mientras que BAJO es lógica nivel 0, OFF, o 0 voltios. 
digitalWrite(13,  HIGH); // activa la salida 13 con un nivel alto (5v.)

Cierto/Falso en Arduino

Estas son constantes booleanas que definen los niveles HIGH (alto) y LOW (bajo) cuando estos se refieren al estado de las salidas digitales. FALSE se asocia con 0 (cero), mientras que TRUE se asocia con 1, pero TRUE también puede ser cualquier otra cosa excepto cero. Por lo tanto, en sentido booleano, -1, 2 y -200 son todos también se define como TRUE. (esto es importante tenerlo en cuanta) 

if  (b  ==  TRUE); 
{  ejecutar las instrucciones; }

Constantes en Arduino

El lenguaje de programación de Arduino tiene unos valores predeterminados, que son llamados constantes. Se utilizan para hacer los programas más fáciles de leer. Las constantes se clasifican en grupos.
Esto nos sirve pra falicitar la programaciòn  de sensores que ya vienen con las librerias necesarias para su utilizaciòn.

Operadores Logicos su Funcion en Arduino

Los operadores lógicos son usualmente una forma de comparar dos expresiones y devolver un VERDADERO o FALSO dependiendo del operador. Existen tres operadores lógicos, AND (&&), OR (||) y NOT (!), que a menudo se utilizan en estamentos de tipo if..: 
Logical AND: if  (x  >  0  &&  x  <  5) // cierto sólo si las dos expresiones son ciertas  
Logical OR: if  (x  >  0  ||  y  >  0)  // cierto si una cualquiera de las expresiones  es cierta 
Logical NOT: if  (!x  >  0)    //  cierto solo si la expresión es falsa

Operadores de Comparacion en Arduino

Las comparaciones de una variable o constante con otra se utilizan con frecuencia en las estructuras condicionales del tipo if.. para testear si una condición es verdadera. En los ejemplos que siguen en las próximas páginas se verá su utilización práctica  usando los siguientes tipo de condicionales: 
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

Asignaciones Compuestas en Arduino

Las asignaciones compuestas combinan una operación aritmética con una variable  asignada. Estas son comúnmente utilizadas en los bucles tal como se describe más adelante. Estas asignaciones compuestas pueden ser: 
x  ++ //  igual que  x  =  x  +  1,   o incrementar x en + 1
x  -- //  igual que  x  =  x  -  1,  o decrementar  x en  -1
x  +=  y //  igual que  x  =  x  +  y,  o incrementra x en  +y
x  -=  y //  igual que  x  =  x  -  y,  o decrementar x en  -y
x  *=  y //   igual que x  =  x  *  y,   o multiplicar  x por  y
x  /=  y //  igual que  x  =  x  /  y,   o dividir x por  y
Nota: Por ejemplo, x * = 3 hace que x se convierta en el triple del antiguo valor x y por lo tanto x es reasignada al nuevo valor .  

Operadores en Arduino

Los operadores aritméticos que se incluyen en el entorno de programación son suma, resta, multiplicación y división. Estos devuelven la suma, diferencia, producto, o cociente (respectivamente) de dos operandos 
y  =  y  +  3;  x  =  x  -  7;  i  =  j  *  6;  r  =  r  /  5;  
La operaciones se efectúa teniendo en cuanta el tipo de datos que hemos definido para los operandos (int, dbl, float, etc..), por lo que, por ejemplo, si definimos 9 y 4 como enteros “int”, 9 / 4 devuelve de resultado  2 en lugar de 2,25 ya que el 9 y 4 se valores de tipo entero “int” (enteros) y no se reconocen los decimales con este tipo de datos.
Esto también significa que la operación puede sufrir un desbordamiento si el resultado es más grande que lo que puede ser almacenada en el tipo de datos. Recordemos el alcance de los tipos de datos numéricos que ya hemos explicado anteriormente.  
Si los operandos son de diferentes tipos, para el cálculo se utilizará el tipo más grande de los operandos en juego. Por ejemplo, si uno de los números (operandos) es del tipo float y otra de tipo integer, para el cálculo se utilizará el método de float es decir el método de coma flotante.  
Elija el tamaño de las variables de tal manera que sea lo suficientemente grande como para que los resultados sean lo precisos que usted desea. Para las operaciones que requieran decimales utilice variables tipo float, pero sea consciente de que las operaciones con este tipo de variables son más lentas a la hora de realizarse el computo..  
Nota: Utilice el operador  (int) myFloat  para convertir un tipo de variable a otro sobre la marcha. Por ejemplo, i = (int) 3,6 establecerá i igual a 3. 

Que es un Array en Arduino

Un array es un conjunto de valores a los que se accede con un número índice. Cualquier valor puede ser recogido haciendo uso del nombre de la matriz y el número del índice. El primer valor de la matriz es el que está indicado con el índice 0, es decir el primer valor del conjunto es el de la posición 0. Un array tiene que ser declarado y opcionalmente asignados valores a cada posición antes de ser utilizado
int  miArray[]  =  {valor0,  valor1,  valor2...}  
Del mismo modo es posible declarar una matriz  indicando el tipo de datos y el tamaño y posteriormente, asignar valores a una posición especifica:  
int  miArray[5];  //  declara un array de enteros de  6  posiciones miArray[3] = 10; //  asigna l valor 10 a la posición 4 
Para leer de un array  basta con escribir el nombre y la posición a leer:  
x  =  miArray[3]; //  x ahora es igual a  10 que está en la posición 3 del array

Tipos de Variables en Arduino.

Enteros son un tipo de datos primarios que almacenan valores numéricos de 16 bits sin decimales comprendidos en el rango 32,767 to -32,768.
Ejemplo 
int  unaVariable  =  1500; //  declara  'unaVariable' como una variable de tipo entero

El formato de variable numérica de tipo extendido “long” se refiere a números enteros (tipo 32 bits) sin decimales que se encuentran dentro del rango -2147483648 a 2147483647. 
long  unaVariable  =  90000;  //  declara 'unaVariable' como tipo long   

El formato de dato del tipo “punto flotante” “float” se aplica a los números con decimales. Los números de punto flotante tienen una mayor resolución  que los de 32 bits con un rango comprendido 3.4028235E +38 a +38-3.4028235E. 
float  unaVariable  =  3.14;  //  declara  'unaVariable' como tipo flotante  
Nota: Los números de punto flotante no son exactos, y pueden producir resultados extraños en las comparaciones. Los cálculos matemáticos de punto flotante son también mucho más lentos que los del tipo de números enteros, por lo que debe evitarse su uso si es posible.  

Como Utilizar una Variable en Arduino.

Una variable puede ser declarada al inicio del programa  antes de la parte de configuración setup(), a nivel local dentro de las funciones, y, a veces, dentro de un bloque, como para los bucles del tipo if.. for.., etc. En función del lugar de declaración de la variable así se determinara el ámbito de aplicación, o la capacidad de ciertas partes de un programa para hacer uso de ella.   Una variable global es aquella que puede ser vista y utilizada por cualquier función y estamento de un programa. Esta variable se declara al comienzo del programa, antes de setup().  

Una variable local es aquella que se define dentro de una función o como parte de un bucle. Sólo es visible y sólo puede utilizarse dentro de la función en la que se declaró. 
declaración

Declaracion de variables en Arduino

Todas las variables tienen que declararse antes de que puedan ser utilizadas. Para declarar una variable se comienza por definir su tipo como int (entero), long (largo), float (coma flotante), etc, asignándoles siempre un nombre, y, opcionalmente, un valor inicial. Esto sólo debe hacerse una vez en un programa, pero el valor se puede cambiar en cualquier momento usando aritmética y reasignaciones diversas. 
El siguiente ejemplo declara la variable entradaVariable como una variable de tipo entero “int”, y asignándole un valor inicial igual a cero. Esto se llama una asignación. 
int  entradaVariable  =  0;  
Una variable puede ser declarada en una serie de lugares del programa y en función del lugar en donde se lleve a cabo la definición esto determinará en que partes del programa se podrá hacer uso de ella.

Se puede decir que no puedes preparar un guisado de carne si antes a ver comprado la carne.
a esto se refiere  con la declaracion de la variables.

Que es una Variable en Arduino.

Una variable es una manera de nombrar y almacenar un valor numérico para su uso posterior por el programa. Como su nombre indica, las variables son números que se pueden variar continuamente
en contra de lo que ocurre con las constantes cuyo valor nunca cambia. Una variable debe ser   
  declarada y, opcionalmente, asignarle un valor.
 Ejemplo
int  variableEntrada  =  0;
  variableEntrada  =  analogRead(2);
Para entender de una mejor manera esto las variables cambian dependiendo la condicion para la cual sean utilizadas, por mencionar tienes un sensor de temperatura el cual es utilizado para saver si tienes agua caliente a esto se refiere con el cambio de  estados de frio a caliente, esto lo puedes utilizar para saber si te puedes bañar  o no.

Como Crear Comentarios en Arduino

Hay dos formar de crear comentarior en Arduino  el Bloque de Comentarios.  ejemplo /*  Esto sirve para dejar un comentario en Arduino */ . o de la Siguiente Forma que se le conoce como linea de comentarios Ejemplo // Esto sirve para decir para que es la siguiente linea de codigo //


Estas Herramientas nos Sirven  para indentificar o dejar comentarios de lo que y para que sirve  el programa en arduino, o para indentificar que y como  hicimos la logica.