ARDUINO PARA ELECTRICISTAS


ÚLTIMAS ENTRADAS

- SIMULADOR DE ARDUINO.







COLABORACIONES:



  José Cerrato nos trae una nueva colaboración,  se trata de algo que seguramente muchos estabais esperando y por supuesto, puede hacerse con Arduino.
Estoy hablando del arrancador estrella-triangulo.



Una nueva colaboración. En esta ocasión se trata de un enlace muy interesante, en el cual se habla sobre información general de Arduino. Pero lo mejor es que incluye información sobre  un programa de simulación.Todos sabemos el valor que tienen estos programas ya que nos permiten comprobar o modificar cualquier proyecto antes de cablearlo lo que nos puede ahorrar alguna que otra sorpresa. Se trata de

VIRTUALBREADBOARD 

No os digo nada sobre el, lo mejor es que veáis el vídeo que seguro lo explica mejor que yo. 

http://www.youtube.com/watch?v=TfemwzKfKrc

El enlace para descargar el programa lo he encontrado en la comunidad Arduinga de Taringa.
http://www.taringa.net/comunidades/arduinga/7989985/Simulador-de-Arduino-Virtual-Breadboard-V3-6.html



INTRODUCCIÓN

QUE ES ARDUINO:
Según la definición de Wikipedia , "Arduino es una plataforma de hardware libre, basada en una placa con un microcontrolador y un entorno de desarrollo, diseñada para facilitar el uso de la electrónica en proyectos multidisciplinares".

En otras palabras, Arduino es una placa electrónica que mediante una programación de software libre y con los correspondientes accesorios es posible realizar diversas aplicaciones relacionadas, en nuestro caso, con la automatización.

Generalmente para realizar un proyecto (llamaremos proyecto a todo aquel diseño que realice alguna función programada previamente) la placa Arduino estará complementada con una serie de accesorios, desde un simple pulsador hasta un transistor, por ejemplo.
Es decir, para muchos "eléctricos", será el primer contacto con el mundo de la electrónica, por lo que será necesario "cambiar un poco el chip" a la hora de interpretar esquemas y manejar conceptos y cantidades no habituales para nosotros, como miliamperios en lugar de amperios o pulsadores Pull-Down o Pull-Up en lugar de contactos abiertos o cerrado, etc.

COMO EMPEZAR:
Evidentemente para empezar, lo primero que se necesita es una placa Arduino. Conseguirla es fácil, basta con teclear "Arduino" en el buscador y aparecerá ante nosotros una abundante oferta.

Lo primero que nos llamará la atención es que existen notables diferencias de precios entre unas páginas y otras, por lo que es recomendable buscar el mejor precio, pero eso sí, con garantías. 
Veremos también que existen una gran cantidad de modelos, "Arduino Uno", "Arduino Mega", "Arduino Nano", etc. Considero que es prudente comenzar poco a poco, por lo que la opción Arduino Uno sería adecuada.
Algunos enlaces:

http://store.arduino.cc/index.php

http://www.miniinthebox.com/es/index.php?main_page=advanced_search_result&inc_subcat=1&search_in_description=0&keyword=arduino

http://dx.com/es/s/arduino

http://www.robotshop.com/en/catalogsearch/result/?q=arduino&order=stats_sales_order_count&dir=desc

http://www.bricogeek.com/shop/


EL SOFTWARE:
Una vez que ya tenemos nuestra placa  Arduino en casa, lo que toca es instalar el programa que nos permita comunicarnos con ella para realizar la programación de nuestros proyectos.
Para la descarga del software, podemos entrar en la página oficial de Arduino. En la pestaña de descargas, podemos bajar el Arduino IDE.
En algunos casos la placa va acompañada con un CD que contiene el software y los controladores de la tarjeta.

http://arduino.cc/en/Main/Software

En cualquier caso, en el siguiente enlace se explican muy claritos los pasos a seguir para una correcta instalación.
Así que sin mas preámbulos, manos a la obra.

http://arduino.cc/es/Guide/Windows

LA PLACA Y SUS PARTES MAS IMPORTANTES:

