Índice de contenidoUn circuito eléctrico básico.............................................................................................................5

La Ley de OHM..........................................................................................................................6Las Resistencias..........................................................................................................................7

Código de colores para resistencias.................................................................................................8Resistencias en Serie...................................................................................................................9Resistencias en Paralelo..............................................................................................................9

Condensadores (Capacitores)........................................................................................................12El código Jis..............................................................................................................................17Resumen de Capacitores...........................................................................................................17

Fuente de alimentación para los proyectos electrónicos................................................................17Conociendo algunos Símbolos Electrónicos..................................................................................19Componentes electrónicos.............................................................................................................22

Las pantallas o displays LCD....................................................................................................23Bobinas o Inductancias..................................................................................................................25Manejo del Multímetro (Tester).....................................................................................................27

Selección de Escalas y Rangos.................................................................................................28Tensión en DC...........................................................................................................................29Medir Corriente en Continua....................................................................................................30Medir Condensadores...............................................................................................................30

Los Semiconductores.....................................................................................................................31Diodos.......................................................................................................................................32

Funcionamiento teórico de un Transistor.......................................................................................33Funcionamiento práctico de un Transistor.....................................................................................33

Repaso de configuraciones para transistores.............................................................................35Conectando un relay a un pin del controlador...........................................................................36Transistores de Efecto de Campo (fet)......................................................................................37Transistores de Potencia............................................................................................................38Los IGBTS................................................................................................................................38Repaso de Transistores..............................................................................................................38Disipadores Térmicos................................................................................................................39

Tiristores........................................................................................................................................40Conclusiones sobre Semiconductores.......................................................................................41

Soldaduras con estaño....................................................................................................................41Técnica de soldado.........................................................................................................................44Lógica Digital................................................................................................................................47Compuertas Lógicas......................................................................................................................48Que es Arduino..............................................................................................................................51

Como trabajar con Arduino.......................................................................................................51Arquitectura de un sketch..........................................................................................................51Conceptos básicos para una programación exitosa...................................................................52El microcontrolador del Arduino UNO.....................................................................................53

Circuito electrónico de la placa Arduino UNO..............................................................................54La placa Arduino UNO..................................................................................................................56

Componentes de la placa Arduino UNO...................................................................................56Esquema lógico de Arduino......................................................................................................58Puertos del Arduino UNO.........................................................................................................59Pines con entradas analógicas y el ADC...................................................................................61Pines con control PWM............................................................................................................63

El sistema de memoria de Arduino...........................................................................................65El IDE de Arduino.........................................................................................................................67

El Booloader de Arduino...........................................................................................................68Librerías para Arduino...................................................................................................................69Programando Arduino UNO..........................................................................................................69

La función millis()....................................................................................................................70El bucle condicional for().........................................................................................................71Sacando binarios por el puerto B..............................................................................................73Contador de un dígito................................................................................................................75Contador de tres dígitos............................................................................................................77

El conversor analógico (ADC)......................................................................................................81Sensor LM35.............................................................................................................................84

Interrupciones con Arduino UNO..................................................................................................87Funcionamiento del Timer 1.....................................................................................................91INT0 y INT1.............................................................................................................................93

Uso de pantallas LCD....................................................................................................................96Midiendo con el ADC por cuatro canales...............................................................................101

Sensor de temperatura 1-wire DS18B20.....................................................................................104Obteniendo el ID de un sensor DS18x20................................................................................107

Medición de temperatura y humedad con DHT22.......................................................................110Medición de temperatura y humedad con HDC1000..................................................................112Sensor Barométrico LPS25HB....................................................................................................115Medición del índice de Radiación Ultravioleta...........................................................................117Reloj calendario DS3231.............................................................................................................119Scanner I2C..................................................................................................................................121Usando el puerto UART...............................................................................................................123

Voltímetro UART....................................................................................................................127Ajustando el calendario DS3231 mediante la UART..................................................................134Lora Radio...................................................................................................................................135Enviando datos por un enlace Lora Radio...................................................................................140Usando la EEPROM de Arduino.................................................................................................144Control de un Servo Motor..........................................................................................................146Control de un motor paso a paso.................................................................................................147Agregando Bluetooth a Arduino..................................................................................................149

Control del Puerto Arduino por Bluetooth..............................................................................152Control de un Servo Motor mediante Bluetooth.....................................................................153

Manejo de un teclado matricial....................................................................................................154Control de un sistema RFID........................................................................................................156

Frecuencias en distintos países................................................................................................156Cantidad de información almacenada en una etiqueta de RFID.............................................157Etiquetas de lectura y lectura/escritura...................................................................................157Etiquetas pasiva y etiquetas activas........................................................................................157Usando tags de solo lectura.....................................................................................................157Control de acceso para una puerta..........................................................................................160

PID (Controlador Proporcional, Integral y Derivativo)...............................................................163Funcionamiento general de un PID.........................................................................................163Control de temperatura con PID.............................................................................................163

Ethernet y protocolos de RED.....................................................................................................165El modelo OSI.........................................................................................................................165Capa 1: FÍSICA.......................................................................................................................165

Capa 2: ENLACE DE DATOS...............................................................................................165Capa 3: RED...........................................................................................................................165Capa 4: TRANSPORTE..........................................................................................................166Capa 5: SESIÓN.....................................................................................................................166Capa 6: PRESENTACIÓN......................................................................................................166Capa 7: APLICACIÓN...........................................................................................................166Potocolo IP..............................................................................................................................166Direcciones IP.........................................................................................................................166El protocolo HTTP..................................................................................................................167Algunas consideraciones practicas..........................................................................................167

Ethernet Shield con WS5100.......................................................................................................168Que es HTML?............................................................................................................................170

Ejemplos de algunas etiquetas HTML....................................................................................171Servidores web con electrónica...................................................................................................173Que es Ajax?................................................................................................................................173

GET( ) y POST( )....................................................................................................................176Mi primer web con Arduino.........................................................................................................177Control HTML de un LED .........................................................................................................181Leyendo el estado de un pin con HTML.....................................................................................185Leyendo el estado de un pin con AJAX.......................................................................................188

XLMHttpRequest( )................................................................................................................189La función Ajax.......................................................................................................................189Funcionamiento del servidor...................................................................................................190

Mejorando la gráfica WEB con HTML.......................................................................................193Lectura de un cana analógico con Ajax.......................................................................................196Manejo de imágenes en código URI64........................................................................................200Lectura de cuatro canales analógicos con Ajax...........................................................................201WEB y CheckBox LED...............................................................................................................204Sensor BMP280 con WEB & Ajax..............................................................................................207Sensor BME280 con WEB & Ajax..............................................................................................210Sitios WEB en memoria SD........................................................................................................214Pines y A/D con Ajax en memoria SD.........................................................................................217Que es Python?............................................................................................................................222

Trabajando con Python............................................................................................................223Variables en Python.................................................................................................................224Creando un menú con Python.................................................................................................226Exportando un Menú Python..................................................................................................227Estructuras de control en Python............................................................................................230

Que es un socket?........................................................................................................................232Conectando Arduino por Socket UDP.........................................................................................233

Controlando un LED por Socket UDP....................................................................................235Lectura de un canal analógico por Socket UDP......................................................................239

Que es MQTT..............................................................................................................................242Por qué MQTT........................................................................................................................242Como funciona MQTT?..........................................................................................................243Trabajando con el sensor BMP280 y MQTT..........................................................................243

Ley de Ohm

Las Resistencias.Las resistencias son el componente electrónico más omnipresente. Son unapieza crítica en casi todos los circuitos. Y juegan un rol muy importante ennuestra ecuación preferida, la Ley de Ohm.Las resistencias son componentes electrónicos que tienen una resistividad eléctrica específica que nunca cambia. La resistividad de la resistencia

