Electrónica y programación para Microcontroladores.

Cursos técnicos para electrónica programable

Mapa
Estamos en

Urquiza 1695, Entre Ríos, Gualeguaychú

Email
Contactanos

consultas@firteconline.com.ar

Arduino

El eje central del libro es la programación en C para PIC y para la arquitectura de ARM con el compilador MikroC Pro de MikroElektronika.

Compilador largamente probado y sin duda una de las herramientas que junto con los compiladores oficiales de las correspondientes marcas generan código confiable y muy eficiente en el uso de los recursos de los microcontroladores.
MikroC ofrece gran cantidad 
de drivers contenidos en una extensa biblioteca que hacen el trabajo del programador mucho más sencillo acortando los tiempos de desarrollo y depuración de código.
Para la mayoría de los programadores de microcontroladores incorporar a su esquema de trabajo la arquitectura de ARM puede ser un paso complejo debido a las grandes diferencias que existen con otras arquitecturas como PIC, Atmel, etc.
Pensando en esto se ha desarrollado el presente trabajo que pretende hacer más fácil 
la programación para ARM en 32 bits y PIC en 8 bits.
También usaremos Visual TFT, un software creado por MikroElektronika para el desarrollo de interfaces gráficas con pantallas TFT que genera código para ser compilado directamente por sus compiladores, esto facilita mucho el diseño de interfaces con pantallas táctiles.
Si bien considero este trabajo como introductorio a la programación en el lenguaje C, encontrará una gran cantidad de ejemplos, rutinas de programación, librerías y textos explicativos sobre una diversidad de temas que pueden ser de utilidad no solo en el proceso de entender cada una de las arquitecturas, sino también para aplicar en desarrollos electrónicos en general.

Todos los ejemplos propuestos están pensados para su realización práctica con electrónica real, esto no significa que no pueda usar simuladores para corroborar su funcionamiento sin embargo la experiencia nos enseña que no siempre los resultados obtenidos en el simulador coinciden con el comportamiento en el terreno físico.
Recuerde que la simulación se ejecuta en un entorno ideal (la memoria del computador), sin ruidos eléctricos ni interferencias del mundo real.

Si le interesa adquirir este libro en formato digital puede consultarnos en Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo. para costos y descarga del libro
El contenido de este libro puede ser considerado como un verdadero curso sobre el tema por lo que puede contratar la asistencia On-Line del autor para consultas o guías que lo ayudarán al correcto entendimiento de los temas tratados.

(No olvide indicar desde donde nos contacta).

 


 

Para quienes estén pensando en saltar al mundo de ARM en 32 bits está disponible en Argentina un libro publicado por Alfa Omega que trata la programación en C con el entorno Keil.
También se trata la programación para ESP32 y distintos ejemplos de uso para IOT.
Este libro lo distribuye Alfa Omega y distintas editoriales del país. 

 

IMPORTANTE: Nosotros no comercializamos el libro, solo se vende a través de las editoriales.

 

Nextion es probablemente una de las mejores opciones para crear proyectos con electrónica, podemos hacerlas funcionar con cualquier microcontrolador que disponga de un puerto serial. Para crear una interfaz gráfica en una pantalla Nextion usaremos el editor Nextion, un software provisto por el propio fabricante que hace la tarea del diseño realmente simple.
Una vez que tenemos todo los elementos de la interfaz desplegados en la pantalla se envía la programación a la propia pantalla usando una simple conexión serial.
Este editor de Nextion es la mejor solución, en realidad casi la única para crear proyectos con estas pantallas inteligentes.
Lamentablemente solo existe en versión para Windows que se descarga a través del enlace oficial de Nextion.
Proponemos diseñar la siguiente interfaz gráfica.
La pantalla dispone solamente de 4 pines. Dos de ellos son de alimentación (cable rojo y negro) y los otros dos son de recepción para el envío de datos por la conexión serial, recepción cable amarillo y transmisión cable azul, para conectar la pantalla a Raspberry PI estos cables se deben conectan cruzados TX con el cable amarillo y RX con el cable azul. 
La pantalla se programa por medio de una conexión serial desde el propio editor Nextion, para programar la pantalla se debe desconectar de Raspberry y conectarla al computador mediante un adaptador USB-RS232.
Cuando queremos mostrar un dato en la pantalla solo “apuntamos” al componente de la pantalla donde queremos enviar los datos y enviamos la información que se me mostrará donde se indicó, en este ejemplo hay una ventana donde se muestran datos de conversión que se identifica como n0 y que tiene una propiedad que se llama val. Solo debemos apuntar al objeto y su propiedad para mostrar los datos.

Sin embargo los mensajes están estructurados en un protocolo propio que se debe conocer para poder dialogar con la pantalla, los mensajes tienen el siguiente formato 65000501FFFFFF donde el número 65 indica que no hay errores, el siguiente número es la página (una interfaz gráfica puede tener varias páginas), luego tenemos el ID del componente que ha enviado el mensaje, luego el evento y por último tres bytes con FF que son los indicativos de fin de trama.
Por ejemplo imagine que quiere enviar datos al panel n0 desde Python escribimos lo siguiente:

puerto.write(b"n0.val=" + str(dato).encode() + b"\xFF\xFF\xFF")

El indicativo b dice que estamos enviando una cadena de bytes, en dato está el valor a mostrar y finalmente los tres bytes de EOF.
Si quiero recibir un evento desde la pantalla tengo que analizar la trama para saber desde cual página, cual elemento y que acción me esta llegando.
Como en este ejemplo solo tenemos una página y un solo botón las cosas son bastantes simples solo basta el siguiente código para saber cuando el botón envía mensajes y encender un LED según el caso.

datos_nextion = binascii.hexlify(puerto.readline())
mensaje = str(datos_nextion) 
for indice in range(len(mensaje)): 
          if indice > 3:
                        if mensaje[7] == "3" and bandera == 0: 
                                    bandera = 1 
                                    GPIO.output(16, 0) 
                       else:
                                    GPIO.output(16, 1) 
                                    bandera = 0 

El código completo para leer datos de un conversor MCP3201 y mostrarlos en un panel, también se detecta la acción de un botón para cambiar el estado de un LED conectado a un pin del puerto Raspberry.

3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import binascii
import time
import spidev
from serial import Serial
import RPi.GPIO as GPIO # Modulo para gestionar los pines GPIO
GPIO.setwarnings(False) # Ignora las advertencias
GPIO.setmode(GPIO.BCM) 	# Los pines serán referidos como Broadcom
spi = spidev.SpiDev()
spi.open(0, 0)
spi.max_speed_hz = 7629
time.sleep(1)
GPIO.setup(16, GPIO.OUT)# Pin 16 será salida
GPIO.output(16, 1)
 
puerto = Serial("/dev/ttyS0", baudrate=9600, timeout=0.2)
if puerto.isOpen() == False:
    puerto.open()
 
puerto.flushInput()
puerto.flushOutput()
bandera = 0
 
 
def Conversor():  # Lee el conversor MCP3201
    
    adc = spi.xfer2([0, 0])
    hi = (adc[0] & 0x1F);
    low = (adc[1] & 0xFe);
    dato = (hi << 8) | low;
    puerto.write(b"n0.val=" + str(dato).encode() + b"\xFF\xFF\xFF")
    
while 1:
    Conversor()
    try:   # Recibe los datos desde la pantalla Nextion     
        datos_nextion = binascii.hexlify(puerto.readline()) 
        mensaje = str(datos_nextion)        # Procesa los datos recibidos
        for indice in range(len(mensaje)):  # Recorre los bytes del mensaje
            if indice > 3:                  # Pantalla envió un mensaje?
                if mensaje[7] == "3" and bandera == 0:  # Mensaje del objeto?
                    bandera = 1             # Avisa que el LED está apagado
                    GPIO.output(16, 0)      # Pin 16 pasa a nivel bajo
                else:
                        GPIO.output(16, 1)  # Pin 16 pasa a nivel alto
                        bandera = 0         # Avisa que el LED está encendido
 
        puerto.flushInput()
        puerto.flushOutput()
        
    except (KeyboardInterrupt, SystemExit):
        puerto.close()
        spi.close()
        GPIO.cleanup()
        raise

En este ejemplo no interesa la página puesto sabemos que es 0 y el botón tiene el ID 3 (podrías ser cualquier número) que también sabemos viene en el casillero 7 de acuerdo a como Python 3 ensambla la trama de recepción.
El resultado final de la aplicación en funcionamiento es el siguiente:

(Todo sobre el manejo de estas pantallas lo encontrará en nuestro nuevo curso para Raspberry PI).

Los robots por software pueden resultar muy útiles a la hora del desarrollo de sistemas de control, mediante el uso de un Bot vamos a iniciar un chat por Telegram con una placa electrónica para leer datos de un sensor BME280 y controlar el estado de un pin.
Telegram fué anunciada oficialmente en el 2013, está enfocada a la mensajería instantánea, el envío de varios archivos y la comunicación en masa, la aplicación se parece mucho a WhatsApp con algunas funciones extras.

La idea es conectar ESP32 programado con el IDE de Arduino para que envíe mensajes de chat a Telegram, también se puede hacer lo mismo para WhatsApp sin embargo debido a las bibliotecas disponibles en este momento, es mas simple conectar con Telegram.
Para ensamblar el proyecto vamos a necesitar algunas bibliotecas siendo necesario que la versión de ArduinoJson encargada de manejar los textos de los mensajes enviados hacia y desde Telegram sea versión 5.x ya que versiones superiores no funcionan con la biblioteca de Arduino para Telegram.   

  • ArduinoJson-5.x.x.
  • Universal-Arduino-Telegram-Bot.
  • Bibliotecas para programar ESP32.

NOTA:
Para agregar las bibliotecas necesarias para el manejo de ESP32 con Arduino vamos a Archivos > Preferencias > Gestor de URLs Adiciones de Tarjetas y agregamos la siguiente línea: https://dl.espressif.com/dl/package_esp32_index.json