Este será más o menos el aspecto d nuestra placa Arduino Uno. Digo que más o menos por que existen varias versiones y puede cambiar de unas a otras.
Las partes que considero más importantes son las siguientes:
Conector USB: Será la comunicación física entre la placa y el ordenador.
Pulsador reset: Volverá al inicio un programa que estemos ejecutando.
Conector alimentación exterior: Es un conector hembra de 2.1mm con el centro al positivo. En algunos kits ya viene preparado un adaptador para pila de 9v, con conector macho.
Led pin 13: Como veremos es un led que dará mucho juego en nuestros proyectos iniciales. Es un led al cual no es necesario conectarle la resistencia en serie, por lo que facilita mucho la prueba de los proyectos.
Pines de entrada/salida: Una de las cosas que nos llamara poderosamente la atención es que estos pines los podemos utilizar como entradas o como salidas. Todo dependerá de como los programemos.
Led de encendido: Esta encendido cuando la placa tiene alimentación.
Microprocesador: El verdadero cerebro de la placa.
Entradas analógicas: Esta serán la entradas que utilizaremos para todas aquellas entradas que no sean digitales, es decir que pueden tener infinitos valores.
Pines de tierra y tensión: Salidas de tensión a 3.3 y 5 voltios y pines de tierra.

Mas información sobre las características de la placa

COMPONENTES ELECTRÓNICOS: 
Antes de comenzar en necesario recordar que necesitaremos unos componentes electrónicos básicos para realizar nuestros primeros proyectos. A medida que avancemos estos componentes serán mas sofisticados.
Para empezar necesitaríamos al menos los siguientes:
PLACA  PROTOBOARD: Es una placa formada por un bloque de plástico perforado en cuyo interior se alojan una serie de láminas de cobre. Esto nos permitirá realizar nuestros montajes de una forma rápida y sin necesidad de utilizar soldadura. 
En cuanto al resto de materiales estos podrían resumirse en lo que se ven en la protoboard. Diodos leds, resistencia de varios valores, pulsadores, algún potenciometro y cablecillos para realizar las conexiones entre la protoboard y la placa .

EMPEZAMOS: 
Suponemos ya instalados los controladores de la tarjeta de Arduino y hemos bajado el programa. La primera impresión que da el aspecto gráfico del IDE de Arduino es bastante desalentadora. No resulta un entorno agradable para programar.

El lenguaje que utiliza Arduino para su programación es C/C++ , considerado como lenguaje de alto nivel. Para los que no tenemos experiencia en este tipo de lenguaje, hay que decir que es bastante rollo, sobre todo en los inicios, ya que si te equivocas en una simple coma, te dará error al cargarlo y podrás desesperarte hasta que encuentres el fallo. Cuando adquieras un poco de práctica, la cosa resulta mas sencilla.
Generalmente está compuesto por los siguientes componentes:
- Estructuras.
- Variables.
- Operadores matemáticos, lógico y booleanos.
- Estructuras de control, condiciones y ciclos.
- Funciones.
Un programa completo se llama "Sketch"

ESTRUCTURAS: Definen las funciones fundamentales que debe contener cualquier programa con Arduino. Estas son:
setup(){
}
Es el código de configuración inicial. Todo lo que incluya estará recogido entre las llaves. Solo se ejecuta una vez.
loop(){
}
Esta función se ejecuta después de setup y se mantiene ejecutándose indefinidamente.

Una vez conocida la estructura básica de un programa con Arduino vamos a realizar el primer ejemplo, ya que si nos perdemos en definir variable, operadores, funciones, etc, me temo que nos podemos aburrir.

PRIMER PROYECTO: 
Comenzaremos  con algo sencillo explicando paso a paso el porqué de cada cosa.
El primer proyecto que se hace siempre con arduino es el "blik"  (parpadeo). También es conocido como el "Hola mundo". 
Básicamente consiste en un diodo led que se enciende y se apaga.
 El código del programa sería el siguiente: 

BLINK

