mircaed

Hace mucho tiempo que escribí la última entrada en la sección de Impresión 3D, las mejoras y modificaciones han sido muchas. Aunque era mi intención documentar mis avances veo que no tomé suficientes fotografías, de todas maneras comparto mis experiencias. He de aclarar que mi impresora es una HE3D modelo Ei3, en mi opinión es exactamente igual a la Tevo Tarantula (en un foro de Tevo Tarantula me crucificaron por haber hecho esta comparación) así que solo diré que los componentes mecánicos y electrónicos son iguales y compatibles. Esta es mi impresora recién armada, sin ninguna modificación Una vez ensamblada y después de mucho uso tuve una idea mas clara de su funcionamiento, hubo modificaciones básicas para mejorar el desempeño (puedes ver las entradas anteriores en esta sección haciendo clic aquí) y sucedió lo que tenía que suceder, llegué al punto en que quería hacer una modificación mayor. La cama original de mi impresora era de 220 X 220 mm (200 X 200 área de impresión) la misma impresora se ofrece con "cama grande" de 220 X 280 mm, debí haber comprado la impresora con cama grande desde un principio pero como todos sabemos APRENDER CUESTA y he aprendido mucho (pero me ha costado mucho) El mismo fabricante de mi impresora ahora ofrece un nuevo modelo, que entre muchas otras mejoras ofrece una cama de 400X 400 mm Además de ser de 400 X 400 mm es de doble zona, puedes calentar solo 200 X 200 mm o calentar el total de la cama. Contacté al fabricante y accedió a venderme la cama suelta (por el momento solo vendían la impresora completa, casi 1000 USD verla aquí), pagué la cama, después me solicitaron más dinero para el envío argumentando que el paquete era muy grande y finalmente me dijeron que "ya no tenían camas sueltas" y me hicieron un reembolso por el total, en resumen: decidieron no vender la cama suelta. En este punto yo ya contaba con que recibiría la cama de 400 X 400 y había adelantado el proyecto, la cama venía desde china y tomaría de 15 a 20 días (envío express) El primer paso fue calcular las medidas de los nuevos perfiles de aluminio, mi idea era hacer una estructura cúbica que diera estabilidad a la impresora y que recibiera sin problemas la cama de 400 X 400 mm que "ya venía en camino". Utilizando ángulos de aluminio de 20X20X28 armé la nueva estructura Con la ayuda de una escuadra me aseguré de que los perfiles quedaran a 90ª Detalle de las esquinas Estructura terminada El fabricante de la impresora ofrecía el "upgrade" a doble eje Z, en mi caso el doble eje Z resulta indispensable por la nueva dimensión del eje X, hasta este punto solo se cambió en su totalidad la estructura de aluminio, el resto de los componentes serán los mismos. Detalle del carro de la cama (ejeY) se ve ridículamente pequeño en la nueva estructura Incorporando la fuente de poder con su toma corriente y un voltímetro a uno de los costados Por el momento la tarjeta lógica quedará montada en el mismo lugar que tenía en la impresora original Impresora armada y funcionando Prueba de impresión, 250 mm altura (eje y) utilizando las varillas roscadas originales de la impresora (370 mm de largo) ya tengo dos varillas nuevas de 600 mm de largo, 230 mm mas de altura en eje y, área de impresión total 400 X 400 X 480 mm, Para instalar las nuevas varillas tendré que cambiar también 6 piezas de la estructura, otro error muy caro, debí comprar las varillas de 600 mm antes de calcular la nueva estructura (esta nueva modificación quedará pendiente a que tenga dinero y tiempo para hacerla). En este punto fue cuando me enteré que mi nueva cama de 400 X 400 mm nunca llegaría así que fue momento de pensar una solución: Fabricar mi propia cama. He de aclarar que vivo en una ciudad pequeña, no es fácil conseguir exactamente lo que uno quiere. Mi primera idea fue instalar dos camas de 220 X 280 mm de la siguiente manera:Las anotaciones las hice en inglés porque este dibujo lo compartí en un foro de Facebook De esta manera obtendría área de impresión de 280 X 420 mm, precio de cada cama 35 USD (ver aquí) y no era la medida que yo quería (400 X 400 mm) además de que habría que resolver varios problemas, por ejemplo: Poder calentar una sola cama o las dos, según el tamaño de la pieza a imprimir Modificar el firmware para dos tamaños de cama distintos (para que la pieza se imprimiera al centro de una o al centro de las dos). Modificar la posición del termistor para una correcta detección de la temperatura al usar una sola o las dos camas juntas. Después pensé en fabricar una cama, igual a la original pero con las nuevas dimensiones. El primer problema fue que no conseguí placa de aluminio de 3mm así que la hice de acero inoxidable (en un calibre menor, 1 mm) esto me dio una ventaja, doblé cejas de 5 mm en las aristas para contener el vidrio en su lugar, ya no será necesario detenerlo con algún objeto que pueda golpear con el ventilador de capa o con la boquilla de impresión Aquí estoy presentando la futura cama de 400 X 400 mm, lo que se ve azul es el plástico protector del acero inoxidable Ahora es momento de modificar el carro de la cama (eje Y), el diseño original sostiene la cama en un solo riel y las ruedas están posicionadas lateralmente en el mismo, esta idea funciona para la cama original pero mi nueva cama es muy grande y muy pesada para conservar ese diseño así que mi nuevo carro será como una patineta deslizándose suavemente sobre 5 ruedas y 3 rieles. Nuevo carro 400X 400 mm con 5 ruedas Los porta ruedas son impresos en 3D, (máquinas haciendo máquinas) Tomé la precaución de que el nuevo carro tuviera las perforaciones necesarias para recibir la cama original (220 X 220 mm y la nueva cama 400 X 400 mm) Momento de mover la tarjeta lógica, en el lugar que se encuentra estorba para poder imprimir en la totalidad de la cama, además de que se agregarán mas componentes electrónicos Agregué dos mosfets, uno para la cama caliente y el otro para el extrusor (todo trabajo pesado que se le ahorre a la tarjeta lógica alargará su vida), dejé lugar para un mosfet mas (en un futuro quiero agregar extrusor doble) y agregué un relevador de estado sólido ya que el calentador de la nueva cama 400 X 400 mm es de 110 volts Después diseñé e imprimí un sensor de filamento, pausa la impresión en caso de que el filamento se termine Sensor de filamento ya instalado No termino un proyecto cuando ya tengo ideas para el siguiente, ¿Que voy a hacer con la estructura original de mi impresora 3D? se me antoja un grabador laser pero ya compré (y en teoría ya viene en camino) una cortadora laser de 50 Watts así que la vieja estructura se convertirá en un router CNC. Habrá que mejorar el proyecto del Profe García: link: https://www.youtube.com/watch?v=X4BLydtpllo&list=PLnwu2s7SIakR-0Gs5vAO_1sfWDOy9mBE0