limita el flujo de electrones en un circuito. Son componentes pasivos, lo que significa que ellos solo consumen energía (y no lapueden generar). Las resistencias generalmente se agregan a loscircuitos como complemento de los componentes activos tales como lo amplificadores operacionales, microcontroladores y otroscircuitos integrados. Generalmente las resistencias se ocupan paralimitar la corriente, dividir los voltajes, y como resistencias pull-up en las líneas de entrada y salida (I/O).En esencia eso es lo único que puede hacer una resistencia sin importar el tipo que sea, de todos los componentes pasivos es sin duda la resistencia el más simple de todos, ya que no tiene polaridad para respetar y su implementación solo está condicionada por dos variables, el valor propio de la resistencia y su potencia. La potencia de una resistencia determina su tamaño físico, a mayor potencia más grande será la resistencia en su aspecto, necesita mayor superficie para disipar el calorde su superficie.El instrumento para medir resistencias es el óhmetro y se simboliza con la letra griega omega rodeado por una circunferencia. Siempre que se mida una resistencia esta debe estar con al menos uno de sus pines desconectado del circuito electrónico.De acuerdo a lo visto podemos entonces decir lo siguiente:

La resistencia es la oposición que presentan los cuerpos al paso de la corriente eléctrica.

Hay una gran variedad de otras resistencias de propósitos especiales. Las resistencias pueden venir en paquetes pre-conectados de cinco o más resistencias. Las resistencias en estos conjuntos pueden tener un pin común o estar puestas como divisor de voltaje. Las resistencias no tienen que ser estáticas. Las resistencias variables conocidas como reóstato, son resistencias que se pueden ajustardentro de un rango específico de valores. Parecido al reóstato es el potenciómetro, lospotenciómetros son una resistencia con un patíno contacto que recorre toda esta resistenciacreando un divisor de voltaje ajustable entre elpin central y cualquiera de sus extremos. Estas resistencias variables generalmente seocupan en entradas, como perillas de volumen.Un conjunto de potenciómetros.

Del extremo superior izquierdo, en sentido de las agujas del reloj, un potenciómetro de ajuste (trimpot), un joystick de 2 ejes, un potenciómetro de membrana (softpot), un potenciómetro deslizante (slide pot), un potenciómetro clásico de ángulo recto, y un potenciómetro de ajusto apto para protoboard.Se los utiliza como controles de volumen, control tono, control de fuerza y control de luminosidad.Para medir un potenciómetro con un tester colocamos el

instrumento entre punta y punta del potenciómetro y medimos su resistencia total luego colocando el multímetro en su punto medio podemos medir la resistencia entre el cursor y los extremos.

Decodificar Resistencias de Montaje en Superficie.Las resistencias de montaje en superficie como las 0603 o las 0805, tienen su propia forma de mostrar su valor. Hay algunos métodos comunes para marcas estas resistencias. Generalmente tienen tres o cuatro caracteres, ya sean números o letras, impresas en la parte superior de la carcasa.Si los tres caracteres que ves son todos números, probablemente está viendo una resistencia con marcas E24. Estas marcas comparten similitudes con el sistema de color que se usa en las resistencias de agujeros pasantes. Los primeros dos números representan los dígitos más significativos del valor, el número final representa la magnitud.

En el ejemplo superior, las resistencias son marcadas 104, 105, 205, 751, y 754. La resistencia marcada con 104 debería ser de 100kΩ (10×104),105 seria 1MΩ (10×105), y 205 es de 2MΩ (20×105). 751 es de 750Ω (75×101), y 754 es de 750kΩ (75×104).

Otro sistema de codificación común es el E96, y es el más críptico de todos. Las resistencias E96

significativas desde el punto de su aplicación como fuente acumulada de energía son: altos valores capacitivos para reducidos tamaños, corriente de fugas muy baja, alta resistencia serie, y pequeños valores de tensión.

El código Jis.En la actualidad es común encontrar condensadores que tienen su valor impreso en un código de

tres cifras, el código Jis inventado por los japoneses y se debe interpretar de la siguiente forma:

La tolerancia al igual que las resistencias hace referencia a la precisión del condensador.Para cambiar de escalas uF, nF o pF usamos el multiplicador x 1000.

Los condensadores variables.Entre los variables existen algunos que pueden modificar su capacidad dentro de unpequeño margen o rango menor y otros en un rango mayor.

La unidad de medida es el pico faradio (pf).

Los condensadores electrolíticos generalmente son de valores capacitivos superiores al uF llegando incluso a valores 50.000 uF o mas.Los tipos empleados en la actualidad son de aluminio y de tantalio.Es importante destacar que este tipo de condensador es generalmente polarizado.La unidad de medida es el uF, por ejemplo: 3300 uFx50V, 100 uFx10V.Cuando vamos a comprar un condensador deberemos especificarle al vendedor dos parámetros:

1. La capacidad del condenador en la escala que resulte mas conveniente uF/nF/pF.2. El voltaje del condensador

Resumen de Capacitores.Son dispositivos que sirven para almacenar energía eléctrica entre sus armaduras y su unidad de medida para el almacenamiento de energía es el faradio (F).Submúltiplos del faradio. Microfaradio (Pf) = millonésima parte de 1f (1 x 10-6). Nanofaradio (nf) = mil millonésima parte de 1f (1 x 10-9). Picofaradio (pf) = billonésima parte de 1f (1 x 10-12).

Fuente de alimentación para los proyectos electrónicos.Para el correcto funcionamiento de todo sistema electrónico la fuente de alimentación es parte fundamental y la mayoría de las veces no se da la importancia que tiene a la hora de conectar circuitos electrónicos.

El uso de opto-acopladores en microcontroladores es de vital importancia por dos motivos fundamentales.

• Aíslan interferencias y ruidos eléctricos que pueden afectar a los sistemas de control.• Aísla al propio usuario de potenciales eléctricos peligrosos convirtiendo el uso de equipos

de potencia seguros desde el punto de vista del riesgo eléctrico.

Lamentablemente el uso de opto-acopladores no es práctica común en el mundo del aficionado a la electrónica. Imagino porque los circuitos electrónicos parecen funcionar bien sin ellos, remarco el “parecen”. No debe olvidar el lector que no es lo mismo hacer funcionar un aparato electrónico en el taller o la mesa de trabajo que colocarlo dentro del motor de un automóvil o el gabinete eléctrico de una fábrica, los ruidos e interferencias eléctricas están presentes en esas condiciones y no en el laboratorio.Por ejemplo imagine que está ensamblando un sistema de alarma simple donde un sensor de movimiento será cableado hasta su sistema de control y para eso necesita 10 metros de cable, en unapunta esta su central de control y en la otra su sensor y en el medio 10 metros de antena dispuesta a recibir todas las posibles señales eléctricas, un simple relámpago en un día de tormenta dispara su alarma. Si colocamos un opto-acoplador a la entrada del sistema de control una interferencia transitoria no alcanzará a encender el led interno y el opto-acoplador funciona como un filtro eliminando los ruidos eléctricos que se imprimen en los 10 metros de cable.Otro ejemplo de uso podría ser el control de una carga sobre la red eléctrica con una señal que proviene de un controlador con 5Voltios como máximo.

Este tipo de montajes son muy seguros porque “separan” al usuario que opera el equipo de control de las potencias que se manejan. Desde el punto de seguridad son montajes casi de uso obligatorio.

Bobinas o Inductancias.

Almacenan energía eléctrica en forma de campo magnético. Físicamente están formados por un alambre esmaltado, el cual se encuentra enrollado sobre una forma de núcleo que puede ser de plástico, ferrita o metal.Su unidad de medida es el henryo, los submúltiplos son: el milihenryo (mH) el microhenryo (uH).

Son dispositivos de indicación de funciones como: luz piloto, etéreo, encendido, rec/play, etc.La función se basa en sus características, es decir, emitir luz roja,verde o amarilla.El principal elemento es el arseniuro de galio.El material de tipo-p es normalmente denominado “ánodo” y elmaterial tipo-n es es denominado “cátodo”. En un esquemático unLED es representado así:Notar que las dos “patas” del LED son de distinto largo, lo queindica cuál es el ánodo y cuál es el cátodo. En un LED, la pata más larga corresponde al ánodo y la más corta al cátodo. La corriente siempre fluye de