/*Blink. Consiste en un un led que se enciende y se apaga. Lo conectaremos en el pin 13, ya que en este pin no es necesario conectar la resistencia en serie con el  led. El encendido y apagado lo realizaremos con el comanda delay*/

Esto que acabo de escribir, se puede escribir también en la misma panatalla donde estamos tecleando el código del programa. La regla es comenzar el párrafo  con   /*   y terminarlo con */ 
Si no necesitamos escribir un párrafo muy largo también podemos utilizar al comienzo de la línea //   Pero en este caso solo sirve para una línea, cada vez que empecemos otra nueva siempre comenzaremos con  //
Empezamos:

int ledPin=13;        // Indicamos que utilizaremos el pin 13 como variable y lo identificaremos
                             // como ledPin, pero podríamos llamarle como quisiéramos.
                             // Importante la sintaxis. int separado del nombre que queremos darle
                             // y terminamos con ;
                             //  int, es una variable. Al colocarla en este punto el programa podrá
                             // utilizarla en cualquier momento. Se conoce como variable global.

void setup ()         // Inicio del programa. Terminado en paréntesis abierto y cerrado.
                             // Abrimos llaves. Todo lo que escribamos a continuación estará
                             // incluido dentro de la llaves.
{
pinMode ( ledPin, OUTPUT);  // Declaramos el pin 13, que lo hemos identificado como ledPin
                                               // como salida. OUTPUT con mayúsculas y
                                              // entre paréntesis y terminado en ;
}

void loop()           // Indicamos que aquí comienza el bucle para que el programa se repita
                            // indefinidamente. Abrimos llaves.
{
digitalWrite (ledPin, HIGH);  // Literalmente lo que estamos diciendo es: "escribe un 1 en el 
                                            // ledPin" Es decir, enciende el led que hemos identificado 
                                            // como ledPin.
delay (1000);                      // Mediante delay lo que hacemos es una parada en el programa,
                                           //ojo, no es un temporizador es provocar una parada en el loop.
                                           //En este caso la parada sera de un segundo ya que hemos 
                                           // programado 1000 milisegundos.
digitalWrite (ledPin, LOW); // En esta ocasión el mensaje es "Escribe un 0 en el ledPin"
                                           // es decir, apaga el led.
delay (1000);                      // Provocamos otra parada en el loop
}                                          // Importante, terminar el programa cerrando las llaves


Este sería el código del "Hola mundo". Es muy importante, no para el funcionamiento del programa, si no para que controlemos lo que hemos escrito, hacer todas,las aclaraciones que consideremos oportunas sobre las diferentes instrucciones. Siempre después de // o abriendo el comentario con  /*  y cerrándolo con */
Una vez tecleado el código lo validamos, lo guardamos y lo transferimos a la placa Arduino, que previamente hemos conectado al ordenador a través del cable USB
Si todo va bien tendrá que funcionar, de lo contrario nos dará un mensaje de error en la validación.
 En esta captura se identifica la utilización de los  diferentes comando del IDE.

En la siguientes imágenes se aprecia en la de la derecha, el mensaje de error que aparece en la barra inferior al validar el programa.                   Si observamos detenidamente veremos que el error consiste en que falta la llave final de cierre.
Una vez subsanado el problemas, validamos y el resultado es la imagen de la izquierda.






















Por último solo nos queda "pinchar" el led en la placa, entre el pin de tierra (gnd) y el pin 13.
En los diodos leds, el negativo (cátodo) es la patilla mas corta. También se distingue por que la capsula del diodo tiene una pequeña parte plana que coincide con el cátodo







SEGUNDO PROYECTO:

Antes de comenzar con el segundo proyecto vamos hablar de "Fritzing".  Fritzing es un programa de código abierto, software libre, con el que podremos diseñar de una forma fácil y comida, nuestros circuitos. Es muy simple de utilizar y ademas viene en español, con lo  que siguiendo los tutoriales y la ayuda es muy sencillo empezar a controlarlo.

Enlace donde podréis descargarlo: 

http://fritzing.org/download/

También podéis visitar esta página donde se ofrece un vídeotutorial muy claro y dídáctico