¿No sabes lo que es Arduino? ¿Qué hace y a quién le puede interesar Arduino? Hay distintas placas Arduino, ¿Cuál comprar? ¿Conviene comprar un paquete de inicio? ¿Qué es Arduino? Arduino es una placa electrónica con un microcontrolador programable, consta de entradas y salidas digitales y también tiene entradas análogas. Originalmente fabricado por una compañía Italiana (original Arduino), Actualmente hay placas Arduino compatibles, no por ser compatibles son “piratas” ya que tanto el diseño de la placa como su programador son de código abierto, esto es, su diseño no es un secreto, no están patentados y son libres de descarga desde el sitio de Arduino. ¿Qué hace y a quién le puede interesar Arduino? La placa base Arduino no hace NADA, absolutamente NADA, es necesario conectarle “accesorios” de entrada y salida y programar su microcontrolador para que ejecute instrucciones interactuando con los “accesorios” conectados. Los proyectos que puedes construir con Arduino son muchísimos, desde lo más sencillo hasta lo más complicado, esto ya depende de ti. Arduino es una de las mejores herramientas de aprendizaje para todas las edades (recomendado para mayores de 13 años) para estudiantes de electrónica e ingeniería y para estudiantes de sistemas y programación. ¿Ya no estás en edad de ser estudiante e ir a clases pero te llama la atención aprender electrónica y programación? Arduino es tu mejor opción! Hay distintas placas Arduino, ¿cuál comprar? Actualmente hay más de 11 placas Arduino distintas, algunas son simples miniaturas de la misma placa (ejemplo: hay Arduino Pro y Arduino Pro Mini) Las dos placas tienen la mismas características, solo una es mucho más pequeña que la otra, en este caso la selección de cuál comprar se basará en el tamaño, según lo requiera tu proyecto en específico. Existen muchísimos tutoriales en Youtube, unos muy buenos, unos muy aburridos, unos bien explicados, otros no tanto, hay de todo, lo que tienen en común es la placa Arduino en la que se basan, la mayoría utiliza la placa Arduino UNO (es la más económica), y las más comunes son UNO, LEONARDO y MEGA. Personalmente me decidí por la Arduino Mega, aunque no es la más económica,  en mi opinión es la que mejor costo-beneficio ofrece, además de que me parece la ideal para un principiante que muy pronto estará haciendo proyectos muy grandes. Observa la siguiente comparación: Placa:                          Pines Digitales / PWM                  Pines Analógicos UNO                                     14 / 6                                           6 LEONARDO                           20 / 7                                           12 MEGA                                  54 / 15                                          16 ¿Conviene comprar un paquete de inicio? Cuando yo me inicié en el mundo Arduino adquirí dos kits (paquetes), uno lo compré en Mercado Libre, el segundo lo compré en eBay. Después de mucho estudiar, ver tutoriales, visitar foros y varias horas de investigación he revisado los paquetes que se ofrecen y llegué a las siguientes conclusiones: 1)      la mayoría de los vendedores son solo eso, VENDEDORES, no saben usar lo que venden y solo te revenden el paquete tal como lo reciben del proveedor, no te ofrecen un manual específico para el paquete que compraste. 2)      Todos te ofrecen “Libros”… muchos libros (hay quienes mencionan CIENTOS de libros o manuales ), la verdad es que si recibes 100 libros o manuales no vas a saber ni por dónde empezar, además la mayoría de los manuales están en INGLES (escritos por CHINOS), todos los manuales tienen experimentos muy similares (o iguales) 3)      El manual o libro de proyectos o experimentos no concuerda con la placa Arduino que te vendieron, esto es, compraste una placa Arduino Mega y las explicaciones son para una Arduino UNO, aunque ambas placas son MUY PARECIDAS…. MUY PARECIDAS = NO IGUALES 4)      Los componentes que te envían con el paquete no corresponden en su totalidad con los proyectos o experimentos a realizar, te mandan muchas piezas que no vas a usar y que al final del curso ni sabes que son. También es común que los cursos requieran piezas que tu kit de inicio no incluye. Entre los foros que visité uno de los usuarios experimentados comentó: “No compres paquetes de sensores y piezas que nunca vas a usar, ve comprando lo que necesitas para cada proyecto”. En mi opinión este comentario aplica para las personas que viven en una ciudad grande, donde hay decenas de tiendas especializadas en estos componentes, yo vivo en Puerto Vallarta, aquí hay tienda Steren (tienen placas compatibles Arduino y protoboards… nada de sensores, ni módulos y lo poco que tienen es muy caro) y una electrónica grande donde encontré lo mismo que vende Steren y unos cuantos sensores más. En mi caso las compras de este tipo las realizo en línea y por los costos de envío me es más conveniente comprar un paquete o kit que estar ordenando pieza por pieza. Mi idea es crear posts de proyectos Arduino, que van de lo básico hasta lo complejo, todos los proyectos explicados paso a paso, todos incluyen ilustración de conexiones, las ilustraciones corresponden a la placa Arduino  Mega.  Al final de cada proyecto hay un reto para reforzar el aprendizaje, la dificultad de cada reto corresponde al nivel de conocimientos adquiridos en el mismo proyecto y también puede incluir conocimientos de proyectos anteriores (los proyectos se deben realizar en orden). No se necesitan conocimientos previos de electrónica ni de programación. Arduino es un excelente regalo para [email protected] de secundaria o preparatoria, no les compres juguetes electrónicos.. ¡Que ellos los hagan! Adquieren conocimientos de electrónica y programación y son la base indispensable para aprender robótica. No se necesitan conocimientos previos de electrónica ni de programación, solo necesitas una computadora (PC o Mac) con un puerto USB disponible y conocimientos básicos de uso de computadora (instalar programa, abrir, guardar y cerrar archivos). Para comenzar: Descarga e instala el programa y controlador de Arduino en la computadora donde realizarás tus prácticas https://www.arduino.cc/en/Main/Software (versiones para PC, Mac y Linux), una vez instalada la aplicación Arduino conecta tu placa Arduino mediante el cable USB a tu PC, entra al panel de control, administrador de dispositivos y toma nota del puerto COM asignado a tu placa Arduino, en mi caso se asignó el puerto COM3 Localiza el ícono del programa Arduino en tu escritorio, da doble clic en él, selecciona el modelo de tu placa Arduino haciendo clic en: Herramientas / Placa / Arduino / Genuino Mega or Mega2560 ahora selecciona el puerto de comunicación clic en: Herramientas / Puerto y selecciona el puerto COM de tu Arduino (en mi caso COM3) La placa Arduino ha quedado instalada y configurada en tu PC IDE (Integrated Development Environment) Entorno de Desarrollo Integrado El IDE de Arduino es la aplicación que utilizaremos para escribir y subir el código a nuestra placa Arduino. La estructura básica de la programación Arduino es muy simple y necesita al menos de dos partes para funcionar (indispensables, aunque no tengan instrucciones dentro), estas dos partes o funciones contienen bloques de instrucciones. La primera parte es la preparación voidsetup() esta parte del programa solo se ejecuta una vez la segunda parte es la ejecución voidloop() esta parte contiene el código a ejecutar y lo hace continuamente, al terminar con el programa lo inicia de nuevo, indefinidamente hasta que el usuario desconecte el Arduino ( o se agote la fuente de poder), void loop () es la parte del programaque realiza todo el trabajo. El lenguaje de programación Arduino tiene sus reglas de sintaxis (el equivalente a las reglas de ortografía, igualque todos los lenguajes de programación), el código debe ser escrito siguiendo estas reglas para que al momento de compilar funcione correctamente, entre estas reglas es importante tener presente la utilización de minúsculas y mayúsculas, esto es: Void Setup no es lo mismo que void setup, en programación mayúsculas y minúsculas se deben respetar. ¿Por qué el nombre de estas dos funciones inician con la palabra void? void (vacío) porque al finalizar sus instrucciones no arrojan un valor de salida. Primeros pasos La línea de texto que está enseguida a la derecha de dos barras inclinadas // es ignorada por el programa y sirve para escribir comentarios. Estos comentarios nos sirven para hacer notas o explicar qué hace cada línea o instrucción. Para comentarios más extensos (más de una línea) se utiliza /* al principio del bloque de texto y */ al final. Ten en cuenta los nombres de los siguientes símbolos: ( ) paréntesis, [ ] corchetes, { } llaves Al conjunto de funciones e instrucciones le llamaremos “ Sketch ” (programa) para no crear confusión ya que ese es el nombre que le asigna Arduino y en otros países (sin importar el idioma que hablen) lo conocen por ese nombre. Ejemplo de estructura de un sketch void setup()             // inicia función de preparación, indispensables los paréntesis al final () {                                // se abre llave, las instrucciones van dentro de estas llaves      instrucciones;   // punto y coma al final de cada instrucción }                               // se cierra llave, indispensable para que el programa funcione void loop()            // inicia función de ejecución, indispensables los paréntesis al final () {                              // se abre llave, las instrucciones van dentro de estas llaves      instrucciones;  // punto y coma al final de cada instrucción }                              // se cierra llave, indispensable para que el programa funcione La declaración de variables se realiza al inicio del sketch , antes de las funciones void setup() y void loop() (el concepto de variables se explicará más adelante) Utilizaremos ///// para indicar que inmediatamente abajo inicia el código y se utilizará nuevamente para indicar el final del mismo. No es necesario escribir ///// en la ventana de programación de la aplicación Arduino. A modo de práctica y refuerzo de conocimientos no todas las líneas del sketch serán comentadas, cuando una línea ya haya sido explicada se dejará el comentario en blanco, debes escribir los comentarios faltantes cuando veas: //_____________________________________________________ Hasta este punto esta es toda la información que necesitas para comenzar a utilizar tu placa Arduino. sigue Proyecto 1: Comunicación serial http://www.taringa.net/posts/ciencia-educacion/19687528/Tutoriales-Arduino-Proyecto-1-Comunicacion-serial.html