ánodo a cátodo. En un circuito simple, el ánodo se conecta al voltaje positivo de la fuente y el cátodo se conecta a tierra o al voltaje negativo de la fuente.Un LED exhibe una caída de voltaje característica basada en el material que se use de semiconductor y generalmente se encuentra entre los 1,5V y 4V. Si se llega a alimentar un LED conuna tensión mayor a este voltaje característico y la fuente puede suministrar la suficiente corriente, el LED se quemará, destruyendose. Por esto, los LED se ocupan casi siempre junto a un resistor limitador de corriente. El resistor disminuye la cantidad de corriente fluyendo por el LED, manteniéndola a un nivel que no lo destruya.

Diodo Led Infrarrojos.

Emiten o reciben rayos infrarrojos al ser recorridos por una corriente eléctrica.Se los utiliza en sistemas de control a distancia de aparatos eléctricos o electrónicos, como TV a color, equipos musicales, video, alarmas, etc.

Funcionamiento teórico de un Transistor.

El transistor convencional o bipolar se denomina así porque en su funcionamiento intervienen corrientes de huecos, o de carga positiva, y de electrones, o de carga negativa. Otros dispositivos como los FET se denominan monopolares porque sólo hay corrientes de un tipo.Los terminales del transistor reciben el nombre de emisor, colector y base. La base es el terminal que está unido a la zona intermedia del transistor. Las tres partes del transistor se diferencian por el distinto nivel de dopaje del material semiconductor, la zona de menor dopaje es la base, a continuación se encuentra el colector y por último el emisor.

Funcionamiento práctico de un Transistor.Observe el siguiente circuito. Tenemos un LED conectado a potencial positivo mediante una resistencia atenuadora de 270 Ohm para limitar la corriente que toma el LED y el propio transistor.

Es por esta razón que se debe disponer el transistor en un soporte disipador, con el fin de que el calor desarrollado no aumente excesivamente la temperatura del cuerpo, y con ello, disminuya en forma considerable el rendimiento del transistor. En general, los transistores de potencia se construyen de modo tal que elcolector este conectado directamente al cuerpo envolvente o cápsula,aumentando así la superficie de radiación.Esto ofrece la ventaja de una buena disipación pero obliga a usar una placaaislante entre el transistor y el disipador, generalmente una placa de mica yunos aislantes para los tornillos que sujetan el transistor al disipador, si no se coloca este placa separadora todo el disipador esta conectado al colector por lo tanto se deberá tener especial cuidado que nada toque el disipador, disipador y transistor forman en este montaje una misma unidad. Para asegurar la correcta transferencia de temperatura al disipador se empleará grasa siliconada paraelectrónica. No confundirla con grasa siliconada para rodamientos, no es lo mismo. La grasa siliconada para disipadores esta especialmente diseñada para este fin.

Tiristores. Un tiristor es uno de los tipos más importantes de losdispositivos semiconductores de potencia y control. Se puede ver el tiristor como un simple diodo controlado,cuando aparece un pulso de disparo en la compuerta, el tiristorconduce y como diodo su funcionamiento primario estaasignado a corrientes continuas, para muchas aplicaciones sepuede suponer que los Tiristores son interruptores oconmutadores ideales con limitaciones.Triac (Triodo de Corriente Alterna).Se puede definir como un tiristor que conduce en ambos sentidos en forma controlada, lo que permite funcionar en circuitos de corriente alterna y controlar dispositivos en alterna dejando pasar ambos semiciclos de la fase alterna. Si bien la compuerta del triac se podría conectar directamente alos pines del controlador, es prudente no conectar estos dispositivos directamente a los pines de los microcontroladores, para esto existen los opto-acopladores (MOC30xx) que sirven de aislantes o separadores entre la lógica de control y la etapa de potencia.

El uso de opto-acopladores para separar la etapa de potencia con la zona de control es casi de uso obligado para evitar riesgos eléctricos, el siguiente es un ejemplo de uso.

Vemos aquí algunas soldaduras deficientes y la forma correcta de un punto de soldadura.

La técnica para realizar una correcta soldadura se resume en tres pasos:1. Calentar con el soldador los elementos a soldar. 2. Aplicar estaño en su justa medida. 3. No retirar el soldador hasta que el estaño se extienda.

Técnica de soldado.Acercar los elementos a unir hasta que se toquen, si es necesario, utilizar unos alicates para sujetar

bien las partes.

Aplicar el soldador a las partes a soldar, de forma que se calienten ambas partes.Tener en cuenta que los alicates o pinzas absorben parte del calor del soldador.Las piezas empiezan a calentarse hasta que alcanzan la temperatura del soldador. Si la punta está limpia, esto suele tardar menos de 3 segundos. Este tiempo dependerá de si se usan alicates y de la masa de las piezas a calentar.

Hay que remarcar que el regulador de 3.3 Voltios saca energía del regulador de 5 Voltios por lo tanto la carga de 3,3 V se suma a la carga total del regulador de 5Voltios, si excede el amper de corriente el regulador se destruirá. Vigile la temperatura de este regulador.

La placa Arduino UNO.

En la placa se pueden ver los pines que corresponden a los puertos, el cristal de16 Mhz que fija la velocidad de operación, una pequeña fuente de alimentación, un botón de reset y algunos componentes periféricos necesarios para el correcto funcionamiento del microcontrolador.

Componentes de la placa Arduino UNO.• No necesita ningún puente USB para conectarse al MCU, en su lugar usa un MCU

ATMEGA16U2 especialmente programado para trabajar como conversor de USB a serie. • La alimentación puede ser vía USB, batería o adaptador AC/DC a 5V, seleccionado

automáticamente. Arduino puede trabajar entre 6 y 20V, pero es recomendado trabajar entre 7 y 12V por las características del regulador de tensión.

• Puerto Serie en los pines 0 y 1.

• Interrupciones externas en los pines 2 y 3.

• LED en el pin 13.

El siguiente pre-escalador supone usar el ADC a 250 kHz, en este caso no se puede garantizar la resolución de 10 bits, pero si una resolución de 8 bits. De todas formas en caso de necesitar un ADCmás rápido se podría usar uno externo.El ADC puede trabajar en dos modos, single conversion mode y free running mode. En modo single conversion el ADC hace una sola conversión y para, pero en modo free running el ADC está continuamente convirtiendo, es decir, hace una conversión y luego comienza con la siguiente.La comparación continúa dividiendo de nuevo la tensión y actualizando cada bit del registro ADC a 1 si el voltaje es alto en la comparación o 0 en el otro caso. Este proceso se realiza 10 veces (por cada bit de resolución del ADC) y genera como resultado la salida binaria que va desde 0 a 1023.Los pines analógicos de Arduino también tienen todas las funcionalidades de los pines digitales, porlo tanto, si necesitamos más pines digitales podemos usar los pines analógicos.Normalmente el uso del conversor analógico obliga a considerar distintos pasos y configuraciones en el hardware para obtener finalmente una medición fiable de una variable analógica. Afortunadamente el entorno de programación de Arduino hace transparente mucho de esta complicación, funciones y bibliotecas destinadas al manejo del conversor hacen que su implementación sea sencilla, sin embargo siempre se debe tener presente que detrás de un Arduino hay un microcontrolador y por tanto, a pesar que no lo veamos la complejidad electrónica existe y en puntuales situaciones deberemos deberemos lidiar con registros y configuraciones “a mano” por ejemplo cuando trabajemos con el ADC controlado por interrupciones.Arduino UNO no tiene pines de salidas analógicas, para esto necesitamos contar con un conversor Digital a Analógico que el microcontrolador AT Mega 328 no tiene.Arduino DUE si cuenta con estas salidas, su microcontrolador ARM tiene a bordo este tipo de conversor. Un detalle importante es que Arduino DUE trabaja con 3,3V y no 5V como Arduino UNO.

Pines con control PWM.El control de potencia por modulación del ancho de pulso es ampliamente usado para el control de motores, iluminación, etc.Arduino UNO tiene varios pines con esta funcionalidad.