http://www.bairesrobotics.com/2013/10/completo-tutorial-de-fritzing-en-espanol-by-opiron/

El aspecto del entorno gráfico de Fritzing es este




Bien, una vez conocido el Fritzing, vallamos por el segundo proyecto.
Se trata de una ampliación del "Hola mundo", pero en esta ocasión utilizaremos dos diodos y otras salida.
Vamos a utilizar un diodo rojo y otro verde conectados a los pines 10 y 11. 

Es conveniente recordar  que los diodos soportan una tensión de entre 1.7 a 2 voltios y una intensidad máxima de entre 10mA y 30mA. En el primer caso tendrá una iluminación muy brillante pero una vida útil corta, mientras que si la intensidad que lo atraviesa es de 30mA su vida será notablemente más larga pero con  menos brillo. 
En nuestro caso tomaremos valores de 1.7 para la tensión y de 20mA (0.02A) para la intensidad.
La limitación de la corriente y la tensión en el diodo se consigue mediante la conexión en serie de una resistencia de con un  valor determinado.
Sabemos, por otra parte que la  tensión de salida entre tierra y cualquiera de los pines que vamos a utilizar es de 5V, por lo tanto es necesario realizar el cálculo de la resistencia necesaria. El cálculo es muy sencillo, basta con aplicar la ley de  Ohm. La formula que utilizaremos será la siguiente:


Rd = V0 - Vd / Id  ;  5 -1.7 /0.02 = 165 Ohmios. 

Donde:  
Rd = Resistencia diodo
V0 = Tensión alimentación.
Vd = Tensión diodo
Id = Intensidad diodo 

Como no existe el valor comercial de esta resistencia tendríamos que elegir una de un valor superior, por ejemplo de 180 o 220 Ohmios.

FUNCIONAMIENTO DEL PROYECTO:
 Se trata de dos diodos, uno rojo y otro verde, conectados a los pines 10 y 11 de arduino, de forma que uno de ellos se encienda durante un segundo y el otro permanezca apagado, transcurrido este tiempo el que estaba apagado se enciende y el que estaba encendido se apaga durante el mismo tiempo.  Esta secuencia se repite indefinidamente.

CÓDIGO DEL IDE:

/* ESTE PROYECTO ES UNA VARIABLE DEL "HOLA MUNDO" PERO EN ESTE CASO CON DOS DIODOS.UTILIZAREMOS UN DIODO VERDE Y OTRO ROJO. TAMBIÉN UTILIZAREMOS LOS PINES 10 Y 11. AL UTILIZAR LOS PINES 10 Y 11 TENDREMOS QUE CONECTAR UNA RESISTENCIA DE 220 OHMIOS EN SERIE CON CADA DIODO. EL FUNCIONAMIENTO ES MUY SIMPLE. CUANDO ESTE ENCENDIDO EL LED VERDE, PERMANECERÁ APAGADO
EL LED ROJO. TRANSCURRIDO UN SEGUNDO SE ENCENDERÁ EL ROJO Y SE APAGARA EL VERDE. ESTA SECUENCIA SE REPETIRÁ INDEFINIDAMENTE*/

int ledVerde=10; //Indicamos que utilizaremos el pin 10 con el ledVerde.
int ledRojo=11; // Indicamos que utilizaremos el pin 11 con el ledRojo.
// Siempre que coloquemos una variable antes del void setup, el programa podrá 
//utilizarla en cualquier momento. Las variables colocadas en este punto 
//se llaman variables globales
              
void setup()
{

  pinMode(ledVerde, OUTPUT); //Se declara que ledVerde sera una salida.
  pinMode(ledRojo, OUTPUT); // Se declara que ledRojo sera una salida.
}
void loop()
{

 digitalWrite(ledVerde,HIGH); //Escribe sobre el pin 10 un "1", es decir enciende ledVerde
 digitalWrite(ledRojo,LOW); //Escribe sobre el pin 11 un "0", es decir apaga ledRojo
 delay(1000); //Lo mantiene activado durante un segundo
 digitalWrite(ledRojo,HIGH); //Escribe un "1" sobre el pin 11, es decir enciende ledRojo
 digitalWrite(ledVerde,LOW); //Escribe sobre el pin 10 un "0", es decir apaga ledVerde
 delay(1000); //Lo mantiene desactivado durante un segundo
}

 Si esto lo tecleas o lo copias y pegas en el IDE, tiene que funcionar.