Proyecto 2: LED intermitente Introducción: El proyecto LED intermitente es muy simple, en esta ocasión no utilizaremos el LED interno de la placa Arduino, conectaremos un LED a uno de los pines digitales. Los Diodos LED (Light Emiting Diode) Diodo emisorde luz tienen polaridad, esto es, una patita va al polo positivo (ánodo) y la otra al polo negativo (cátodo), si es conectado al revés simplemente no funcionará (no te preocupes, el componente no se daña si lo conectas al revés) hay varias formas de identificar la polaridad, la más obvia es que la patita positiva es más larga. Identificando el valor de las resistencias: la siguiente tabla indica la codificación de colores de las resistencias para determinar su valor en ohms Rojo = 2, Rojo = 2, Marrón = 10,   2  2 * 10 = 220 ohmsHardware a utilizar: Placa Arduino Cable USB LED Resistencia 220 ohms (rojo, rojo marrón) Protoboard CablesConociendo laProtoboard: La Protoboard o placa de prototipos nos permite montar circuitos electrónicos temporales, esto es, sin la necesidad de soldar los componentes. Las grandes ventajas son que podemos reutilizar los componentes y hacer correcciones y cambios de componentes con facilidad. La siguiente imagen muestra cómo están conectados internamente los puntos del Protoboard Como se puede apreciar en la imagen hay dos barras horizontales, una roja y una azul, arriba y abajo, normalmente utilizamos estas barras para la alimentación, positivo al rojo, negativo al azul. Las barras verticales nos sirven para interconectar el resto de los componentes, basta con insertar el conector en una de las perforaciones o puntos para que el componente quede conectado a la barra vertical. Todas las conexiones que realizaremos serán explicadas gráficamente. DiagramaEsquemático Conexión del circuito Sigue las conexiones del siguiente diagrama, utilizaremos el pin 10 de la placa Arduino como salida, todas las salidas del Arduino son de 5 Voltios, el LED trabaja alrededor de los 3 voltios, la resistencia es para evitar quelos 5 voltios lleguen directamente al LED, la resistencia se conecta en serie con el LED, es indiferente si ponemos la resistencia en la pata positiva (ánodo) o en la pata negativa (cátodo) ya que al estar conectados en serie el voltaje se divide entre los componentes. En el sketch de ejemplo recuerda llenar amano los comentarios faltantes, esto refuerza el aprendizaje.Sketch de ejemplo: ///// int ledPin = 10;     //declara lavariable ledPin y le asigna valor de 10 void setup()         //_______________________________________ {                         //________________________________________ pinMode(ledPin,OUTPUT);    //define ledPin como pin de SALIDA }                         //________________________________________ void loop()        //________________________________________ {                       //_________________________________________ digitalWrite(ledPin, HIGH);     //pone en estado encendido (HIGH) a ledPin delay (1000);            // Espera 1000 milisegundos (un segundo) digitalWrite(ledPin, LOW);     //pone enestado apagado (LOW) a ledPin delay (1000);             // Espera 1000milisegundos (un segundo) } ///// Así se verá el sketch en el IDE de Arduino: Verifica y sube el programa a la placa, verás como el LED prende y apaga en intervalos de un segundo. Ahora utilizaremos una variable, si queremos cambiar el tiempo que el LED permanece prendido (HIGH) y apagado (LOW) tenemos que cambiar el valor de la instrucción delay, en el caso de nuestro pequeño y simple programa tendríamos que cambiar dos valores (delay) para encendido y (delay) para apagado, vamos a declarar una variable al principio del programa: int tiempo = 500; y reemplazaremos el valor (1000) de la instrucción delay por (tiempo).El programa nos quedará así: ///// int tiempo = 500;     //Declara variable entera tiempo y le asigna valor de 500 int ledPin = 10;     //declara la variable ledPin y le asigna valor de 10 void setup()          //___________________________________ {                         //____________________________________ pinMode(ledPin,OUTPUT);     //define ledPin como pin de SALIDA }                         //____________________________________ void loop()        //_____________________________________ {                       //_______________________________________________ digitalWrite(ledPin, HIGH);     //pone en estado encendido (HIGH) a ledPin delay (tiempo);             //Espera el valor de la variable tiempo digitalWrite(ledPin, LOW);     //pone en estado apagado (LOW) a ledPin delay (tiempo);             // Espera el valor de la variable tiempo }                  //__________________________________________________ /////Revisa y sube el sketch a la placa Arduino, ahora el tiempo de encendido y apagado cambió de 1 segundo a medio segundo (500 milisegundos), cambia el valor a tu gusto de la variable tiempo, revisa y sube de nuevo. (si el valor de tiempo es muy pequeño, debajo de 50 no podrás apreciarlo)Combina este proyecto con el Proyecto 1, a través del monitor serial pregunta al usuario que velocidad de parpadeo quiere (delay en milisegundos, 1000 milisegundos = 1 segundo) Ahora el sketch nos quedará así:///// int tiempo;    // declara variable entera como tiempo, no se asigna valor int ledPin = 10;     //etiqueta l pin 10 de la tarjeta Arduino como ledPin void setup()          //___________________________________ {                         //____________________________________ pinMode(ledPin,OUTPUT);     //define ledPin como SALIDA Serial.begin (9600); Serial.println ("velocidad? (100 a 2000) " );  // envía el texto al monitor serial while (Serial.available()==0)  // espera a que el usuario escriba algo { } Serial.println ("Gracias!" ); tiempo = Serial.parseInt();  // almacena el valor entero y lo asigna a tiempo }                          //____________________________________ void loop()        //_____________________________________ {                       //_____________________________________ digitalWrite(ledPin, HIGH);     //pone enestado encendido (HIGH) a ledPin delay (tiempo);             // Espera el valor de variable tiempo en milisegundos digitalWrite(ledPin, LOW);     //pone enestado apagado (LOW) a ledPin delay (tiempo);             // Espera elvalor de tiempo en milisegundos } ///// Reto Proyecto 2, LED intermitente: agrega un segundo LED (con su respectiva resistencia) pata negativa a GND (usa la misma que el otro LED)  y positiva al pin 11 del Arduino, haz que la intermitencia sea alternada (cuando uno enciende el otro apaga) ************************************************************************ Problemas escribiendo el código? descarga los ejemplos desde mi carpeta compartida en Dropbox: https://www.dropbox.com/sh/w5h38cdrynqdwhf/AABP7b9T3ADbO4KqiPm4pO-9a?dl=0 Sigue: Proyecto 3: Lectura de valor análogo http://www.taringa.net/posts/ciencia-educacion/19687938/Tutoriales-Arduino-Proyecto-3-Lectura-de-valor-analogo.html