La modulación por ancho de pulsos también conocida como PWM, es una técnica en la que se modifica el ciclo de trabajo de una señal periódica, ya sea para transmitir información a través de uncanal de comunicaciones o para controlar la cantidad de energía que se envía a una carga.El ciclo de trabajo de una señal periódica es el ancho relativo de su parte positiva en relación con el período, el duty cycle es el tiempo que la salida está a uno o a un nivel alto.Los pines asignados a PWM también se pueden usar como puertos de uso general, tienen todas las características de cualquier pin de puerto.En Arduino la frecuencia de PWM es de 500Hz. Pero es un valor que puede modificar en caso que lo necesitemos.

como cadenas, estructuras inicializadas y variables globales.Las variables .bss son la memoria asignada para variables globales y estáticas no inicializadas.Heap es el área de memoria dinámica.La pila es el área de memoria ubicada al final de la RAM y crece hacia el área de datos. El área de pila se usa para almacenar el estado del microcontrolador al saltar a una subrutina y recuperarlo luego, valores de retorno en interrupciones, etc. Como ocurre con todos los microcontroladores el manejo inadecuado del Stack o pila puede traer problemas serios ya que si el Stack crece de manera descontrolada destruirá las otras variables del programa y todo el sistema colapsa.Es importante que siempre exista suficiente memoria libre entre el Stack y el bloque de memoria de datos del usuario. Cuando esta área es demasiado pequeña para las tareas requeridas o falta espacio para el Stack, el microcontrolador comienza a extraviarse o reiniciarse.Normalmente el programador no se preocupa por sus variables y donde se almacenan, esto lo resuelve el compilador, sin embargo como veremos mas adelante, si importa conocer la naturaleza de la variable que estamos usando para ayudar al compilador a un manejo mas eficiente de la memoria SRAM.En algunos microcontroladores es posible agregar memoria RAM externa de una manera similar a como lo hacemos con una PC. Por lo general, esto es costoso (unos pocos KB de RAM externos cuestan mas que el propio microcontrolador) y también requiere habilidades avanzadas de hardwarey software.

El IDE de Arduino.El IDE (Integrated Development Environment) es el entorno de desarrollo integrado o entorno de desarrollo interactivo. Es donde vamos a escribir los programas que finalmente terminan en la memoria FLASH del microcontrolador.

El IDE de arduino y todo lo necesario para trabajar se descarga desde su sitio en Internet, es libre y solo con descargarlo ya está listo para trabajar con el. Al momento de escribir estas líneas hay disponible para su descarga una versión que no necesita ser instalada, se descarga un archivo zip se descomprime y todas las herramientas quedan listas para su uso.El entorno de trabajo de Arduino es bastante austero si lo comparamos con otros entornos para otrasarquitecturas sin embargo es totalmente funcional. Se puede escribir un programa en el, depurarlo e incluso tiene todo lo necesario para programar la memoria del microcontrolador.Las placas Arduinos son reconocidas por el entorno de trabajo de manera automática si se trata de

número anterior como si todavía estuviera presente en el visor y se forma la ilusión óptica que permite ver tres cifras distintas en lo que parece ser el mismo instante.Si la decena está en cero no se muestra lo mismo que la centena, no tiene sentido mostrar tres ceros generando el consumo de mas segmentos cuando no hay información útil para ver.

El conversor analógico (ADC).En muchos proyectos tenemos que tratar con las señales o información del mundo analógico, como la temperatura, presión, corriente, etc .Estas señales son analógicas de forma predeterminada y en la mayoría de los casos se utilizan sensores que convierten estas señales a analógico de tensión eléctrica que será presentada en un pindel microcontrolador para hacer algún trabajo. Por desgracia, los microcontroladores son digitales y no pueden hacer frente a las señales analógicas por lo que estas señales deben ser convertidas en señales digitales que sean comprensibles por el núcleo del microcontrolador. Básicamente digitalizar algo es simplemente convertirlo a una secuencia de números de tal forma que si hacemos el proceso inverso de leer esos números podemos reconstruir la información original.Para el siguiente ejemplo usaremos la electrónica que se muestra a continuación.

Pretendemos medir un voltaje variable mediante un potenciómetro conectado al pin AN0 de nuestra placa Arduino.El ADC de la placa Arduino tiene una resolución de 10 bits, como se dijo anteriormente, digitalizar algo es convertirlo a una secuencia de números, con 10 bits se pueden hacer 1024 números.Es decir que toda medición terminará en un número dentro de ese rango, si esta secuencia de números se convierten a hexadecimal el resultado serían números entre 000 y 3FF.El trabajo propuesto lee el voltaje presente en el punto medio del potenciómetro y lo muestra en hexadecimal en con tres dígitos controlados por un multiplexador de tres transistores.

/****************************************************************** Ejemplo de uso del conversor analógico digital. El ADC muestra* los datos en tres dígitos de siete segmentos. Tres transistores* MPSA13 se utilizan como multiplexador de los display tipo cátodo* El ADC mide el voltaje presente en AN0, el voltaje es generado* por un potenciómetro de 10K cuyos extremos se conectan entre +5* y GND. El punto medio del potenciómetro se conecta a AN0.* Los datos se muestran en hexadecimal de 000 a 3FFF

unsigned char pin = 2; for (unsigned char j=0; j < 7; j++) { digitalWrite(pin, num_array[number][j]); pin++; }}/************** Fin de Programa FIRTEC ARGENTINA ***************/Recuerde que Arduino tiene A0, A1, A2, A3, A4 y A5, todos estos son canales analógicos y por cualquiera de ellos se pueden realizar mediciones incluso todos conectados a distintos sensores.Si bien el conversor del ATmega328 no es de los mas rápidos, es lo suficientemente ágil y preciso para la mayoría de los problemas a resolver con una placa Arduino.

Sensor LM35.El LM35 es la versión para grados centígrados de un legendario sensor que mide en grados Kelvin, el LM355.Ambos son parecidos solo que miden en escalas diferentes, no son reemplazo uno del otro.El LM35 tiene un funcionamiento muy sencillo y seguramente encontrará en la red incontables sitios que lo describen en profundidad. Solo diremos que por su salida envía un voltaje que es proporcional a los grados de temperatura a la está expuesta su cápsula.El voltaje de salida sube o baja a razón de 10 mV por cada grado, 0 mV son cero grados centígradosy 250 mV equivalen a 25 grados C.Como imaginará su uso con Arduino es bastante simple, solo debemos medir el voltaje que el sensor envía al ADC y hacer unos pequeños cálculos para conocer la temperatura.En el ejemplo propuesto necesitamos la siguiente electrónica conectada a la placa Arduino.

El condensador de 01 uF y la resistencia de 100 Ohms forman un filtro para eliminar las posibles interferencias que se pudieran captar entre la conexión del sensor y el pin A0 de la placa Arduino.Recuerde que básicamente está midiendo el voltaje que envía el sensor, si coloca un cable demasiado largo (varios metros) se provoca una caída de tensión en la línea y la medición no será fiable.El siguiente es el código de funcionamiento para el sensor LM35 y el ADC, básicamente es el mismo trabajo anterior solo se han agregado las rutinas para calcular la temperatura y se ha

Funcionamiento del Timer 1.Un temporizador es en esencia un contador que cuenta a la velocidad de CPU.Usando un resonador cerámico de 16Mhz como tiene la placa Arduino, el tiempo de CPU es 1/16 = 62,5 nS. Este es el tiempo de una instrucción de un solo ciclo por ejemplo la instrucción NOP.Y esta es la velocidad de cuenta de un Timer, es decir que cada cuanta toma 62,5 nS, conociendo esto podemos fácilmente calcular tiempos. Un Timer de 16 bits puede contar desde 0 a 65535 a la velocidad de 62,5 nS por cada número contado. Podemos usar un “modulo”, un registro que le dice al Timer desde donde iniciar la cuenta, no necesariamente tiene que ser siempre cero, se puede iniciar la cuenta desde cualquier numero y cuando el contador llegue al final (65535) y pase a cero nuevamente la interrupción se dispara para avisar que el tiempo se ha cumplido. También tenemos los divisores que pueden dividir el tiempo generado en un temporizador por números ya definidos por ejemplo 8, 64, 256 o 1024. Un detalle, los Timer's en la placa Arduino sonsiempre de conteo ascendente.Veamos un ejemplo, imaginemos que queremos generar una señal por un pin que corresponda a unafrecuencia de 50Hz. Recuerde que el Timer no es un generador de frecuencias, solo vamos hacer subir o bajar un pin y vamos a calcular todo para que el ritmo se corresponda a una señal de 50Hz. Como sabemos el período de 50Hz es 20 mili-segundos, es decir que durante 10 mS esta arriba y otros 10 mS abajo.Vamos pedirle al Tmer_1 que genere un tiempo equivalente al período de una señal de 100 Hz que corresponde a 1/100 = 10 mS, esto quiere decir que cada 10 mS el Timer_1 se interrumpirá, solo resta calcular los valores para ajustar el Timer.