Insisto que es muy importante poner todas las anotaciones que queramos a lo largo del programa, de esta forma siempre sabremos lo que el programa esta haciendo en cada momento.





Este será el esquema del montaje con Fritzing




Y este el montaje real




Y de momento nada más. Hasta el próximo proyecto.

Otra cosa. Si alguien ve estos contenidos, por favor, escribid algo en los comentarios, mas que nada para saber si merece la pena seguir con esto o no.  Gracias.


TERCER PROYECTO:Este tercer proyecto es una variante del anterior. En este caso vamos a utilizar tres diodos y vamos hacer que se vallan encendiendo uno tras otro pero de forma que nunca permanezca encendido mas de uno. También vamos a modificar  el tiempo de encendido.
Para el montaje utilizaremos  una sola resistencia, ya que como nunca va a estar encendido mas de un diodo podemos utilizar una resistencia común de 220 Ohmios conectada en el pin de tierra.

CÓDIGO DEL IDE:

/* SE TRATA DEL ENCENDIDO PROGRESIVO DE TRES DIODOS, DE FORMA QUE NUNCA ESTE ENCENDIDO MAS DE UN LED. PRIMERO SE ENCENDERÁ EL ROJO, SE APAGARÁ ESTE Y SE ENCENDERÁ EL AMARILLO, SE APAGARÁ ESTE Y SE ENCENDERÁ EL VERDE. SE APAGARÁ EL VERDE Y EL CICLO VOLVERÁ A REPETIRSE INDEFINIDAMENTE.
SE HA PROGRAMADO UN TIEMPO DIFERENTE PARA CADA DIODO*/

int ledrojo=10; //indicamos que el led rojo lo conectaremos en el pin 10 
int ledamarillo=11; //indicamos que el led amarillo lo conectaremos en el pin 11 
int ledverde=12; //indicamos que el led verde lo conectaremos en el pin 12 

void setup()
{ pinMode(ledrojo, OUTPUT); //Se declara el pin 10 como salida
  pinMode(ledamarillo, OUTPUT); //Se declara el pin 11 como salida
  pinMode(ledverde, OUTPUT); //Se declara el pin 12 como salida
}
void loop()
{

 digitalWrite(ledrojo,HIGH); //Activa el pin 10
 digitalWrite(ledamarillo, LOW);// Desactiva el pin 11
 digitalWrite(ledverde, LOW);// Desactiva el pin 12
 delay(2000); //Espera en esta situación durante dos segundos

 digitalWrite(ledrojo, LOW);//Desactiva el pin 10
 digitalWrite(ledamarillo,HIGH); //Activa el pin 11
 digitalWrite(ledverde, LOW);// Desactiva el pin 12
 delay(3000); //Espera en esta situación durante tres segundos

 digitalWrite(ledrojo, LOW);//Desactiva el pin 10
 digitalWrite(ledamarillo,LOW); //Desactiva el pin 11
 digitalWrite(ledverde, HIGH);//Activa el pin 12
 delay(4000); //Espera en esta situación durante cuatro segundos. Luego repite el ciclo
}

Si os dais cuenta este programa se parece mucho al funcionamiento de un semáforo, lo cual nos da una idea del potencial de esta "plaquita" . Pero bueno eso lo dejaremos para el próximo proyecto.





Esquema del montaje. Se observa la conexión de la resistencia común.



MONTAJE REAL
RETO: OS PROPONGO OTRA VARIANTE DE ESTE PROYECTO. PODRÍA SER QUE LOS DIODOS SE ENCENDIERAN PROGRESIVAMENTE Y SE QUEDARAN ENCENDIDOS, HASTA COMPLETAR LOS TRES. EN ESTE PUNTO PERMANECERÍAN ENCENDIDOS  UN TIEMPO, SE APAGARÍAN Y VOLVERÍA A COMENZAR LA SECUENCIA.
Posibles soluciones :    sjulian333.blogpost@gmail.com