Proyecto 1:Comunicación serial, “Hola mundo!” Introducción:Comencemos desde CERO, con algo muy simple, solo necesitas la placa Arduino y un cable USB para realizar el proyecto comunicación serial, “Hola Mundo!”. Este proyecto es una prueba de comunicación entre la placa Arduino y la PC.Hardware a Utilizar: Placa Arduino Cable USBConexiones del circuito: Conecta un extremo del cable USB a la placa Arduino, conecta el otro extremo a un puerto disponible en tu PCPrograma de ejemplo:Ahora escribiremos el código y compilaremos el sketch para que Arduino “imprima” (presente en la ventana del monitor serial): “HolaMundo!” cuando se le dé la instrucción y programaremos el led interno de laplaca Arduino (este se encuentra conectado al pin digital 13) para que destelle cuando reciba dicha instrucción. Inicia el IDE de Arduino y escribe el siguiente código: El texto en negritas es solo para llamar tu atención, no hay negritas en el programa Arduino ///// int val; // declara la variable val como entera, no le asigna un valor inicial int ledpin=13; // declara la variable ledpin como entera y le asigna el valor 13 void setup() //_____________________________________________________ { //______________________________________________________ Serial.begin(9600); // Inicializa la comunicación serial velocidad (baudrate) 9600 pinMode(ledpin,OUTPUT); // variable ledpin la configura como SALIDA } //______________________________________________________ void loop() //_______________________________________________________ { // se abre llave de función void loop val=Serial.read(); // Lee el contenido del monitor serial , asigna el valor a val if (val=='R') // si val es igual a “R” se ejecuta el código de la función if * { // abre llave función if, comienzan instrucciones de esta función digitalWrite(ledpin,HIGH); // enciende el LED en el pin 13 etiquetado como ledpin delay(500); // espera 500 milisegundos (medio segundo) digitalWrite(ledpin,LOW); //apaga el LED en el pin 13 etiquetado como ledpin delay(500); // espera 500 milisegundos (medio segundo) Serial.println( "Hola Mundo!" ) ; // muestra el texto en la ventana demonitor serial } // se cierra llavefunción if } // se cierra llave defunción void loop /////*NOTA IMPORTANTE: en la línea del sketch if (val=='R') , la R está entre comillas simples, Teclado en Inglés: dos teclas a la derecha de la tecla L Teclado en Español (Latinoamerica, @ en la tecla Q): tecla del signo ? Teclado en Español (España, @ en la tecla 2): tecla del signo ? Así se verá en la ventana de programación de Arduino: Seguramente lo primero que notaste son los diferentes colores que Arduino asigna al texto y como habrás notado si la sintaxis es incorrecta el comando no tomará su color respectivo. Ahora haz clic sobre una llave { o }, observa como Arduino encierra en un rectángulo la llave que es pareja (complemento) de la que seleccionaste, esto ayuda a encontrar errores. Haz clic en el icono Verificar de la aplicación, Arduino te pedirá que guardes tu sketch, dale nombre y selecciona la ruta donde deseas guardarlo, (puedes hacer una carpeta y llamarla “Prácticas Arduino” ya sea en Escritorio o en Mis Documentos) ahora Arduino revisará el sketch y te informará si existe algún error, en este punto es de esperarse que tengas más de un error de sintaxis, revisa las líneas del código que te sean resaltadas por Arduino, corrígelas y revisa de nuevo. Una vez que tu programa esté libre de errores la parte inferior debe verse como esta: Consejo: En la aplicación de Arduino da clic en Archivo / Preferencias y marca la casilla Mostrar números de línea, da clic en Ok. De esta forma el sketch tendrá las líneas numeradas, cuando tengas un error te será más fácil encontrar la línea por su número. Si no lo has hecho, conecta tu placa Arduino al PC, selecciona tu placa Arduino haciendo clic en: Herramientas / Placa / Arduino / Genuino Mega or Mega 2560 ahora selecciona el puerto de comunicación clic en: Herramientas / Puerto y selecciona el puerto COM asignado a tu Arduino. Haz clic en el icono de Subir para cargar tu sketch a la placa Arduino, espera a que los LEDs de comunicación (TX y RX) en la placa destellen indicando que se cargó el programa. En el IDE de Arduino haz clic en el icono Monitor Serie , la ventana de Monitor serial se abrirá, escribe R y haz clic en el botón Enviar, el LED en el pin 13, etiquetado como pinled destellará una vez y en la ventana del Monitor Serial aparecerá el texto: “Hola Mundo!” Explicación rápida de las Instrucciones y funciones utilizadas hasta este momento: int declara una variable como entera Serial.begin(XXXXX) Inicializa la comunicación serial y le asigna el baud rate XXXXX pinMode(X,OUTPUT) determina si X será entrada o salida (INPUT, OUTPUT) Serial.read Lee el contenido del cuadro de texto de la ventana monitor serial if (X==Y) función condicionante, compara valores, si se cumple la comparación se ejecuta digitalWrite(X,HIGH) determina encendido o apagado, alto o bajo (HIGH, LOW) delay(X) espera X milisegundos antes de continuar con la siguiente instrucción Serial.println( "XXX" ) muestra el texto o el valor en la ventana de monitor serial (ln salto de línea) Reto de proyecto1: modifica el código de manera que al enviar R Arduino conteste: “HolaMundo!” y al enviar X el LED destelle dos veces y Arduino conteste: “AdiosMundo Cruel!” Nota importante: Omito de forma intencional los acentos dentro de los sketches ya que el IDE de Arduino no los interpreta correctamente. Son faltas de ortografía intencionales. Concepto de Variables: Como su nombre lo sugiere, una variable es algo que va a variar o cambiar, para explicarlo en forma muy simple supongamos que tenemos tres cubetas vacías, su contenido puede variar dependiendo de lo que pongamos dentro de ellas, para identificar cada cubeta le pondremos una etiqueta con su nombre, esta etiqueta no solo identifica a la cubeta, también nos dice qué tipo de contenido tiene. Empezaremos con 3 tipos de variables para proseguir con nuestro proyecto: int Variable de tipo entera (almacena valores enteros) float Variable numérica con punto decimal (punto flotante) string Variable que almacena cualquier cadena de caracteres (letras y números)Realizaremos un nuevo sketch para interactuar con la comunicación serial entre la aplicación IDE y nuestra placa Arduino.///// String Nombre; // declaramos variable de tipo cadena (string) Nombre int Edad; // declaramos variable de tipo entera Edad float Altura; //declaramos variable de tipo punto flotante Altura void setup() // inicia función de configuración { // abre llave función configuración Serial.begin (9600); // iniciamos comunicación serial } // cierra llave función configuración void loop() // inicia función de ejecución (bucle) { // se abre llave función de ejecución Serial.println ( "Cual es tu nombre? " ) ; // envía el texto al monitor serial while (Serial.available()==0) // espera a que el usuario escriba algo { // se abre llave función while } // se cierra llave función while Nombre = Serial.readString(); //almacena el texto en la variable Nombre Serial.println ( "Que edad tienes? " ) ; // envía el texto al monitor serial while (Serial.available()==0) // espera a que el usuario escriba algo { //__________________________________________ } //__________________________________________ Edad = Serial.parseInt(); // almacena el valor entero en la variable Edad Serial.println ( "Cuanto mides? " ) ; // envía el texto al monitor serial while (Serial.available()==0) // espera a que el usuario escriba algo { //__________________________________________ } //__________________________________________ Altura = Serial.parseFloat(); //almacena el valor de punto flotante en la variable Altura Serial.println ( " " ) ; // envía una línea sin texto al monitor serial, salta línea (ln) Serial.print ( "Hola " ) ; //envía el texto al monitor serial Serial.print (Nombre); // envía la cadena de texto de la variable Nombre al monitor Serial.print ( ", Tu edad es " ) ; // envía texto al monitor serial Serial.println (Edad); // envía el valor entero de la variable Edad al monitor serial Serial.print ( "y tu estatura es " ) ; // envía el texto al monitor serial Serial.println (Altura); // envía elvalor de punto flotante de la variable Altura al monitor Serial.println ( " " ) ; // envía una línea sin texto al monitor serial, salta línea (ln) } // se cierra llave función ejecución (loop) ///// Revisa y si no tienes errores sube el sketch a tu placa Arduino, abre la ventana del monitor serial, responde a las preguntas escribiendo en el cuadro de texto superior de la ventana del monitor serial, da clic en Enviar para mandar la respuesta. Explicación rápida de las Instrucciones y funciones utilizadas hasta este momento:String declara una variable de tipo cadena de texto int declara una variable de tipo entera float declara una variable de tipo punto flotante while (parámetro) función while se ejecuta mientras se cumpla el parámetro { entre las llaves se escriben las instrucciones a ejecutar } la función termina cuando se deja de cumplir el parámetro Serial.readString() lee una variable de tipo String desde el monitor serial Serial.parseInt() lee una variable de tipo int desde el monitor serial Serial.parseFloat() lee una variable de tipo float desde el monitor serial ************************************************************************ Problemas escribiendo el código? descarga los ejemplos desde mi carpeta compartida en Dropbox: https://www.dropbox.com/sh/w5h38cdrynqdwhf/AABP7b9T3ADbO4KqiPm4pO-9a?dl=0 Sigue: Proyecto 2: LED Intermitente https://www.taringa.net/posts/ciencia-educacion/19687673/Tutoriales-Arduino-Proyecto-2-LED-Intermitente.html

