en cmd instalar mediante pip la biblioteca serial
pip install serial
pip install pyserial
Mostrando las entradas con la etiqueta Arduino. Mostrar todas las entradas
Mostrando las entradas con la etiqueta Arduino. Mostrar todas las entradas
Bluetooth Arduino datos para hacerlo funcionar
Viene configurado por defecto con lo siguiente:
* Modo esclavo, es decir, nos conectamos a él.
* Nombre: HC-05.
* Contraseña: 1234
* Velocidad en Baudios: 9600
En arduino debemos programar la comunicación como Serial.begin(9600);
* Led que titila constantemente: esperando conexión.
* Led de doble titileo: dispositivo conectado.
* Led que titila constantemente: esperando conexión.
* Led de doble titileo: dispositivo conectado.
Ejemplo de código arduino Mega con puerto serial de la pc y de arduino
Con una App enviar al Bluetooth texto y número, y ver en la terminal serial lo que se recibe.
Incluir el caracter Z para concluir una línea.
Código:
char letra = "";String palabra = "";int numero;void setup() {Serial.begin(115200);Serial3.begin(9600);Serial.println("Bienvenidos");}void loop() {if (Serial3.available()>0){//delay(5);letra = Serial3.read();if (letra != 'Z'){palabra += letra;Serial.println(letra);}else{Serial.println("Se ha completado una palabra");Serial.println(palabra);Serial.println("La pasaremos a un entero");numero = palabra.toInt();Serial.println(numero);palabra = "";}}}
Pasar de String a Int en segundos con toInt() en Arduino
Pasar fácilmente en arduino una cadena a un entero
Variable int aquí = Variable String aquí agregar seguido.toInt();
Ejemplo:
String palabra = "543";
int numero;
void setup() {
}
void loop() {
numero = palabra.toInt();
// Listo
}
otro ejemplo:
Al recibir unos caracteres los imprime individualmente,
Al recibir Z mayúscula, imprime la palabra completa
Convierte los caracteres en números enteros
char letra = "";
String palabra = "";
int numero;
void setup() {
Serial.begin(115200);
Serial.println("Bienvenidos");
}
void loop() {
if (Serial.available()>0){
letra = Serial.read();
if (letra != 'Z')
{
palabra += letra;
Serial.println(letra);
}
else
{
Serial.println("Se ha completado una palabra");
Serial.println(palabra);
Serial.println("La pasaremos a un entero");
numero = palabra.toInt();
Serial.println(numero);
palabra = "";
}
}
}
Random en Arduino, generar numero al azar
Obtener un número al azar (Aleatorio) con función random
random(min, max):
min es el mínimo valor deseado.
max es el máximo valor deseado.
Ejemplo
int aleatorio;
void setup() { Serial.begin(9600);
}
void loop() {
Serial.print("A"); Serial.print(aleatorio); Serial.println("Z"); delay(500);}
Grabar en la memoria interna EEPROM del Arduino, super fácil
Arduino tiene una memoria interna que se llama EEPROM, es super fácil de usar, acá un ejemplo concreto:
El siguiente código va para en las dos partes del ejemplo, vamos a hacer un programa para grabar las variables y uno para leerlas.
Incluir la librería:
#include <EEPROM.h>
Declarar las variables necesarias:
int v1;
int v2;
En el setup se podría leer las variables una vez que estén escritas, pero si es la primera vez, no lo hagamos. Mejor inicialicemos el puerto serie para obtener una respuesta:
void setup() {
Serial.begin(115200);
}
En el Loop: podremos grabar y leer también, vamos a ver un ejemplos de cada uno:
Grabar: se hace con EEPROM.write(posición,número de 0 a 255);
Leer: se hace con variable = EEPROM.read(posición);
void loop() {
v1 = EEPROM.read(1);
v2 = EEPROM.read(2);
Serial.print("El valor de la posición 1 es:"):
Serial.println(v1):
Serial.print("El valor de la posición 2 es:"):
Serial.println(v1):
delay(8000);
}
Así de fácil.
Por si no queda claro: pegar este ejemplo primero:
#include <EEPROM.h>
int v1;
int v2;
void setup() {
Serial.begin(115200);
}
void loop() {
v1 = EEPROM.read(1);
v2 = EEPROM.read(2);
Serial.print("El valor de la posición 1 es: ");
Serial.println(v1);
Serial.print("El valor de la posición 2 es: ");
Serial.println(v1);
delay(8000);
}
ahora pegar este otro:
#include <EEPROM.h>
int v1;
int v2;
void setup() {
Serial.begin(115200);
}
void loop() {
EEPROM.write(1,20); // guarda el valor 20 (atención: el máximo es es 255)
EEPROM.write(2,5); // guarda el valor 5
Serial.println("Se ha grabado");
Serial.println("hacer el ejemplo de lectura para recuperar el valor de la posición 1 y 2");
delay(8000);
}
;)
Código de ejemplo de ingreso por teclado en Arduino
Código sencillo para arduino,
Si se ingresa la letra "a" o bien "b", se imprime en el puerto serial la frase correspondiente.
Si se ingresa la letra "a" o bien "b", se imprime en el puerto serial la frase correspondiente.
char teclado;
void setup() {
Serial.begin(115200);
Serial.println("Bienvenido al programa");
}
void loop() {
teclado = Serial.read();
if (teclado == 'a'){
Serial.println("Se ha detectado la a");
}
else if (teclado == 'b'){
Serial.println("Se ha detectado la b");
}
}
Cómo es el tema de los relés optoacoplados
El tema de los reles optoacoplados (optoaislados) bien explicado es así:
Si el jumper está puesto, el electroiman se alimenta directamente desde la placa arduino, y si sucediera una falla en el relé, se correría riesgo de dañar el microcontrolador; entonces como primer paso será retirar el jumper y buscar una fuente externa de 5v para alimentar JD-VCC (Ejemplo, fuente Yrobot para protoboard); y por otro lado alimentar VCC con los 5v de Arduino.
GND irá a GND de Arduino.
Muy importante saber esto:
Mientras no se alimenten las entradas IN, los relés permanecerán encendidos.
* IN1,2,3,4 van a pines digitales de arduino. Pin en LOW para encender el relé, y pin en HIGH para apagarlo.
Por otro lado un detalle a tener en cuenta es que muchos reles tienen un N/A(normal abierto) y N/C(normal cerrado), eso significa que:
* N/C está dando paso de energía siempre que el relé esté apagado, y corta el paso de energía siempre que esté encendido.
* N/A, funciona de modo inverso que N/C, es el que usamos normalmente, al energizar el relé se habilita el paso de energía.
Entonces conectando diferente obtenemos un resultado inverso, pero el detalle a tener en cuenta es que habrá un período en el que los reles no estarán energizados, y esto daría paso a la energía.
Para invertir el tema del pin, se podría optar por una compuerta inversora (NOT) por ejemplo un 7404.
El circuito del relé optoacoplado es el siguiente:
Si el jumper está puesto, el electroiman se alimenta directamente desde la placa arduino, y si sucediera una falla en el relé, se correría riesgo de dañar el microcontrolador; entonces como primer paso será retirar el jumper y buscar una fuente externa de 5v para alimentar JD-VCC (Ejemplo, fuente Yrobot para protoboard); y por otro lado alimentar VCC con los 5v de Arduino.
GND irá a GND de Arduino.
Muy importante saber esto:
Mientras no se alimenten las entradas IN, los relés permanecerán encendidos.
A la inversa de lo que normalmente se usaría, hay que mandar un HIGH para mantener apagado el relé, al dejar de alimentarlo, se encenderá.
* IN1,2,3,4 van a pines digitales de arduino. Pin en LOW para encender el relé, y pin en HIGH para apagarlo.
Por otro lado un detalle a tener en cuenta es que muchos reles tienen un N/A(normal abierto) y N/C(normal cerrado), eso significa que:
* N/C está dando paso de energía siempre que el relé esté apagado, y corta el paso de energía siempre que esté encendido.
* N/A, funciona de modo inverso que N/C, es el que usamos normalmente, al energizar el relé se habilita el paso de energía.
Entonces conectando diferente obtenemos un resultado inverso, pero el detalle a tener en cuenta es que habrá un período en el que los reles no estarán energizados, y esto daría paso a la energía.
Para invertir el tema del pin, se podría optar por una compuerta inversora (NOT) por ejemplo un 7404.
El circuito del relé optoacoplado es el siguiente:
Función Si en lenguaje C (Función if... else.. else if..)
// Si (comparación), ejecutar código
if (comparación)
{
Código;
}
//-----------------------------
// Si (comparación), ejecutar código1, sino ejecutar código2.
if (comparación)
{
Código1;
}
else
{
Código2;
}
//-----------------------------
// Si (comparación1), ejecutar código1, sino si (comparación2) ejecutar código2, sino ejecutar código3.
if (comparación1)
{
código1;
}
else if(comparación2)
{
código2;
}
else
{
código3;
}
if (comparación)
{
Código;
}
//-----------------------------
// Si (comparación), ejecutar código1, sino ejecutar código2.
if (comparación)
{
Código1;
}
else
{
Código2;
}
//-----------------------------
// Si (comparación1), ejecutar código1, sino si (comparación2) ejecutar código2, sino ejecutar código3.
if (comparación1)
{
código1;
}
else if(comparación2)
{
código2;
}
else
{
código3;
}
Ejemplo que comprueba que Millis() se desborda, pero no afecta al programa
8) Se ve que por suerte y de algún modo se corrige el código, porque en teoría no debería funcionar, pero funciona como si nada pasara.
Aquí el código de ejemplo, se usa la variable unsigned long simuladormillis para hacer el incremento simulando a millis()
//INICIO-----------------------------------------------------------------------------------------------------------
unsigned long simuladormillis; // simula millis() iniciando en el valor que se indica más abajo.
int cada; // cada cuanto se imprimen los ....... puntos
unsigned long tiempodedisparo; // para comparar con el simulador de millis.
void setup() {
simuladormillis = 4294967290; // El límite de millis() será 4294967295; en este caso restamos 20 para dar un margen de conteo.
cada =7; // cada 7 incrementos del simulador de millis, se imprimirán los .......
Serial.begin(9600);
tiempodedisparo = simuladormillis + cada; // Se determina el tiempo en el que deberá entrar en el if.
}
void loop() {
Serial.println(simuladormillis); // Imprimirá siempre el valor del simulador de millis().
simuladormillis ++; // Incremensta el simulador de millis
if (simuladormillis >= tiempodedisparo){ // si el simulador de millis es igual al tiempo de disparo
Serial.println("............."); // imprime ......
tiempodedisparo = simuladormillis + cada; // da un nuevo valor al comparador
}
delay(200); // retrasamos para que vaya un poco más lento el proceso y se vea mejor
}
//FIN-----------------------------------------------------------------------------------------------------------
concluyo que no se detendría Serial.println("............."); al desbordarse millis().
Aquí el código de ejemplo, se usa la variable unsigned long simuladormillis para hacer el incremento simulando a millis()
//INICIO-----------------------------------------------------------------------------------------------------------
unsigned long simuladormillis; // simula millis() iniciando en el valor que se indica más abajo.
int cada; // cada cuanto se imprimen los ....... puntos
unsigned long tiempodedisparo; // para comparar con el simulador de millis.
void setup() {
simuladormillis = 4294967290; // El límite de millis() será 4294967295; en este caso restamos 20 para dar un margen de conteo.
cada =7; // cada 7 incrementos del simulador de millis, se imprimirán los .......
Serial.begin(9600);
tiempodedisparo = simuladormillis + cada; // Se determina el tiempo en el que deberá entrar en el if.
}
void loop() {
Serial.println(simuladormillis); // Imprimirá siempre el valor del simulador de millis().
simuladormillis ++; // Incremensta el simulador de millis
if (simuladormillis >= tiempodedisparo){ // si el simulador de millis es igual al tiempo de disparo
Serial.println("............."); // imprime ......
tiempodedisparo = simuladormillis + cada; // da un nuevo valor al comparador
}
delay(200); // retrasamos para que vaya un poco más lento el proceso y se vea mejor
}
//FIN-----------------------------------------------------------------------------------------------------------
concluyo que no se detendría Serial.println("............."); al desbordarse millis().
Encender el Led Onboard del Módulo Wi Fi Esp8266 V12 programar con Arduino IDE
El código es muy sencillo, es como el que trae arduino ide para arduino, pero el pin debe ser el Nº 2 del módulo Esp8266 V12
void setup() {
pinMode(2, OUTPUT);
}
void loop() {
digitalWrite(2, HIGH);
delay(1000);
digitalWrite(2, LOW);
delay(1000);
}
Acá muestro el código y que ya lo he compilado al 100%, más abajo explico paso a paso.
Antes de compilar el programa para cargarlo se debe verificar esto:
* La placa debe ser la siguiente:
Menú Herramientas - Placa Generic Esp8266 Module - Generci Esp8266 Module
* El puerto se debe seleccionar aquí:
Herramientas - Puerto: _____ probar alguno de la lista o bien para estar más seguro, si se tiene windows 7 por ejemplo se puede buscar en administrador de dispositivos, lo detallo más abajo.
Resultado final en gif animada del Esp8266 v12 funcionando en protoboard con el programa del Blink que enciende el pin nº 2.
Proximamente: Pasos previos de configuración y conexión para que el Esp8266 funcione con el IDE de Arduino.
void setup() {
pinMode(2, OUTPUT);
}
void loop() {
digitalWrite(2, HIGH);
delay(1000);
digitalWrite(2, LOW);
delay(1000);
}
Acá muestro el código y que ya lo he compilado al 100%, más abajo explico paso a paso.
Antes de compilar el programa para cargarlo se debe verificar esto:
* La placa debe ser la siguiente:
Menú Herramientas - Placa Generic Esp8266 Module - Generci Esp8266 Module
* El puerto se debe seleccionar aquí:
Herramientas - Puerto: _____ probar alguno de la lista o bien para estar más seguro, si se tiene windows 7 por ejemplo se puede buscar en administrador de dispositivos, lo detallo más abajo.
Saber con seguridad el puerto al cual está conectado:
Ejemplo para Windows 7
1) Clic derecho en Equipo, clic en propiedades.
2) Clic en Administrador de dispositivos, clic en Puertos (COM y LPT), y ahí ver por ejemplo el COM6 en mi caso). Esto mismo sirve también para conocer el COM cuando se conecta Arduino.
Ahora si ya se puede enviar el programa, previamente habiendo mantenido presionado el botón reset que se ve cerca del módulo en la proto, y luego seguido y antes de soltar el reset, habiendo conectado el cable que dice Flash que sale del GPIO0. (toda esta configuración la voy a explicar en otro post)
Para que quede más claro:
* Presionar Reset por dos o tres segundos
* Antes de soltar reset conectar el GPIO0 cable FLASH de la imagen.
* Clic en el botón de la flecha para enviar.
Ahora que ya se ha presionado el botón para enviar, hay que esperar hasta que cargue al 100%, he leído por ahí que si se interrumpe la carga dejará de funcionar el módulo, por las dudas prefiero NO hacer la prueba ;) Así que ATENCIÓN en esta parte del proceso.
Resultado final en gif animada del Esp8266 v12 funcionando en protoboard con el programa del Blink que enciende el pin nº 2.
Proximamente: Pasos previos de configuración y conexión para que el Esp8266 funcione con el IDE de Arduino.
Valores Máximos para Arduino Uno
Especificaciones Máximas Absolutas de Arduino UNO
Temperatura Mínima de Operación: -55 °C
Temperatura Máxima de Operación: +125 °C
Temperatura Mínima de Almacenamiento: -65 °C
Temperatura Máxima de Almacenamiento: +125 °C
Voltaje en todo pin menos el de reset: -0.5V a Vcc +0.5V
Voltaje en el pin reset con respecto a tierra: -0.5V a +13.0V
Voltaje Máximo de Operación: 6.0V
Corriente continua por pin de entrada y salida: 40.0 mA
Corriente continua de Vcc y Tierra: 200.0 mA
No conectar directamente motores, tiras led y reles; porque no hay que forzar al pin de arduino a netregar más corriente de la que puede soportar.
Se debe usar amplificadores de corriente como lo son los transistores, ejemplo el BC547 o el 2N2222 para pequeñas cargas, pequeños motores o tiras leds.
Para motores grandes o cualquier carga mayor, se puede hacer un arreglo Darlington usando un transistor de alta ganancia como el BC547 o 2N2222 controlando a un transistor de mayor ganancia como es el TIP31C o el Tip122 ya que soportan mayor cantidad de amperes; hay que revisar cada datasheet.
Número 255 en Binario es 1111 1111
Número decimal 255 es 11111111 en el sistema binario
1 bit = cero o uno, es un lugar.
8 bits = 1 byte = 8 lugares donde pueden ir cero o uno. _ _ _ _ _ _ _ _
Los números decimales que se pueden almacenar son desde el 0 hasta el 255
Ejemplos:
0000 0000 = 0
0000 0001 = 1
0000 0010 = 2
0000 0011 = 3
......
1111 1100 = 252
1111 1101 = 253
1111 1110 = 254
1111 1111 = 255
La memoria EEPROM de Arduino almacena 1kb es decir 1024 bytes, cada byte puede almacenar un valor desde 0 hasta 255.
1 bit = cero o uno, es un lugar.
8 bits = 1 byte = 8 lugares donde pueden ir cero o uno. _ _ _ _ _ _ _ _
Los números decimales que se pueden almacenar son desde el 0 hasta el 255
Ejemplos:
0000 0000 = 0
0000 0001 = 1
0000 0010 = 2
0000 0011 = 3
......
1111 1100 = 252
1111 1101 = 253
1111 1110 = 254
1111 1111 = 255
La memoria EEPROM de Arduino almacena 1kb es decir 1024 bytes, cada byte puede almacenar un valor desde 0 hasta 255.
Cómo usar Motores Paso a Paso UNIPOLARES con Arduino
Pueden tener 5 o 6 cables, en el caso de que tenga 5, será porque tienen unido los cables medios de la bobina, ya veremos que estos se conectan en simultaneo a +12V.
1º) Con el Multímetro (tester) medir la conductividad entre las diferentes puntas de los cables buscando los 3 de una bobina y los 3 de la otra.
2º) Suponiendo que ya distinguimos continuidad entre los terminales abc y en el otro caso def, habrá que probar la resistencia para identificar cual es el hilo medio.
Poniendo como ejemplo el primer grupo (abc), habrá menos resistencia entre ab y cb que entre ac, y con esto distinguimos que b es el cable medio.
7º) Cómo hacer la conexión desde el microcontrolador
El tiempo entre pulso y pulso lo puede ir experimentando el usuario, ej: probar con un delay de 100 milisegundos entre pasos.
Transistor Tip122
1º) Con el Multímetro (tester) medir la conductividad entre las diferentes puntas de los cables buscando los 3 de una bobina y los 3 de la otra.
Poniendo como ejemplo el primer grupo (abc), habrá menos resistencia entre ab y cb que entre ac, y con esto distinguimos que b es el cable medio.
Se muestra un ejemplo de 3 mediciones en el gráfico anterior.
3º) En el caso de tener 6 cables, unir los medios y aplicar +12V.
En nuestro ejemplo se unirá “b” con “e”.
4º) Determinar una secuencia, en la que veamos que el motor gira de a un paso.
Tocamos las bobinas unidad con “a”, “c”, “e” y “f” buscando una secuencia para que gire; si por ejemplo al tocar “a”, da un paso, asignamos el número 1 de giro para “a”.
Y así repetimos el proceso hasta obtener la secuencia 1, 2, 3, 4 que determina que gire en un sentido.
3º) En el caso de tener 6 cables, unir los medios y aplicar +12V.
En nuestro ejemplo se unirá “b” con “e”.
4º) Determinar una secuencia, en la que veamos que el motor gira de a un paso.
Tocamos las bobinas unidad con “a”, “c”, “e” y “f” buscando una secuencia para que gire; si por ejemplo al tocar “a”, da un paso, asignamos el número 1 de giro para “a”.
Y así repetimos el proceso hasta obtener la secuencia 1, 2, 3, 4 que determina que gire en un sentido.
5) Paso por paso:
La tabla muestra en cada momento como se envía una señal a cada cable; es una secuencia para que el motor avance paso por paso.
La tabla muestra en cada momento como se envía una señal a cada cable; es una secuencia para que el motor avance paso por paso.
Medio paso:
Si polarizamos entre 2 bobinas, el rotor estará entre una y otra, y hará medio paso (celdas amarillas de la secuencia).
Si polarizamos entre 2 bobinas, el rotor estará entre una y otra, y hará medio paso (celdas amarillas de la secuencia).
6º) Para invertir el giro, correr la secuencia de pulsos al revés.
7º) Cómo hacer la conexión desde el microcontrolador
El tiempo entre pulso y pulso lo puede ir experimentando el usuario, ej: probar con un delay de 100 milisegundos entre pasos.
Transistor Tip122
Una cosa a tener en cuenta es que el motor tiene que arrancar girando lento, luego alcanzará la velocidad de trabajo constante y finalmente una velocidad de desaceleración para detenerse.
Ingreso por teclado desde la PC en Arduino y el encendido de un led
Encender un led en el pin 13 al presionar la tecla "a" y desactivarlo con la misma tecla si está encendido
no se necesita resistencia para el led, justamente porque el pin 13 ya la tiene incorporada.
int led1 = 13; // variable q almacena solamente el "número" de pin de salida en el cual está el led en arduino
char leer; // variable para almacenamiento de caracteres
boolean encendido = true; // variable de almacenamiento de estado binario
void setup() {
Serial.begin(9600); // inicialización del puerto serial para la comunicación a 9600 baudios
pinMode (led1,OUTPUT); // se declara salida al pin que contiene el led, el número depende de la variable led1
digitalWrite(led1, HIGH);
}
void loop() {
leer = Serial.read(); //almacena la lectura del puerto serial en la variable "leer" que es de tipo caracter
if ((leer == 'a')&&(encendido == false)){ //si en la variable leer aparece la letra "a"; y si el led no está encendido hacer lo siguiente:
digitalWrite(led1, HIGH); //Encender el led
encendido = true; // asigna el valor 1 a la variable encendido, que da seguimiento al estado booleano del led
}else if ((leer == 'a')&&(encendido == true)){
digitalWrite(led1, LOW); //Apagar el led
encendido = false; // asigna el valor 0 a la variable encendido, que da seguimiento al estado booleano del led
}
}
no se necesita resistencia para el led, justamente porque el pin 13 ya la tiene incorporada.
int led1 = 13; // variable q almacena solamente el "número" de pin de salida en el cual está el led en arduino
char leer; // variable para almacenamiento de caracteres
boolean encendido = true; // variable de almacenamiento de estado binario
void setup() {
Serial.begin(9600); // inicialización del puerto serial para la comunicación a 9600 baudios
pinMode (led1,OUTPUT); // se declara salida al pin que contiene el led, el número depende de la variable led1
digitalWrite(led1, HIGH);
}
void loop() {
leer = Serial.read(); //almacena la lectura del puerto serial en la variable "leer" que es de tipo caracter
if ((leer == 'a')&&(encendido == false)){ //si en la variable leer aparece la letra "a"; y si el led no está encendido hacer lo siguiente:
digitalWrite(led1, HIGH); //Encender el led
encendido = true; // asigna el valor 1 a la variable encendido, que da seguimiento al estado booleano del led
}else if ((leer == 'a')&&(encendido == true)){
digitalWrite(led1, LOW); //Apagar el led
encendido = false; // asigna el valor 0 a la variable encendido, que da seguimiento al estado booleano del led
}
}
¿Cómo conectar un led en arduino?, Led RGB y Transistor 2N2222
El ánodo será la patilla que esté asociada a tu pin 5V y el cátodo irá a GND.
La resistencia será de 330 o 220 Ω
No importa en donde se coloque la resistencia, si entre el ánodo y el led o el cátodo y el led, lo importantes es lograr la caída de voltaje.
La resistencia será de 330 o 220 Ω
No importa en donde se coloque la resistencia, si entre el ánodo y el led o el cátodo y el led, lo importantes es lograr la caída de voltaje.
Los LEDs RGB tiene 4 patas, una es un ánodo comñun o bien puede ser una de cátodo común y el resto ánodos, habitualmente suelen ser más los LEDs RGB de ánodo común
* ánodo, “polo positivo”
* cátodo, “polo negativo”
En resumen, en un LED RGB de ánodo común como la parte que diferencia a los tres LEDs que componen el diodo son los cátodos, tendrás que “jugar” con los cátodos para conseguir colores y, en el caso de los LEDs de cátodo común, serán los ánodos lo que habrá que variar.
El voltaje de funcionamiento de cada uno de los colores es aproximadamente 2.1V para el color rojo y 3.3V para los colores verde y azul; con una corriente máxima de 20mA
La longitud de onda (que se asocia a la tonalidad de color) del color rojo es de unos 625nm. En el caso del color verde es 520nm y en el color azul son 465nm.
La intensidad luminosa oscila entre los 200-300mcd para el color rojo, 800-1000mcd para el color verde y 300-400mcd para el color azul.
La pata correspondiente al ánodo la podrás identificar fácilmente porque su tamaño es mayor que las demás, y se conecta a los 5v; luego el resto se conecta con resistencias individuales.
o bien a los pines digitales aptos para simular salida digital (3,5,6,9,10,11)
Las salidas PWM (ancho de pulso modulado) que vienen representadas en tu Arduino con el símbolo “~”, proporcionan 5V (al igual que el resto de salidas digitales) con la diferencia de que oscilan su valor entre 0V y 5V al ritmo que tú le indiques mediante la instrucción analogWrite(), consiguiendo así simular valores de voltaje intermedios.
Debes tener en cuenta que la caída de voltaje que se produce en la patilla asociada al color rojo es menor, por lo que, si la resistencia es la misma en todas las patillas, circulará más corriente (recuerda aquí el límite de los 20mA). Ésto también quiere decir que el rojo brillará más (aunque como el ojo humano es menos sensible al rojo, esto es un factor positivo)
analogWrite(PinDelLedRojo, valor entre 127 al 255 para q funcione);
analogWrite(PinDelLedVerde, valor entre 127 al 255 para q funcione);
analogWrite(PinDelLedAzul, valor entre 127 al 255 para q funcione);
Para un mejor funcionamiento se utiliza un transistor 2N2222
continuará...
Fuente:
http://www.educachip.com/led-rgb-arduino-anodo-comun/
Ejemplo comunicación serial Arduino y Visual Basic 6
Con estas simples lineas, Visual Basic recibe texto enviado por Arduino
En el código se encuentra una función antirebote para cuando se presiona el botón, la señal pueda ser detectada correctamente.
Código para Arduino:
const int boton = 4; // Botón conectado al pin 4
const int tiempoantirebote = 10;
int cuenta = 0; // lleva la cuenta de cuantas veces se presiona el botón
int estadoboton;
int estadobotonanterior;
//-----inicio------------función antirebote----------
boolean antirebote(int pin){
int contador = 0;
boolean estado; // Guarda el estado del boton
boolean estadoanterior; // Guarda el último estado del botón
do {
estado = digitalRead(pin);
if (estado != estadoanterior){ //comparamos el estado actual con el anterior
contador = 0; // Reiniciamos el contador
estadoanterior = estado;
}
else{
contador = contador + 1;
}
delay(1);
} while(contador < tiempoantirebote);
return estado;
}
//-----fin------------función antirebote----------
void setup() {
Serial.begin(9600); //Inicia la comunicación serial
pinMode(boton, INPUT); //Declara el boton como entrada
}
void loop() {
estadoboton = digitalRead(boton); // leemos el estado del boton
if(estadoboton != estadobotonanterior){ // si hay cambio con respecto al estado anterior
if(antirebote(boton)){ /// verificamos si está presionado y si lo está,
Serial.print("Hola");
delay(1000);
}
}
estadobotonanterior = estadoboton; // guarda el estado del boton
}
Código para Visual Basic 6:
Private Declare Sub Sleep Lib "kernel32" (ByVal dwMilliseconds As Long)
Private Sub Form_Load()
MSComm1.PortOpen = True
Sleep 2000
End Sub
Private Sub MSComm1_OnComm()
Dim ReceivedData As String
ReceivedData = MSComm1.Input
Text1.Text = Text1.Text & ReceivedData
Label1.Caption = ReceivedData
End Sub
Private Sub Form_Unload(Cancel As Integer)
MSComm1.PortOpen = False
End Sub
Private Sub Text1_Change()
Text1.SelStart = Len(Text1.Text)
Text1.SelLength = 0
End Sub
Private Sub Timer1_Timer()
Label1.Caption = MSComm1.Input
End Sub
Label1 recibe el mensaje Hola, que aparece en pantalla.
En el código se encuentra una función antirebote para cuando se presiona el botón, la señal pueda ser detectada correctamente.
Código para Arduino:
const int boton = 4; // Botón conectado al pin 4
const int tiempoantirebote = 10;
int cuenta = 0; // lleva la cuenta de cuantas veces se presiona el botón
int estadoboton;
int estadobotonanterior;
//-----inicio------------función antirebote----------
boolean antirebote(int pin){
int contador = 0;
boolean estado; // Guarda el estado del boton
boolean estadoanterior; // Guarda el último estado del botón
do {
estado = digitalRead(pin);
if (estado != estadoanterior){ //comparamos el estado actual con el anterior
contador = 0; // Reiniciamos el contador
estadoanterior = estado;
}
else{
contador = contador + 1;
}
delay(1);
} while(contador < tiempoantirebote);
return estado;
}
//-----fin------------función antirebote----------
void setup() {
Serial.begin(9600); //Inicia la comunicación serial
pinMode(boton, INPUT); //Declara el boton como entrada
}
void loop() {
estadoboton = digitalRead(boton); // leemos el estado del boton
if(estadoboton != estadobotonanterior){ // si hay cambio con respecto al estado anterior
if(antirebote(boton)){ /// verificamos si está presionado y si lo está,
Serial.print("Hola");
delay(1000);
}
}
estadobotonanterior = estadoboton; // guarda el estado del boton
}
Código para Visual Basic 6:
Private Declare Sub Sleep Lib "kernel32" (ByVal dwMilliseconds As Long)
Private Sub Form_Load()
MSComm1.PortOpen = True
Sleep 2000
End Sub
Private Sub MSComm1_OnComm()
Dim ReceivedData As String
ReceivedData = MSComm1.Input
Text1.Text = Text1.Text & ReceivedData
Label1.Caption = ReceivedData
End Sub
Private Sub Form_Unload(Cancel As Integer)
MSComm1.PortOpen = False
End Sub
Private Sub Text1_Change()
Text1.SelStart = Len(Text1.Text)
Text1.SelLength = 0
End Sub
Private Sub Timer1_Timer()
Label1.Caption = MSComm1.Input
End Sub
Label1 recibe el mensaje Hola, que aparece en pantalla.
Función Map() y Constraint() en Arduino
Una variable llamada "variabletemperatura" tendrá valores entre 10 y 40, se tomará el valor en cada instante y se lo convertirá a un valor entre 0 y 255, se lo almacenará en la variable "variablebrillo".
Ej: variablebrillo = map(variabletemperatura,10,40,0,255); // de 10 a 40 convertir a de 0 a 255
Ej: variablebrillo = constraint(variablebrillo,0,255); // limitar los valores que puede tomar variablebrillo
Ej: variablebrillo = map(variabletemperatura,10,40,0,255); // de 10 a 40 convertir a de 0 a 255
Ej: variablebrillo = constraint(variablebrillo,0,255); // limitar los valores que puede tomar variablebrillo
Comunicación Serial en Arduino pequeño resumen
La comunicación Serial solo se da en los pines 0 y 1
Pin 0 Rx <- (Recibir)
Pin 1 Tx -> (Transmitir)
Se puede conectar 2 arduinos de forma cruzada
El puerto USB sirve para una comunicación serial con la computadora.
Dentro de la función setup escribimos Serial.begin(9600); para que arduino entienda que se debe iniciar la comunicación serial
9600 es la taza de baudio o los bps (bits por segundos) a los que se maneja la comunicación serial(sirve para la comunicación coordinada entre los dispositivos)
Dentro de la función loop escribir lo siguiente:
Serial.print("texto");
Serial.print(variableaqui);
serial.print(",");
delay(500);
Pin 0 Rx <- (Recibir)
Pin 1 Tx -> (Transmitir)
Se puede conectar 2 arduinos de forma cruzada
El puerto USB sirve para una comunicación serial con la computadora.
Dentro de la función setup escribimos Serial.begin(9600); para que arduino entienda que se debe iniciar la comunicación serial
9600 es la taza de baudio o los bps (bits por segundos) a los que se maneja la comunicación serial(sirve para la comunicación coordinada entre los dispositivos)
Dentro de la función loop escribir lo siguiente:
Serial.print("texto");
Serial.print(variableaqui);
serial.print(",");
delay(500);
Entradas analógicas en Arduino
Los pines analógicos ya están declarados como entradas automáticamente (A0 hasta A5)
* Usar la salida analógica: analogWrite(pin, valor de 0 a 255) teniendo en cuenta de haber declarado el pin como salida ej: pinMode(nº, OUTPUT);
* Usar la entrada analógica: analogRead(pin)
Ej
brillo = analogRead(0) // para el pin cero analógico, previamente habiendo declarado la variable brillo.
analogRead lee de 0 a 1023
ej 2.5v = 512
ej 5v = 1023 aproximadamente
Se lo puede usar por ejemplo con un potenciómetro, tomando la entrada analógica y convirtiéndola a una salida digital para encender un led con intensidad regulable.
* Usar la salida analógica: analogWrite(pin, valor de 0 a 255) teniendo en cuenta de haber declarado el pin como salida ej: pinMode(nº, OUTPUT);
* Usar la entrada analógica: analogRead(pin)
Ej
brillo = analogRead(0) // para el pin cero analógico, previamente habiendo declarado la variable brillo.
analogRead lee de 0 a 1023
ej 2.5v = 512
ej 5v = 1023 aproximadamente
Se lo puede usar por ejemplo con un potenciómetro, tomando la entrada analógica y convirtiéndola a una salida digital para encender un led con intensidad regulable.
Simular salida analógica en pin digital de Arduino
Código:
void setup() {
pinMode(3, OUTPUT); // Se declara el pin 3 como salida
// los pines que se pueden usar son: 3,5,6,9,10,11 solamente; se llaman PWM ~
}
void loop() {
analogWrite(3, 255); // se simula una salida analógica en el pin 3 con valor máximo de 255
}
void setup() {
pinMode(3, OUTPUT); // Se declara el pin 3 como salida
// los pines que se pueden usar son: 3,5,6,9,10,11 solamente; se llaman PWM ~
}
void loop() {
analogWrite(3, 255); // se simula una salida analógica en el pin 3 con valor máximo de 255
}
En la imagen:
El pin 3 de arduino va a la pata del led, seguido, se conecta la resistencia (330Ω) a la otra para, y se lo conecta a cualquiera de los dos GND (Tierra) del arduino.
Es útil para usar dentro del ciclo "for"
Suscribirse a:
Entradas (Atom)