CUARTO  PROYECTO:
 Lo prometido es deuda. En este nuevo proyecto, os propongo el control de un semáforo para el cruce de una calle. Por lo tanto tendrá una parte para los coches, con tres diodos, rojo, verde y amarillo, y otra para peatones, con verde y rojo.

Lo primero que tenemos que hacer es establecer una secuencia lógica de tiempos, es decir determinar cuanto tiempo va a estar encendido cada diodo de forma que coincida el paso de los peatones con la parada de los coches y al revés.
Dicha secuencia podría ser la siguiente:


Como decía se trata de establecer una secuencia más o menos lógica. El siguiente paso será pasar los tiempos que se especifican, (reducidos para que no resulte pesado), al programa de arduino.

CÓDIGO DEL IDE:

/* SE TRATA DEL DEL  CONTROL DE UN SEMÁFORO QUE REGULE EL TRÁFICO DE UNA CALLE.PARA LO CUAL CONTAREMOS CON TRES LEDS, ROJO, AMARILLO Y VERDE QUE SIMULARAN LA PARTE DEL SEMÁFORO DE COCHES, Y DOS DIODOS, VERDE Y ROJO, QUE SERÁN LA PARTE DE LOS PEATONES. MEDIANTE LA UTILIZACIÓN DE DELAY PROVOCAREMOS LOS RETARDOS NECESARIOS EN EL PROGRAMA PARA REALIZAR LA SECUENCIA QUE NECESITEMOS*/

int verdecoches=10; //indicamos que el led verde coches lo conectaremos en el pin 10 
int amarillocoches=11; //indicamos que el led amarillo coches lo conectaremos en el pin 11 
int rojocoches=12; //indicamos que el led rojo coches lo conectaremos en el pin 12
int rojopeatones=9; // indicamos que el led rojo peatones lo conectaremos en el pin 9
int verdepeatones=8; // indicamos que el led verde peatones lo conectaremos en el pin 8

void setup()
{ pinMode(verdecoches, OUTPUT); //Se declara el pin 10 como salida
  pinMode(amarillocoches, OUTPUT); //Se declara el pin 11 como salida
  pinMode(rojocoches, OUTPUT); //Se declara el pin 12 como salida
  pinMode(rojopeatones, OUTPUT); //Se declara el pin 9 como salida
  pinMode(verdepeatones, OUTPUT); //Se declara el pin 8 como salida
}
void loop()
{

 digitalWrite(verdecoches,HIGH); //Activa el pin 10
 digitalWrite(rojopeatones, HIGH);// Activa el pin 9
 delay(5000);//Espera en esta situación durante 5 segundos
 digitalWrite(amarillocoches, HIGH);// Activa el pin 8
 delay(2000); //Espera en esta situación durante dos segundos
 digitalWrite(verdecoches,LOW); //Desactiva el pin 10
 digitalWrite(amarillocoches, LOW);// Desactiva el pin 8
 digitalWrite(rojocoches,HIGH); //Activa el pin 12
 delay(2000); //Espera en esta situación durante dos segundos
 digitalWrite(rojopeatones, LOW);// Desactiva el pin 9
 digitalWrite(verdepeatones,HIGH); //Activa el pin 8
 delay(4000); //Espera en esta situación durante 4 segundos
 digitalWrite(verdepeatones,LOW); //desactiva el pin 8
 digitalWrite(rojopeatones, HIGH);// activa el pin 9 
 delay(2000); //Espera en esta situación durante dos segundos
 digitalWrite(rojocoches,LOW); //Activa el pin 12


 }

El esquema en Fritzing.





PROGRAMA MINIBLOQ:
Antes de continuar con otros comandos quiero presentaros un programa que hace que la programación en arduino sea mucho mas amena y sencilla. Se trata de MINIBLOQ . Este programa puede definirse como un entorno gráfico de programación para arduino. 
La forma de programar es muy sencilla. Consiste en una pantalla donde podemos ir cogiendo los bloques que necesitamos y configurarlos con los valores que queramos.