Proyecto 8: LED controlado por botón Introducción: Puerto I/O significa puerto de ENTRADA /SALIDA (INPUT / OUTPUT). Hasta este punto hemos utilizado los pines digitalescomo salida, en este experimento utilizaremos uno de los pines digitales como entradapara leer el dispositivo conectado a él, en este caso un botón, sin oprimir(abierto, 0v, LOW) y cuando se oprime (cerrado, 5v, HIGH). Hardwarea Utilizar Placa Arduinio Cable USB Switch de botón LED Resistencia 220 ohms Resitencia 10K ohms (marrón, negro, naranja) Protoboard Cables Diagrama esquemático Conexión del circuito Sketch de ejemplo: Cuando oprimimos y soltamos el botón se encenderá el LED y permanecerá encendido, al volver a presionar y soltar el botón elLED se apagará y permanecerá apagado. Primero realizaremos el sketch suponiendo que el botón entrega un pulso limpio y sin rebotes, probaremos el circuito y veremos que su funcionamiento es errático. Para hacer el sketch mucho más corto utilizaremos una nuevatécnica llamada interrupciones de hardware que explicaremos mas adelante ///// int LED = 11; int PULSADOR =2; volatile int estado = LOW; void setup() { pinMode (LED,OUTPUT); pinMode (PULSADOR,INPUT); attachInterrupt(digitalPinToInterrupt(PULSADOR),manejadorpulsador,RISING); digitalWrite (LED,estado); } void manejadorpulsador() { estado = !estado; } void loop() { digitalWrite(LED,estado); } ///// Revisa y sube el sketch a tu placa Arduino, comprueba el funcionamiento del circuito. Como te habrás dado cuenta el circuito funciona, a veces si, a veces no, tienes que insistir varias veces para obtener el resultado que se espera, ya sea que prenda el LED o que apague. Ahora utilizaremos un código totalmente diferente al anterior, sin interrupciones de hardware, basándonos en el sketch del proyecto antirrebote ///// const int boton = 2; // declaramos constante entera botón const int tiempoAntirebote = 10; //declaramos constante entera tiempoAntirrebote int estadoBoton; // declaramos variable entera estadoBoton, no se le asigna valor int estadoBotonAnterior; // declaramos variable entera estadoBotonAnterior, int ledPin = 11; boolean LED; booleanantirebote(int pin) // inicia función antirrebote { int contador = 0; //declara variable entera contador y la iguala a cero boolean estado; //declara variable tipo boolean estado, no le asigna valor booleanestadoAnterior; //declara variable tipo boolean estadoAnterior, no le asigna valor inicial do //inicia función do while { estado = digitalRead(pin); // lee el estado de pin y le asigna el valor a la variable estado if(estado !=estadoAnterior) //comparamos el estado actual con el anterior { contador = 0; //Reiniciamos el contador estadoAnterior =estado; // asigna el valor de estado a la variable estadoAnterior } else //si estado no es diferente a estadoAnteriorse ejecutan instrucciones de función else { contador =contador + 1; //la variable contador se incrementa en uno } delay(1); // espera un milisegundo } while(contador< tiempoAntirebote); //ejecuta las instrucciones do si contador es menor que tiempoAntirrebote return estado; // regresa la variable estado al programa para continuar ejecución } //termina función antirrebote void setup() //inicia función de configuración { pinMode(boton,INPUT); // Declaramos el botón como entrada pinMode (ledPin,OUTPUT); LED = false; } void loop() { estadoBoton =digitalRead(boton); // Leemos el estado del botón if(estadoBoton !=estadoBotonAnterior) // si hay cambio con respecto al estado anterior del botón { if(antirebote(boton)==true)// checamos si esta presionado y si lo esta { LED =! LED; digitalWrite(ledPin,LED); } estadoBotonAnterior= estadoBoton; //Guardamos el estado del botón } } ///// Revisa y sube el sketch a la placa Arduino, oprime el botón, oprímelo varias veces, intenta hacer fallar el circuito, verás que es estable y libre de fallas. LED =! LED Adivinaste qué es lo que hace esta instrucción? El signo de admiración equivale a NEGACION, si LED era HIGH al negarlo se convierte en LOW y viceversa. Reto de Proyecto: Agrega un segundo LED con su respectiva resistencia, conéctalo al pin 10, haz que este encienda y apague al contrario del primer LED (cuando uno está encendido el otro está apagado y viceversa) ******************************************************************************** Problemas escribiendo el código? descarga los ejemplos desde mi carpeta compartida en Dropbox: https://www.dropbox.com/sh/w5h38cdrynqdwhf/AABP7b9T3ADbO4KqiPm4pO-9a?dl=0