16.000.000 / 256 = 62500 (256 es el divisor usado)62500 / 100 = 625 (100 es el período buscado)65535 – 625 = 64911 Módulo del Timer para obtener el período de una señal de 100Hz

Teniendo la interrupción ocurriendo cada 10 mS solo tenemos que subir y bajar un pin a ese ritmo para generar una señal de 50 Hz. La imagen siguiente muestra el tren de pulsos generado.

Para configurar el Timer_1 es necesario trabajar con tres registros.

• TCNT1 es el registro donde se debe escribir el módulo.

void loop (){ float t = dht.readTemperature(); // Lee sensor temperatura float h = dht.readHumidity(); // Lee sensor humedad if (isnan(h) || isnan(t)) { // Verifica si error de lectura Serial.println("ERROR!"); } else{ // No hay error, procesa los datos dtostrf(t, 4, 1, Temperatura); // Procesa la temperatura dtostrf(h, 4, 1, Humedad); // Procesa la humedad lcd.setCursor(12,0); lcd.print(Temperatura); // Muestra la temperatura lcd.setCursor(8,1); lcd.print(Humedad); // Muestra la humedad delay(3000); // Espera para medir nuevamente } } /************** Fin de Programa FIRTEC ARGENTINA ***************/NOTA: Los sensores DHTxx son sensores lentos no debe hacer mediciones consecutivas sin mediar un tiempo entre ellas, en nuestro ejemplo estamos esperando 300 mS entre cada medición lo que asegura una respuesta correcta del sensor.Si toma mediciones muy rápidas el sensor no responderá enviando códigos de error o simplemente no midiendo.

Medición de temperatura y humedad con HDC1000.Con este sensor podemos medir temperatura con un rango que va desde -40 grados a +125 grados y humedad de 0 a 100%. Utiliza un conversor analógico de 14 bits lo que da una precisión mas que aceptable y sin duda superior al sensor DHT22, es la alternativa cuando lo que se necesita es un grado de exactitud mas alto.

Desarrollado por Texas Instruments y ha sido calibrado en fábrica por lo que no requiere ajuste alguno.Este sensor tiene una serie de registros de 16 bits para su configuración y uso. En la dirección 0x00 se guardan dos Bytes que corresponden a la temperatura y en la dirección 0x01 dos Bytes para la humedad.En nuestro ejemplo y para simplificar las cosas, estamos usando un sensor ya montado en una placa

Serial.print("Luz Ultravioleta: "); Serial.println(UVindex); delay(1000);}//********* Fin del archivo Firtec Argentina ********************

En la imagen anterior se pude el resultado al ejecutar el programa, el sensor envía por la UART la cantidad de luz visible, cantidad de lux infrarroja y la luz ultravioleta detectada.

Reloj calendario DS3231.Un reloj de tiempo real (RTC) es un dispositivo electrónico que permite obtener la hora,minutos y segundos. También la fecha calendario. Los RTC normalmente están formados por un resonador de cristal integrado con la electrónica necesaria para contabilizar de forma correcta el paso del tiempo. La electrónica de estos relojes calendario tienen en cuenta las peculiaridades de nuestra forma de medir el tiempo, como por ejemplo el sistema sexagesimal, los meses con diferentes días, o los añosbisiestos.Los RTC aportan la ventaja de reducir el consumo de energía, aportar mayor precisión y liberar a Arduino de tener que realizar el control del tiempo. Además, frecuentemente los RTC incorporan algún tipo de batería que permite mantener los datos en caso de pérdida de alimentación.Dos son los RTC de uso habitual en domótica, el DS1307 y el DS3231, ambos fabricados por Maxim (anteriormente Dallas Semiconductor). El DS3231 tiene una precisión muy superior y puede considerarse sustituto del DS1307.En el modelo DS1307 las variaciones de temperatura que afectan a la medición del tiempo de los cristales resonadores se traducen en errores en un desfase acumulado. Esto hace que el DS1307 sufra de un desfase temporal, que puede llegar a ser 1 o 2 minutos al día.Para solucionarlo, el DS3231 incorpora medición y compensación de temperatura garantizando unaprecisión de alrededor de un segundos al mes.La comunicación en ambos modelos se realiza a través del bus I2C por lo que es sencillo obtener los datos. La tensión de alimentación es 4.5 a 5.5 para el DS1307, y 2.3 a 5.5V para el DS3231.En el caso del DS3231, la medición de temperatura también está disponible, aunque tiene una precisión baja ±3ºC, y el tiempo de adquisición puede durar hasta 1 segundo.También incorporan una batería CR2032 para mantener el dispositivo en hora al retirar la

instrumento.Voltaje = (entrada_A0 * 5.5)/1024, Voltaje_Final = (Voltaje/R2(R1+R2)).

Note que siempre suponemos que los valores de las resistencias son exactas por lo que el error de lectura estará determinado por el error que tengan las resistencias en sus valores en Ohmios.También podríamos leer el voltaje en las entradas A0, A1, A2 y A3 y mostrar los datos en otro instrumento virtual.

Necesitamos cuatro divisores resistivo uno para cada canal analógico. El código de funcionamiento es el siguiente.

/***************************************************************** Lee cuatro canales analógicos y envía datos por el puerto UART.* (Utilizar la aplicación Conversor2.exe)

Ajustando el calendario DS3231 mediante la UART.Teniendo control de la UART vamos a desarrollar una pequeña aplicación que nos permita transferirde forma automática el calendario de nuestra PC al DS3231, para esto usaremos una pequeña aplicación escrita en C que hace el trabajo.

Esta aplicación se conecta al programa Arduino que vemos seguidamente y actualiza los registros del chip DS3231 con los valores del calendario que tenga la computadora donde se ejecuta el programa.

/**************************************************************** * Descripción: Ajusta el DS3231 mediante el puerto UART y Software * de ajuste. * Placa Arduino: Arduino UNO * Arduino IDE: 1.8.5 * * www.firtec.com.ar * (Utilizar la aplicación DS3231.exe)****************************************************************/#include <Wire.h> // Biblioteca para 1-Wire#include "RTClib.h" // Biblioteca para el RTC#include <SoftwareSerial.h>SoftwareSerial mySerial(11, 12); RTC_DS3231 rtc;

char daysOfTheWeek[7][12] = {"Domingo", "Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado"};

byte datos[6];bool bandera = false;byte rx = 0, offset = 0;