Este es el enlace desde donde puede descargarse el programa

http://blog.minibloq.org/p/download.html
Ademas existen en la rede un montón de tutoriales y foros donde se habla de Minibloq y se intercambias experiencias.
Algunos enlaces sobre tutoriales.

http://blog.minibloq.org/2012/05/nuevo-manual-en-pdf-y-odt-en-espanol.html
http://blog.minibloq.org/2012/01/guia-en-espanol-de-robotica-spanish.html

http://blog.minibloq.org/2012/01/nuevo-tutorial-con-ejemplos-en-espanol.html


http://blog.minibloq.org/2012/11/pequena-guia-basica-en-espanol.html

http://www.taringa.net/posts/info/13937120/Libros-de-Arduino-en-PDF-Espanol.html

El aspecto de la pantalla sería el siguiente




GOOGLE SITES:
Como esto se va haciendo cada vez más grande, he decidido crear un sitio donde se colgaran los proyectos y todos los tutoriales, video-tutoriales y otros enlaces que considere interesantes.  




QUINTO PROYECTO: EL COCHE FANTÁSTICO. Tranquilos, que de momento no vamos a construir ningún coche  o artefacto motorizado.  Se trata simplemente de realizar una secuencia con siete led para conseguir un efecto parecido al mítico coche fantástico de la serie del mismo nombre.
Este proyecto lo realizaremos en  tres versiones diferentes, la primera que resulta un poco sosa la segunda que sin realizar muchos cambios mejora el efecto notablemente y por último una tercera con un programa mas corto utilizando nuevos comando.

                                                                    ENLACE



COLABORACIÓN

ARRANCADOR ESTRELLA-TRIANGULO. 

José Cerrato , nos presenta esta colaboración.  Se trata de un arrancador estrella- triangulo, con un solo pulsador. Esta probado y funciona correctamente.
Este es el código.
//------------------------------------
//ARRANQUE ESTRELLA TRIÁNGULO
int pulsador=6; //PULSADOR DE MARCHA Y PARADA
int led=12;  // RELÉ PARA CONTACTOR DE LINEA
int led1=11;  // RELÉ PARA CONTACTOR DE ESTRELLA
int led2=10;   // RELÉ PARA CONTACTOR DE TRIÁNGULO
int cnt_etapa=0; //contador de etapas y estado//
void setup(){
  pinMode(pulsador,INPUT);
  pinMode(led,OUTPUT);
  pinMode(led1,OUTPUT);
  pinMode(led2,OUTPUT);
  Serial.begin(9600);
}
void loop(){
  if(digitalRead(pulsador)==HIGH&&cnt_etapa==0)
  {
    digitalWrite(led,HIGH); // ENTRA RELÉ DE LÍNEA
    {digitalWrite(led1,HIGH);  // ENTRA RELÉ DE ESTRELLA
    delay(1000); // TIEMPO DE CAMBIO
    digitalWrite(led1,LOW);  // DESCONEXIÓN DE ESTRELLA
    delay(100);  // TIEMPO DE SEGURIDAD
     
    digitalWrite(led2,HIGH);  // ENTRA EL RELÉ DE TRIÁNGULO
    }

    cnt_etapa=1;
    }
    
if(digitalRead(pulsador)==LOW&&cnt_etapa==1){
  cnt_etapa=2;                                 // PARADA TOTAL
}
if(digitalRead(pulsador)==HIGH && cnt_etapa==2){ 
  digitalWrite(led,LOW);
  digitalWrite(led1,LOW);
  digitalWrite(led2,LOW);
  cnt_etapa=3;
}
if(digitalRead(pulsador)==LOW && cnt_etapa==3){
  cnt_etapa=0;
}
Serial.println(cnt_etapa); //puedes ver dónde está el programa viendo en qué etapa está
}


2 comentarios:

  1. Santiago, si me hago de un arduino seguro que lo hago. Muy buen trabajo, sigue así!

    ResponderEliminar
  2. Muy buena informacion Saludos desde chile

    ResponderEliminar