Proyecto 6: LED secuencial Introducción: El proyecto de luces secuenciales consiste en seis LEDs que prenden y apagan de forma secuencial, este efecto es muy utilizado en anuncios luminosos, en este proyecto escribiremos un programa que simule dicho efecto. Hardware autilizar: Placa Arduino Cable USB 6 LEDs 6 resitencias 220 ohms Cables Diagrama esquemático:  Conexióndel circuito: Sketch de ejemplo: ///// int BASE = 2;     //declaramos variable BASE número del pin donde inician los LEDs int NUM = 6;     //declaramos variable NUM número total de LEDs void setup() {                                                        //se abre llave función void setup for (int i = BASE; i< BASE+NUM; i++)   //crea variable entera i, le asigna el valor BASE //compara i con el valor BASE +NUM, si se cumple la condición ejecuta las instrucciones //de la función, incrementa el valor de i en uno {                                                                //se abre llave función for pinMode(i,OUTPUT);     // configura pin i como salida (OUTPUT) }                                                                //se cierra llave función for }                                                                //se cierra llave función void setup void loop()                                                 {                                                                // se abre llave función void loop for(int i=BASE;i<BASE +NUM; i++)    //crea variable entera i, le asigna el valor BASE //compara i con el valor BASE +NUM, si se cumple la condición ejecuta las instrucciones //de la función, incrementa el valor de i en uno {                                      // se abre llave función for digitalWrite(i,LOW);          // pone el pin i correspondiente en estado apagado (LOW) delay(200);                      // espera 200 milisegundos }                                     // se cierra llave función for for(int i=BASE;i<BASE +NUM; i++)    //crea variable entera i, le asigna el valor BASE //compara i con el valor BASE +NUM, si se cumple la condición ejecuta las instrucciones //de la función, incrementa el valor de i en uno {                                       // se abre llave función for digitalWrite(i,HIGH);           // pone el pin ien estado encendido (HIGH) delay(200) ;                      // espera 200 milisegundos }                                     // se cierra llave función for }                                    // se cierra llave función void loop ///// En este programa utilizamos la función for para ejecutar varias veces una instrucción en vez de escribir cada instrucción 6 veces (una para cada LED). Revisa y sube el sketch a la placa Arduino, observa como camina la secuencia. Analicemos detenidamente el sketch: void setup() {                                                                   //se abre llave función void setup for (int i = BASE; i< BASE+NUM; i++)     //crea variable entera i, le asigna elvalor BASE //compara i con el valor BASE +NUM, si se cumple la condición ejecuta las instrucciones de la //función, incrementa el valor de i en uno {                                                                //se abre llave función for pinMode(i,OUTPUT);     // configura pin icomo salida (OUTPUT) }                                                                 //secierra llave función for }                                                                //se cierra llave función void setup Con los conocimientos que tenemos hasta este punto hubiéramos configurado los pines de salida de la siguiente forma: pinMode (2,OUTPUT); pinMode (3,OUTPUT); pinMode (4,OUTPUT); pinMode (5,OUTPUT); pinMode (6,OUTPUT); pinMode (7,OUTPUT); En vez de escribir 6 instrucciones podemos “optimizar” el código, en este caso utilizando la función for for (int i = BASE; i< BASE+NUM; i++)   -         Declara la variable i y le asigna el valor BASE(declarado como 2 al principio del programa) -         pregunta ¿es i menor que BASE+NUM? (BASE = 2, NUM = 6, BASE+NUM = 8) -         SI, ejecuta la instrucción pinMode(i,OUTPUT). NO, termina la función for -         i ++ (i es igual a i +1) -         regresa a comparar de nuevo i con BASE+NUM De esta forma asigna los pines de salida del 2 al 7, en el momento que el valor de i es igual a 8 ya no se cumple la condición de la función for y ésta termina. La misma función se utiliza en void loop(), primero enciende los leds de uno por uno y después los apaga de la misma manera. Reto Proyecto 6:utilizando el potenciómetro cambia la velocidad de la secuencia de LEDs (de 0 a1023 milisegundos) necesitarás la salida analógica del potenciómetro y asignarsu valor a una variable, yo usé velocidad ******************************************************************************** Problemas escribiendo el código? descarga los ejemplos desde mi carpeta compartida en Dropbox:  https://www.dropbox.com/sh/w5h38cdrynqdwhf/AABP7b9T3ADbO4KqiPm4pO-9a?dl=0    Sigue: Proyecto 7: Uso de botones http://www.taringa.net/posts/ciencia-educacion/19692015/Tutoriales-Arduino-Proyecto-7-Uso-de-Botones.html