void setup (){ Serial.begin(9600); mySerial.begin(9600); delay(3000);

En la imagen anterior se aprecia un enlace lora vinculado al Arduino Uno y otro enlace en Arduino Mega.

El enlace bajo prueba es provisto por Adafruit y se vincula a la placa Arduino mediante el puerto SPI, utiliza ocho pines de conexionado, los pines de alimentación para 5 voltios y los pines del puerto SPI, SCK del enlace se conecta al pin 13, MISO se conecta al pin 12, MOSI al pin 11.El pin “GO” del enlace de Adrafruit se conecta al pin 3 del Arduino, RESET del enlace de radio se conecta al pin 2 del Arduino y el pin CS del enlace al pin 4 del Arduino.En la imagen siguiente se aprecian las conexiones del transmisor.

En la imagen anterior se puede ver el resultado obtenido al ejecutar el programa ejemplo. El sensor DS18B20 se conecta al pin 2, de la misma forma que en los ejemplos anteriores donde se usó este sensor. Los pines TX y RX hacen referencia a los pines de la UART, y es que en el fondo un Bluetooth es un puerto UART con conectividad por radio y capacidades superiores al clásico UART.Los pines de datos se conectan cruzados, es decir que el TX del Bluetooth va a RX en Arduino y TXde Arduino va a RX del Bluetooth.

/****************************************************************** Descripción : Este programa lee la temperatura de un sensor** DS18B20 y lo envía mediante un enlace Bluetooth** HC-05 a un teléfono móvil. ** Target : Arduino UNO** ToolChain : Arduino IDE 1.8.5** www.firtec.com.ar*****************************************************************/#include <SoftwareSerial.h>#include <OneWire.h> #include <DallasTemperature.h>OneWire ourWire(2); //Se establece el pin 2 como bus OneWire DallasTemperature sensors(&ourWire);SoftwareSerial mySerial(11, 12); // RX, TX

void setup(){ pinMode(13, OUTPUT); digitalWrite(13, LOW); mySerial.begin(9600); Serial.begin(115200); sensors.begin(); //Se inicia el sensor DS18B20}

void loop(){ sensors.requestTemperatures(); mySerial.println("Temperatura "); Serial.println(sensors.getTempCByIndex(0)); delay(2000);}//********* Fin del archivo Firtec Argentina ********************

Placa Arduino: UNO Arduino IDE: 1.8.5

www.firtec.com.ar*******************************************************************/#include <PID_v1.h>#include <LiquidCrystal.h>

int salidaPWM = 3; // Salida de señal PWMdouble temp, error, Setpoint, Output; // Variables del PIDdouble Kp = 8, Ki = 1.5, Kd = 1; // Ajustes del PID//// PID myPID(&temp, &Output, &Setpoint, Kp, Ki, Kd, REVERSE);PID myPID(&temp, &Output, &Setpoint, Kp, Ki, Kd, DIRECT);

LiquidCrystal lcd(8, 9, 4, 5, 6, 7);//SetTunings(Kp, Ki, Kd) para ajustar dinámicamente

void setup() { pinMode(salidaPWM, OUTPUT); // Pin PWM puesto como salida Setpoint = 25; lcd.begin(16, 2); myPID.SetMode(AUTOMATIC); // Configura y activa PID myPID.SetOutputLimits(0, 255); lcd.setCursor(0, 0); lcd.print("Control PID"); lcd.setCursor(0, 1); lcd.print("Temp: "); lcd.setCursor(10, 1); lcd.print("SP: ");

}void loop() { char buffer[10] = ""; Setpoint = 25; temp = analogRead(0) * 500.0 / 1024.0; myPID.Compute(); // Calcula salida PWM analogWrite(salidaPWM, Output); sprintf(buffer, "%d.%01d", (int)temp, abs((int)(temp * 10) % 10)); lcd.setCursor(5, 2); lcd.print(buffer); lcd.setCursor(13, 1); lcd.print((byte)Setpoint);}

De esta forma se verificó el funcionamiento del PID, observe que el foco usado es del tipo filamento (antiguo) funcionando como resistencia calefactora controlada por el modulador de potencia provista por el PID.

de datos es recibido por múltiples dispositivos, y las E son para experimentación y prueba.

La dirección IP 127.0.0.1 es la dirección loopback y corresponde con la IP de nuestra computadora.

El protocolo HTTPEl protocolo HTTP está ubicado en la capa 7, capa de aplicación. Es un protocolo simple, basado en texto, utilizado por los navegadores y los servidores web para comunicarse.Cuando desde nuestro navegador intentamos acceder, por ejemplo, al sitio www.firtec.com.ar estamos realizando una petición HTTP al servidor de firtec, que responderá enviando la página solicitada si esta disponible.

Algunas consideraciones practicas.Sabido es que cualquier aplicación decente que pretenda competir en el campo del “Internet de las Cosas” o IoT debe tener conectividad a nivel de red.En las páginas siguientes veremos una serie de ejemplos que logran justamente eso. Construiremos Servidores Web simples con HTML, otros bajo el control de Ajax y enlaces por UDP, el llamado “RS-232” de Internet.Arduino UNO con su microcontrolador ATmega328 tiene un potencial de hardware mas bien acotado para ejecutar aplicaciones que requieran control web, la solución viene con el chip WS5100montado sobre el escudo para Ethernet.

Este escudo se monta directamente sobre los pines de Arduino UNO y tiene incluso un zócalo para conectar una memoria SD pudiendo así alojar en esta memoria los futuros sitos web que el servidor

los flujos de datos que pasan por el puerto Ethernet. En la imagen siguiente se pude ver la estructura interna del W5100.

El escudo provee un conector Ethernet estándar RJ45. También dispone de unos conectores que permiten conectar a su vez otras placas encima.Arduino usa los pines digitales 10, 11, 12, y 13 (SPI) para comunicarse con el W5100. Estos pines no pueden ser usados para otra cosa mientras se usa Ethernet..El botón de reset en la placa Ethernet envía un reset al W5100 y la placa Arduino.La placa Ethernet contiene varios LED para información:

• ON: indica que la placa está alimentada• LINK: indica la presencia de un enlace de red y parpadea cuando envía o recibe datos • 100M: indica la presencia de una conexión de red de 100 Mb/s• RX: parpadea cuando recibe datos • TX: parpadea cuando envía datos

El puente soldado marcado como “INT” puede ser conectado para permitir a la placa Arduino recibir notificaciones de eventos por interrupción desde el W5100, pero esto no está soportado por la librería Ethernet. El puente conecta el pin INT del W5100 al pin digital 2 de Arduino.Recordar:

• Trabaja a 5V suministrados desde la placa de Arduino • El controlador Ethernet es el W5100 con 16K de buffer interno. No consume memoria del

Arduino. • Se comunica con el microcontrolador de Arduino por el bus SPI, por lo tanto para usarlo

siempre debemos incluir la libreria SPI.h• Soporta hasta 4 conexiones simultáneas.• Usar la librería Ethernet para manejar el shield: http://arduino.cc/en/Reference/Ethernet

</center> </body></html>

Resultado en el navegador.

Para enviar el sitio web al navegador solo es necesario escribir los tag secuencialmente en HTTP, distintas herramientas para distintos microcontroladores tienen distintas sintaxis pero todos hacen lomismo, enviar una secuencia de bytes conteniendo los tag para darle formato a un sitio web.En el caso de Arduino, Serial.print(") envía información al puerto serial y cliente.println("<html>")envía un tag al navegador. La palabra cliente (o cualquier palabra) estará asociada al WiFi o Ethernet dependiendo del tipo comunicación que se esté usando, entre comillas están los ASCII enviados al navegador, de la misma forma que enviaríamos un texto por la UART.Para enviar la página solo enviamos la secuencia de ASCII conteniendo los tag, algo como esto:

cliente.println("HTTP/1.1 200 OK"); cliente.println("Content-Type: text/html"); cliente.println("Connection: keep-alive"); cliente.println(); cliente.println("<meta charset='UTF-8'>"); cliente.println("<!DOCTYPE html>"); cliente.println("<html>"); cliente.println("<center>");

….......…...….....

Ejemplos de algunas etiquetas HTML.En Internet se pueden encontrar muchos portales con información sobre los elementos básicos del HTML, se detallan algunos de los usados en los ejemplos.

<HTML> … </HTML>

size:18pt" /></form><p>Las funciónes de incremento y borrado son llamadas por los botones.</p><hr Size=3 noshade/> <H4>by. Firtec Argentina </H4></center> </body></html>

GET( ) y POST( ).Cuando un usuario interactúa en un botón o formulario en una página web, los datos hay que enviarlos de alguna manera al servidor. Las dos formas de envío de datos posibles son el método POST o el método GET.

Normalmente POST está “escondido” y GET es mas visible. Cuando hacemos clic en una URL eso es GET y cuando se envía un formulario es POST. Tanto el método GET como POST son protocolo HTPP el cual envía al servidor una petición (request) y recibe una respuesta a dicha solicitud (response). El concepto GET es obtener información del servidor. Traer datos que están en el servidor, ya sea en un archivo o base de datos al cliente. Independientemente de que para eso tengamos que enviar un (request) o algún dato que será procesado para luego devolver la respuesta (response) que esperamos, como por ejemplo un identificador para obtener un estado de hardware.POST sin embargo es enviar información desde el cliente para que sea procesada. Cuando enviamos (request) datos a través de un formulario (un botón, etc), estos son procesados y luego se devuelve (response) alguna información.Ambos métodos solicitan una respuesta del servidor y ahí es donde parece que los conceptos son iguales ya que con ambos se podría lograr los mismos objetivos, sin embargo tienen sustanciales diferencias.GET es mucho mas rápido que POST y también mas simple pero solo puede enviar 512 Bytes.POST no tiene límites en la cantidad de bytes enviados y en general es mas robusto y seguro (las solicitudes GET se pueden ver en la barra de navegación, en este caso un comando para apagar un LED).

POST es útil para actualizar bases de datos en un servidor ya que los datos enviados no son mostrados y todo el intercambio de datos es transparente en el navegador.

Se define el inicio del cuerpo de la pagina con el marcador <body> y el color de fondo de la página.navegador.println(F("<body style=background:#F0FFFF>"))

Y el título de la página definido por le marcador h1 con su cierre /h1..navegador.println(F("<h1>Arduino Web Server</h1>"))

Se define un subtitulo, un texto con otro tamaño de letra definido por h2 y el cierre /h2.navegador.println(F("<h2>Mi primer web con

Arduino</h2>"))El marcador <br> indica un salto de línea, tres en el caso del ejemplo, luego se pinta una línea horizontal con marcador <hr> el número indica el grueso de la línea y sin sombra.

navegador.println(F("<hr Size=7 noshade/>"))Al pié de la pagina se imprime el cartel by. Frtec Argentina con un tamaño de letra mas pequeño usando elmarcador <h5>.

navegador.println(F("<H5>by. Firtec Argentina </H5>"))El marcador <center> centra toro el contenido en el centro de pagina, para quitar su efecto </center>, el marcador </body> indica el fin del cuerpo de pagina.

Control HTML de un LED .En el ejemplo anterior el sitio web no realizaba ninguna tarea solo mostrar un cartel al navegante. En este ejemplo vamos a interactuar con la electrónica de la placa Arduino encendiendo y apagandoun LED conectado en el pin 5.Vamos a generar el siguiente sitio web.

El objetivo del programa es que cada vez que el navegante oprima el botón en el sitio web el estado

*****************************************************************/void Pin_Status(EthernetClient navegador){ if (digitalRead(3)) { navegador.println(F("Estado del pin:<font color='red'><b> ALTO</b></font>")); } else { navegador.println(F("Estado del pin:<font color='green'><b> BAJO</b></font>")); }}

Leyendo el estado de un pin con AJAX.Viendo el funcionamiento del ejemplo anterior se hace evidente lo molesto que es tener que actualizar la página web cada vez que se quieran visualizar nuevos datos.El siguiente ejemplo no presenta grandes cambios en la parte gráfica, la estética de la web es la misma salvo que no hemos dado color al fondo y se ha cambiado el texto de la pestaña que muestra el navegador.

Sin embargo lo que si ha cambiado totalmente es su comportamiento, ya no es necesario cargar todala pagina web para actualizar los datos. Una función en Java Script sen encarga de manejar los datosque el servidor envía, en código la función Ajax está pintada en azul y su nombre es EstadoDelPin(), para marcar donde inicia un código Java Script primero se envían los marcadores que la definen.

navegador.println(F("<script>"));..navegador.println(F("</script>"));

Luego del marcador del inicio del código Ajax se declara el nombre de la función.

cl.println(F(" Voltios")); cl.println(F("</p>")); }

WEB y CheckBox LED.Vamos a crear una página web para el control de un LED con una casilla de verificación.

Este es otro ejemplo donde no es necesario código Ajax porque la acción del usuario sobre la propiapágina web desencadena la respuesta del servidor para actualizar los datos en el sitio web.Cuando el usuario marca la casilla de verificación esta acción es recogida por el servidor que contesta cambiando el cartel de “APAGADO” a “ENCENDIDO” y viceversa.La variable LED_status es encargada de controlar el encendido/apagado del LED conectado en el pin 5 y también es quien cambia el estado del cartel APAGADO/ENCENDIDO en la propia web.En este código se verifica el mensaje enviado por la casilla de verificación en la propia función que actualiza el estado del pin 5.

void ProcessCheckbox(EthernetClient cl){ if (HTTP_req.indexOf("LED5=5") > -1) { if (LED_status) { LED_status = 0; } else { LED_status = 1; } } if (LED_status) { digitalWrite(5, HIGH); cl.println(F("<input type=\"checkbox\" name=\"LED5\" value=\"5\" \

para ejemplo propuesto.Su funcionamiento es similar al sensor BMP280 visto en el ejemplo anterior. Este tipo de sensores pueden ser utilizados para calcular la altitud con gran precisión (barómetro), por lo que es un sensor muy utilizado en sistemas para Drones entregando medidas de altitud con una precisión de hasta 1m. Otras aplicaciones como monitoreo de clima, Internet de las Cosas, Domótica, Aire acondicionado, etc.Como se puede ver en la siguiente imagen, en los datos reportados a la web ahora también se muestra el porcentual de humedad.

La capacidad de este sensor para medir la humedad es la diferencia principal con el BMP280, también su costo siendo el BME280 un poco mas caro que su hermano el BMP280.

#include <SPI.h>#include <Ethernet.h>#include <Wire.h>

#include "SparkFunBME280.h"BME280 mySensorA; //Uses default I2C address 0x77BME280 mySensorB; //Uses I2C address 0x76 (jumper closed)

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};IPAddress ip(192, 168, 1, 200);EthernetServer server(80);

String HTTP_req; // Buffer para las solicitudes HTTP

cl.print(F("<?xml version = \"1.0\" ?>")); cl.print(F("<inputs>")); cl.print(F("<boton_1>")); if (digitalRead(7)) { cl.print(F("NO")); } else { cl.print(F("SI")); } cl.print(F("</boton_1>")); cl.print(F("<boton_2>")); if (digitalRead(8)) { cl.print(F("NO")); } else { cl.print(F("SI")); } cl.print(F("</boton_2>")); analog_val = analogRead(2); cl.print(F("<analog_1>")); cl.print(analog_val); cl.print(F("</analog_1>")); cl.print(F("</inputs>"));}

La página web es la siguiente.

El código completo para el Arduino es el siguiente.

#include <SPI.h>

Desde el año 2005, Guido van Rossum trabaja en Google creando aplicaciones con Python.

El intérprete de Python y sus bibliotecas son de acceso y uso libre para distintas plataformas, desde el sitio web de Python, https://www.python.org/ se pueden descargar y distribuirse libremente. El mismo sitio contiene también distribuciones y enlaces de muchos módulos libres de Python de terceros, programas y herramientas, y documentación adicional.El intérprete de Python puede extenderse fácilmente con nuevas funcionalidades, tipos de datos y bibliotecas para el desarrollo de interfaces gráficas e interactuar con dispositivos electrónicos.Lo interesante de trabajar con Python es que fácilmente podemos construir interfaces para visualizaren computadoras datos generados en Arduino. Trabajar con el puerto UART puede ser interesante pero trabajar con conexiones en un Socket UDP lo será mucho mas, con este tipo de conexiones la placa Arduino y la computadora pueden estar separados en cualquier lugar del planeta y vinculados por Internet. Python puede crear este tipo de conexiones con gran facilidad, nació en el mundo de Internet y se mueve en Internet como pez en elagua y por eso es tan interesante en la conectividad electrónica.

Trabajando con Python.Por su simpleza usaremos el Ninja IDE como interfaz de programación para correr los ejemplos propuestos en las siguientes páginas.

Aspecto del IDE Ninja.

Para el desarrollo de los ejemplos se han utilizado los siguiente programas todos provistos con el material de trabajo.

• Python v2.7.• Ninja IDE.• PySerial 2.7.• Py2exe.

# -*- coding: utf-8 -*-#!/usr/bin/env pythonfrom menu_frm import mi_menu # Importamos el menú de otro programafrom Tkinter import *

root = Tk( )for i in range(3): # Tres son los menú necesarios replicar frm = Frame( ) mnu = mi_menu(frm) mnu.config(bd=2, relief=RAISED) frm.pack(expand=YES, fill=BOTH) Label(frm, bg='black', height=5, width=15).pack(expand=YES, fill=BOTH)Button(root, text="Salir", command=root.quit).pack( )root.mainloop( )

El código escrito se reduce bastante al importar módulos ya construidos, además con un correcto funcionamiento ya que han sido probado en la aplicación desde donde se importa.Vemos otro ejemplo. Imaginemos que necesitamos ingresar una cadena de texto en una ventana que serviría para algún propósito determinado, por ejemplo configurar un puerto COM, establecer una IP, ajustar un termostato, etc. Vemos la siguiente imagen.

El programa abre una ventana con un campo de edición para escribir una cadena de texto que al apretar el botón “Mostrar Texto” el mismo se escribe en la pantalla de salida.

hacemos con RS-232 y microcontroladores) este tipo de socket es ideal para mover datos con nuestra electrónica.

Conectando Arduino por Socket UDP.Para graficar el funcionamiento de un Socket UDP vamos ver un ejemplo que envía el estado de un contador funcionando en Arduino y un socket lo conecta a una aplicación escrita en Python.En aplicaciones con microcontroladores es mas eficiente el uso de socket UDP por la velocidad y la simpleza de los datos enviados, generalmente solo una corta secuencia de binarios que corresponde a una medición o estado de un sensor.Del lado de la electrónica tenemos la placa Arduino y del lado del computador tenemos una aplicación Python. Con el siguiente código vamos a generar una venta como la que se aprecia en la imagen.

La conexión por socket es del tipo cliente (Arduino) servidor (El computador), por lo tanto lo primero que debe saber el cliente es donde está el servidor, cual es su dirección IP.La aplicación Python del ejemplo publica su propia IP para que sea informada al código del cliente en la placa Arduino. En la imagen de ejemplo vemos que el servidor se encuentra en la IP 192.168.1.200 y se conecta por el puerto 3000, estos datos deben ser informados al código Arduino para que pueda establecer la conexión.

# -*- coding: utf-8 -*-#!/usr/bin/env pythonimport socketimport sysimport selectimport errnoimport timefrom Tkinter import *from tkMessageBox import showinfo

class MyGui(Frame): def __init__(self, parent=None): Frame.__init__(self, parent)

def get_ip(): s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) try: # doesn't even have to be reachable s.connect(('10.255.255.255', 0))

makemenu(ventana)

#********* Label´s que despliegan la iformación y rótulos del script *********

label_Nombre_IP = Label(ventana, text="IP:", bg="beige", fg="blue", font=("Helvetica", 14))label_Nombre_IP.place(x=30, y=30)

label_IP = Label(ventana, bg="beige", fg="blue", font=("Helvetica", 14))label_IP.config(text = Dir_IP)label_IP.place(x=58, y=30)

label_Nombre_Puerto = Label(ventana, text="Puerto del Servidor:", bg="beige", fg="black", font=("Helvetica", 10))label_Nombre_Puerto.place(x=200, y=165)

label_Puerto = Label(ventana, bg="beige", fg="blue", font=("Helvetica", 10))label_Puerto.config(text = UDP_PORT)label_Puerto.place(x=320, y=165)

label_dato = Label(ventana, text="", bg="beige", fg="red", font=("Helvetica", 28))label_dato.place(x=270, y=95)

label_contador = Label(ventana, text="Contador:", bg="beige", fg="black", font=("Helvetica", 28))label_contador.place(x=90, y=95)

update_label()ventana.mainloop( )

Controlando un LED por Socket UDP.De la misma forma que podemos enviar información por un socket podemos recibir datos decodificarlos y actuar en consecuencia.En el ejemplo siguiente dos botones en Python son los encargados de controlar el estado de un LEDconectado en el pin 5 de la placa Arduino.

Recuerde es necesario que la placa Arduino se conecte a la IP y puerto del servidor de lo contrario la conexión nunca ocurrirá.El funcionamiento de este programa Python es muy sencillo, cuando se oprime el botón Apagar LED se envía el carácter “4” y cuando se oprime Encender LED se envía el carácter “5”. Estos

Serial.begin(9600); while (!Serial) ; if (Ethernet.hardwareStatus() == EthernetNoHardware) { Serial.println(F("ERROR en la placa Ethernet(")); while (true) { delay(1); } } if (Ethernet.linkStatus() == LinkOFF) { Serial.println(F("El cable de rer no esta conectado.")); } Udp.begin(udpPort);}

void loop() { conversion = analogRead(A0); conversion = (conversion *5.0)/1024; sprintf(buffer, "%d.%01d", (int)conversion, abs((int)(conversion*100)%100)); // Convierte todo a ASCII Udp.beginPacket(udpAddress, udpPort); // Conecta con el servidor Udp.print(buffer); // Envía el voltaje Udp.endPacket(); // Fin de transacción delay(100); // Espera 100 mS }

Que es MQTT.Cuando los enfoques informáticos clásicos (servidores web, socket de red, etc) resultan ser demasiado “pesados” por la cantidad de recursos necesarios para sostenerlos o resultan ser soluciones exageradas para resolver una simple comunicación de algunos Bytes, entran en juego protocolos como MQTT (Message Queue Telemetry Transport), ideado por IBM es un protocolo usado para la comunicación máquina a máquina (M2M). Es un protocolo específico para Internet de las cosas, orientado a la comunicación de sensores y dispositivos con una tasa de transferencia de datos baja, necesita muy poco ancho de banda y puede ser utilizado en la mayoría de los dispositivos con escasos recursos (CPU, RAM, etc). La arquitectura de MQTT sigue una topología de estrella, con un nodo central que hace de servidor o "broker" normalmente con una capacidad teórica de hasta 10000 clientes. El broker es el encargado de gestionar la red y de transmitir los mensajes, para mantener activo el canal, los clientes mandan periódicamente un paquete de datos y según el caso pueden esperar una confirmación del broker. La comunicación se basa en "topics" o temas, y para que un cliente tenga acceso a la información debe estar subscrito al tema sin importar cuantos clientes estén siguiendo el tema.Un cliente (cualquiera) puede publicar mensajes y los nodos, que deseen recibirlo deben estar subscrito a él. La comunicación puede ser de uno a uno, o de uno a muchos. Un "topic" se representa mediante una cadena y tiene una estructura jerárquica separada con '/'. Por ejemplo, "firtec/sensor_1/temperatura" o "firtec/sensor_2/ruido". De esta forma se pueden crear jerarquías de clientes que publican y reciben datos.

Por qué MQTT.MQTT es un protocolo abierto, sencillo, ligero y fácil de implantar.Es ideal para responder a las siguientes necesidades:

• Está especialmente adaptado para utilizar un ancho de banda mínimo • Es ideal para utilizar redes inalámbricas

librerías igual que en los casos anteriores.Para visualizar los datos hemos usado uno de los tantos brokers disponibles en el Play Store y el resultado es el siguiente.

Arduino tiene una biblioteca para MQTT, PubSubClient es la encargada del control de MQTT y el broker que usemos para suscribirnos a los datos maneje la versión 3.1.1 de MQTT (muchos solo manejan 3.1.0)El código completo para el manejo del sensor del sensor BMP280 y publicación de datos en la red MQTT es el siguiente.

#include <SPI.h>#include <Ethernet.h>#include <PubSubClient.h> // Biblioteca MQTT

#include "SPI.h" #include <Adafruit_Sensor.h>#include "Adafruit_BMP280.h"

Adafruit_BMP280 bmp;

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};

// IP del servidor MQTTconst char* mqtt_server = "192.168.1.15";

#define TEMP_TOPIC "firtec/temp"#define PRES_TOPIC "firtec/pre"

float p; float t;

long lastMsg = 0;char msg[20];boolean bandera = false;