Proyecto 10: Zumbador pasivo Introducción: Podemos utilizar la placaArduino para realizar muchos trabajos interactivos, los más comunes son ópticosy acústicos. A diferencia del zumbador activo que solo puede emitir un tono(siempre igual, a la misma frecuencia) el zumbador pasivo no tiene oscilador,entonces, al enviarle diferentes frecuencias produce distintos tonos de sonido.Podemos usar la placa Arduino para tocar la melodía de una canción. Hardware a utilizar PlacaArduino Cable USB Potenciómetro 10K ohms Zumbador pasivo Protoboard Cables Diagrama esquemático: Conexiones del circuito: Sketch de ejemplo: ///// int zumbador = 8; //____________________________________________ int potenciometro = 0; //________________________________________ int lectura; //declara la variable entera lectura, no le asigna ningún valor int FreqMin = 100; //___________________________________________ int FreqMax = 1000; //__________________________________________ int frecuencia; //_______________________________________________ void setup() //_________________________________________________ { //__________________________________________________________ pinMode (zumbador,OUTPUT); //____________________________ pinMode (potenciometro,INPUT); //____________________________ } void loop() { lectura = analogRead (potenciometro); //__________________________________________ frecuencia = map (lectura, 0, 1023, FreqMin, FreqMax); //hace un mapeo 0 a 1023 con FreqMin aFreqMax tone (zumbador, frecuencia);// genera un tono en zumbador utilizando el valor de frecuencia } ///// Revisa y sube el sketch a tu placa Arduino, gira el potenciómetro y escucha como cambia el tono del sonido en el zumbador pasivo. Hagamos esto un poco más interesante, modifica la última instrucción de lafunción void loop y agrega un delay para que te quede de lasiguiente manera: tone (zumbador, frecuencia,300); // genera un tono en zumbador utilizando el valor de //frecuencia, silencio 300 milisegundos) delay (500); // espera 500milisegundos Revisa y sube el sketch a tu placa Arduino, escucha la diferencia que hicieron las últimas instrucciones Explicación de la función map: frecuencia = map (lectura, 0, 1023, FreqMin, FreqMax); - La variable lectura es la salida del potenciómetro, su rango de valores es de 0 a 1023 - El rango de valores de frecuencia es de FreqMin (100) a FreqMax(1000) - la función mapr ealiza un mapeo, cuando lectura sea cero (valor mínimo) frecuencia será FreqMin (100) - cuando lectura sea 1023 (valor máximo) frecuencia será FreqMax(1000) - la función map calcula los valores de los puntos intermedios de 0 a 1023 y los asigna a los valores intermedios entre 100 y 1000 - map asigna el valor calculado a la variable frecuencia Reto Proyecto10: quita los delays y quita el potenciómetro, declara las siguientes variables enteras: DO = 283, RE =314, MI = 346, FA = 378, los valores se aproximan a la frecuencia de las notas musicales correspondientes, toca lasiguiente melodía: DO, RE, MI DO, MI DO, MI (pausa) RE, MI, FA (pausa) FA, MI, RE FA ajusta los delay hasta que reconozcas la melodía. ******************************************************************************** Problemas escribiendo el código? descarga los ejemplos desde mi carpeta compartida en Dropbox: https://www.dropbox.com/sh/w5h38cdrynqdwhf/AABP7b9T3ADbO4KqiPm4pO-9a?dl=0 Sigue: Proyecto 11: Pistola cósmica http://www.taringa.net/posts/ciencia-educacion/19695275/Tutoriales-Arduino-Proyecto-11-Pistola-cosmica.html

Proyecto 12: LED RGB Introducción: El LED RGB (Red, Green, Blue) puede emitir luz brillante de los colores Rojo, Azul y Verde y todas las combinaciones posibles de los mismos, además por medio del control PWM podemos hacer infinidad de combinaciones variando independientemente la intensidad de cada color. Este es el principio del funcionamiento de la televisión a color. Observa la imagen del LED RGB y su respectivo diagrama, la pata más larga (No. 2) es la pata común de tres LEDS internos, en este caso la pata común es el Cátodo (polo negativo), Hay LEDs RGB con Ánodo (polo positivo) común, para este proyecto necesitamos que sea de Cátodo común. Hardware a utilizar: Placa Arduino Cable USB 3 Potenciometros de 10K ohms 3 resitencias 220 ohms 1 LED RGB (cátodo común) Diagrama esquemático: Conexiones del circuito Sketch de Ejemplo: Utilizaremos como salida los pines digitales (con capacidad PWM) 8, 9 y 10, para leer las salidas análogas de los potenciómetros utilizaremos los pines de entrada análogos A0, A1 y A2. Utilizaremos la ventana Monitor Serial del IDE de Arduino para observar el cambio de valores análogos en los potenciómetros ///// int LED1 = 8; int LED2 = 9; int LED3 = 10; int pot1 = A0; int pot2 = A1; int pot3 = A2; void setup() { pinMode(LED1,OUTPUT); pinMode(LED2,OUTPUT); pinMode(LED3,OUTPUT); Serial.begin(9600); } void loop() { int salida1 =analogRead(pot1); int salida2 =analogRead(pot2); int salida3 =analogRead(pot3); int PWM1 = map (salida1, 0, 1023, 0, 254); int PWM2 = map (salida2, 0, 1023, 0, 254); int PWM3 = map (salida3, 0, 1023, 0, 254); Serial.print ("ROJO " ); Serial.print (PWM1); Serial.print (" VERDE " ); Serial.print (PWM2); Serial.print (" AZUL " ); Serial.println (PWM3); Serial.println (" " ); analogWrite (LED1,PWM1); analogWrite (LED2,PWM2); analogWrite (LED3,PWM3); delay(100); } ///// Revisa y sube el sketch a tu placa Arduino, Abre la ventana del monitor serial, gira los 3 potenciómetros hacia la izquierda (hasta el tope), ahora sube y baja uno por uno, observa los cambios de color en el LED RGB. Reto Proyecto 12: quita los potenciómetros y solo deja conectado al protoboard el LED RGB con sus respectivas resistencias, la pata común (cátodo) va a GND (tierra) y las patas de cada color a los pines digitales 8, 9 y 10. Escribe el siguiente sketch, revísalo y súbelo a la Placa Arduino: ///// int led1 = 8; int led2 = 9; int led3 = 10; void setup() { pinMode(led1, OUTPUT); pinMode(led2, OUTPUT); pinMode(led3, OUTPUT); } void loop() { int i,j,k=0; for(i=0;i<=10;i++) { analogWrite(led1, i*25); delay(100); for(j=0;j<=10;j++) { analogWrite(led2, j*25); delay(100); for(k=0;k<=10;k++) { analogWrite(led3, k*25); delay(100); } } } } ///// Observa como los tres colores se combinan en una gran variedad de tonalidades. ******************************************************************************** Problemas escribiendo el código? descarga los ejemplos desde mi carpeta compartida en Dropbox: https://www.dropbox.com/sh/w5h38cdrynqdwhf/AABP7b9T3ADbO4KqiPm4pO-9a?dl=0

Proyecto 14: Sensor de flama Introducción: El sensor de flama es un diodo de alta sensibilidad a la luz infrarroja, la flama emite luz infrarroja (imperceptible al ojo humano). Al igual que los LEDs, la pata más larga es el polo positivo (ánodo) y la corta el negativo (cátodo) Hardware a utilizar: Placa Arduino Cable USB Sensor de flama Zumbador Resistencia 10k ohms Cables Diagrama esquemático: Conexiones del circuito Funcionamiento Escribiremos un pequeño sketch para conocer los valores de salida de nuestro sensor, el nivel mínimo será cuando no hay presencia de una flama y el valor máximo cuando la flama está muy cerca del sensor. El valor y sus cambios los veremos en la ventana Monitor serial del IDE de Arduino. ///// int sensorflama = 0; int lectura; void setup() { Serial.begin(9600); } void loop() { lectura =analogRead (sensorflama); Serial.println(lectura); delay(100); } ///// Revisa y sube el sketch a la placa Arduino, abre el monitor serial y toma nota del valor de la variable lectura,como no hay ninguna flama cerca del sensor este será el valor máximo. Con uncerillo o un encendedor enciende una flama y acércala poco a poco al sensor, observa como el valor cambia, cuando la flama esté lo más cerca posible delsensor (sin quemarlo) toma nota del valor de la variable lectura, este será el valor mínimo. Ahora escribiremos el programa para que la alarma suene en la presencia de una flama. Sketch de ejemplo: ///// int sensorflama = 0; int lectura; int zumbador =9; void setup() { pinMode (zumbador,OUTPUT); Serial.begin(9600); } void loop() { lectura =analogRead (sensorflama); Serial.println(lectura); if(lectura<=600) { digitalWrite (zumbador,HIGH); } else { digitalWrite (zumbador,LOW); } delay(100); } Revisa y sube el sketch a la placa Arduino, la alarma debe sonar cuando el sensor de flama la detecta. Reto proyecto 14: agrega un LED rojo al circuito, modifica el programa para que al detectar flama el LED rojo se encienda y el zumbador suene intermitentemente. ******************************************************************************** Problemas escribiendo el código? descarga los ejemplos desde mi carpeta compartida en Dropbox: https://www.dropbox.com/sh/w5h38cdrynqdwhf/AABP7b9T3ADbO4KqiPm4pO-9a?dl=0 sigue Proyecto 15: Sensor de inclinación http://www.taringa.net/posts/ciencia-educacion/19700492/Tutoriales-Arduino-Proyecto-15-Sensor-de-inclinacion.html

Proyecto 13: Foto-resistencia Introdución: Despuésde realizar los proyectos anteriores, hemos adquirido conocimientos básicos de lo que puede hacer la placa Arduino. Hemos aprendido Entradas y Salidasdigitales así como entradas análogas y salidas PWM, ahora comenzaremos a trabajar con sensores. La Foto-resistencia (foto-resistor) es una resistencia cuyo valor cambia dependiendo de la luz que recibe, está fabricada con un semiconductor fotoeléctrico, si recibe mucha luz el valor de su resistencia disminuye, si la luz disminuye el valor de su resistencia aumenta. La foto-resistencia se utiliza comúnmente para medir la intensidad de la luz, control de luz (apagadores ópticos) y para convertir el cambio de intensidad de luz en un cambio de intensidad de corriente eléctrica. Este proyecto es prácticamente igual al proyecto 4, en vez de utilizar el potenciómetro para cambiar la intensidad del LED manualmente, utilizaremos la foto-resistencia (que como el potenciómetro tiene una salida análoga) que cambiará la intensidad del LED automáticamente dependiendo de la luz que esta reciba. Hardware a utilizar: Placa Arduino Cable USB Foto-celda LED Resitencia 10K ohms Resistencia 220 ohms Protoboard Cables Diagrama esquemático Conexióndel circuito Sketch de ejemplo: ///// int fotopin = 0; int ledpin = 11; int val = 0; int brillo = 0; void setup() { pinMode(ledpin,OUTPUT); Serial.begin (9600); } void loop() { val = analogRead(fotopin); Serial.println(val); brillo = map(val,0,1023,0,255); analogWrite (ledpin,brillo); delay(10); } ///// Revisa y sube el sketch a la placa Arduino, cambia la intensidad de luz que recibe la foto-resistencia y observa cómo cambia la intensidad de brillo del LED. Abre la ventana del monitor serial y observa los valores de salida análoga de la foto-resistencia, acerca una luz intensa a la foto-resistencia y toma nota del valor (mínimo), en mi caso fue 12, ahora cubre la foto-resistencia para que no reciba nada de luz y toma nota del valor (máximo), en mi caso 390. Ajusta la función map en tu sketch para hacer más exacto el comportamiento esperado: brillo = map(val,10,400,0,255); Reto Proyecto13: Agrega el zumbador activo al circuito, haz que pite cuando la foto-resistencia se encuentre en valor máximo (sin luz). ******************************************************************************** Problemas escribiendo el código? descarga los ejemplos desde mi carpeta compartida en Dropbox:  https://www.dropbox.com/sh/w5h38cdrynqdwhf/AABP7b9T3ADbO4KqiPm4pO-9a?dl=0     Sigue Proyecto 14: Sensor de flama http://www.taringa.net/posts/ciencia-educacion/19699525/Tutoriales-Arduino-Proyecto-14-Sensor-de-flama.html