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

Nuevo curso On-Line 

Totalmente práctico trabajando con Arduino y como se puede ver en el temario, el curso abarca una gran cantidad de tópicos desarrollados de manera clara y directa, puede verificar esto descargando un ejemplo de clase semanal. También podrá descargar algunos programas usados a lo largo del curso.
El objetivo de este curso es iniciar con los principios básicos de electrónica digital para ir lentamente escalando conocimientos hasta llegar a la programación de Arduino.
El curso está dividido en una serie de clases que se envían semanalmente con una clase On-Line por semana para tratar los temas mas relevantes.

En la programación de Arduino iniciamos con ejemplos simples y lentamente entrar en la programación avanzada de sistemas complejos aplicables a robótica, domótica, mecatrónica, seguridad, y sistemas electrónicos en general.

En este curso aprendemos a usar sockets de red, enviar señales de control o recibir datos por la red desde y hacia cualquier parte del mundo es sencillo usando sockets. De la misma forma que enviamos comandos por la UART (RS-232) podemos controlar los pines del Arduino solo que este caso lo hacemos por Internet.

En el transcurso del curso se desarrollan varios sistema de control web que fácilmente se pueden reformar y/o adaptar a cualquier necesidad.
Si necesitamos desplegar información de manera gráfica con presentaciones intuitivas y fácil de entender podemos mostrar los datos en una página web embebida en la propia placa Arduino.
Con esto ahorramos el uso de una pantalla gráfica propia (el usuario usa su propio teléfono o dispositivo móvil) y además el sistema podrá ser accedido desde cualquier lugar no siendo necesario estar frente al equipo para ver una pantalla estática.

Mas información de este curso se puede solicitar a Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo..

El grado de dificultad de este curso ha sido calificado como medio.

Dinámica del curso.
Modalidad: Distancia (En cualquier momento del año). 
También puede ser interesante la lectura del siguiente libro disponible en Amazon.


 

Nuevo curso On-Line.
El principal objetivo de este curso es servir de instructivo para el desarrollo de sistemas electrónicos simples con conectividad TCP-IP usando el controlador ESP32.
Se trataran aspectos prácticos de la programación de servidores web y sitios web para el control del hardware de un controlador ESP32, no es la idea entrar en el funcionamiento electrónico del ESP32 y en el detalle funcional de cada uno de sus módulos.

Pretendemos hacer uso del ESP32 de la misma forma que alguien usa una placa Arduino con un escaso o nulo conocimiento de electrónica encapsulando toda la complejidad operativa en funciones y librerías muchas de ellas de uso común en Arduino.
 ESP32 por si solo puede realizar múltiples tareas, mediciones, comunicaciones, control electrónico, PWM para el control de luminarias LED, controlar motores entre otras muchas funcionalidades disponibles.
Su procesador de doble núcleo permite hacer infinidad de tareas por si mismo, pero también permite servir de puente entre electrónica de bajos recursos y el despliegue web necesario en cualquier aplicación de control moderno gracias a su conectividad WiFi.
Con esta tecnología podemos empezar a cambiar algunas costumbres de trabajo y en lugar de colocar una pantalla gráfica podemos hacer que el usuario utilice su propio teléfono o tablet como pantalla y desde cualquier lugar del mundo interactúe con la electrónica en su casa.

Aprenderemos lo necesario de JavaScript para poder diseñar funciones Ajax embebidas en el HTML, también a decodificar mensajes HTPP y así realizar diálogos entre un sitio web y el servidor.
También aprenderemos lo necesario de Pyhton para poder entender el funcionamiento de un Socket de red y establecer comunicación por los Socket.
Cuando no es necesario un servidor web, con un Socket podemos enviar datos igual que el viejo RS-232 solo que ahora el receptor puede estar en cualquier lugar del mundo!
Conoceremos  MQTT y la magia de conectar electrónica entre si y subir datos a la nube.

Para trabajar usaremos mayormente el IDE de Arduino que nos permite acceso a todas sus librerías y estructuras de programación.
También veremos el entorno oficial ESP-IDF para el ESP32.
El dispositivo también tiene conectividad Bluetooth en su versión de baja energía, veremos ejemplos de uso sin embargo el foco del presente trabajo es conectividad web y Socket y si bien estamos tomando como ejemplo ESP32, los conceptos expuestos en este curso son aplicables a cualquier arquitectura.
 

Que necesito saber para este curso?

Tener conocimientos de electrónica digital y algo de programación en lenguaje C .

Cual es la dinámica para este curso?

  • Envío semanal de clases y prácticos, una clase semanal On-Line para tratar los temas enviados.
  • Consultas permanentes mediante WS, Telegram, Skype o E-mail.
  • Este curso se puede certificar cumpliendo con un trabajo práctico, el único de carácter obligatorio.
  • Este trabajo para la certificación se envía al finalizar la cursada y el alumno tiene treinta (30) días para presentarlo.

Como pago el curso?

Se puede pagar el costo del curso mediante Paypal, Mercado Pago, Transferencia bancaria. (Mas información sobre los costos puede solicitarla enviando un E-mail).

Que herramientas necesito para este nuevo curso?

  • Una placa con el controlador ESP32.
  • Una computadora.
  • Compilador ESP-IDF (Software de descarga libre).
  • IDE Arduino (Software de descarga libre).

Cual es el nivel de profundidad de los temas tratados?

Para tener una idea descargue algunas páginas del manual de estudio.

Como se dicta este curso?

Modalidad distancia y en cualquier momento del año.

El curso tiene ejemplos?

Si, los ejemplos se descargan con el curso. Todos completos y listos para ser compilados. Estos ejemplos se pueden reformar y/o adaptar a cualquier necesidad o proyecto personal.
Puede descargar el temario de este curso.

Información sobre costos y modalidad de cursada se puede solicitar a Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo. . (No olvide indicar desde donde nos escribe)

También puede ser de interés el siguiente libro disponible en Amazon.


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

Estuvimos probando el funcionamiento del sensor MLX90614 montado sobre un escudo para mikrobus en un Arduino Uno. 
También conectamos una pantalla OLED de 96 x 39 pixeles en el mismo escudo, el funcionamiento resulta muy interesante para 
construir sistemas de medición, sistemas de alarma, etc.

 El código completo para Arduino es el siguiente. 

1
2
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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
/********************************************************************************
   Descripción: Ejemplo para el sensor de temperatura  por infrarrojos MLX90614.
                El ejemplo también usa una pantalla OLED de 96 x 39 pixeles con
                un controlador I2C SSD1306.
                
   Placa Arduino: UNO
   Arduino IDE: 1.8.11
   www.firtec.com.ar
**********************************************************************************/
#include <SPI.h>
#include "oled.h"
#include <Wire.h>
#include <Adafruit_MLX90614.h>
 
#define OLED_CS         10
#define OLED_DC         6
#define OLED_RST        A3
 
Adafruit_MLX90614 mlx = Adafruit_MLX90614();
 
const char cartel_1 [] = {"TEMP."};
const char cartel_3 [] = {"AMBIENTE:"};
const char cartel_2 [] = {"OBJETO:"};
char buffer[10]=" ";
uint8_t _x, _y;
uint8_t _sx=1, _sy=1; 
 
 
void setup() {  
  SPI.begin();
  pinMode(OLED_CS, OUTPUT);
  pinMode(OLED_DC, OUTPUT);
  pinMode(OLED_RST, OUTPUT);
  OLED_Initialize();        // Configuración de la pantalla OLED
  delay(100);
  OLED_Clear();             // Borrado inicial de pantalla
  OLED_SetScale(1, 1);      // Letras en tamaño pequeño
  OLED_Puts(0, 1, cartel_2);// Muestras carteles iniciales
  OLED_Puts(0, 4, cartel_3);
  mlx.begin();              // Inicia el sensor MLX90614
}
 
void loop() {
  dtostrf(mlx.readObjectTempC(), 2, 1, buffer); // Temperatura del objeto pasada a ASCII
  OLED_SetScale(1, 3);                          // Cambia tamaño de letras
  OLED_Puts(60, 0, buffer);                     // Muestra la temperatura del objeto frente al sensor.
  OLED_SetScale(1, 1);                          // Cambia a letra pequeña
  dtostrf(mlx.readAmbientTempC(), 2, 1, buffer);// Lee y convierte a ASCII la temperatura ambiente
  OLED_Puts(65, 4, buffer);                     // Muestra la temperatura
  delay(500);
 
}
 
//------------ Funciones para la pantallas OLED -----------------
 
void OLED_Command(uint8_t temp){
  SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0));
  digitalWrite(OLED_CS,LOW);
  digitalWrite(OLED_DC,LOW);
  SPI.transfer(temp);
  digitalWrite(OLED_CS,HIGH);
  SPI.endTransaction();
}
 
void OLED_Data(uint8_t temp){
  SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0));
  digitalWrite(OLED_CS,LOW);
  digitalWrite(OLED_DC,HIGH);
  SPI.transfer(temp);
  digitalWrite(OLED_CS,HIGH);
  SPI.endTransaction();
}
 
void OLED_Initialize(void)
{
    digitalWrite(OLED_RST,LOW);
    delay(1000);
    digitalWrite(OLED_RST,HIGH);
    delay(1000);
    OLED_Command(SSD1306_DISPLAYOFF);             //0xAE  Set OLED Display Off
    OLED_Command(SSD1306_SETDISPLAYCLOCKDIV);     //0xD5  Set Display Clock Divide Ratio/Oscillator Frequency
    OLED_Command(0x80);
    OLED_Command(SSD1306_SETMULTIPLEX);           //0xA8  Set Multiplex Ratio
    OLED_Command(39);
 
    OLED_Command(SSD1306_SETSEGMENTREMAP);        //0xA1  Set Segment Remap Inv
    OLED_Command(SSD1306_COMSCANDEC);             //0xC8  Set COM Output Scan Inv
 
    OLED_Command(SSD1306_SETDISPLAYOFFSET);       //0xD3  Set Display Offset
    OLED_Command(0x00);
    OLED_Command(SSD1306_CHARGEPUMP);             //0x8D  Set Charge Pump
    OLED_Command(0x14);                           //0x14  Enable Charge Pump
    OLED_Command(SSD1306_SETSTARTLINE);           //0x40  Set Display Start Line
    OLED_Command(SSD1306_SETCOMPINS);             //0xDA  Set COM Pins Hardware Configuration
    OLED_Command(0x12);
    OLED_Command(SSD1306_SETCONTRAST);            //0x81   Set Contrast Control
    OLED_Command(0xAF);
    OLED_Command(SSD1306_SETPRECHARGE);           //0xD9   Set Pre-Charge Period
    OLED_Command(0x25);
    OLED_Command(SSD1306_SETVCOMDETECT);          //0xDB   Set VCOMH Deselect Level
    OLED_Command(0x20);
    OLED_Command(SSD1306_DISPLAYALLON_RESUME);    //0xA4   Set Entire Display On/Off
    OLED_Command(SSD1306_NORMALDISPLAY);          //0xA6   Set Normal/Inverse Display
    OLED_Command(SSD1306_DISPLAYON);              //0xAF   Set OLED Display On
} 
 
void OLED_SetRow(uint8_t add)
{
    add = 0xB0 | add;
    OLED_Command(add);
}
 
void OLED_SetColumn(uint8_t add)
{
    add += 32;
    OLED_Command((SSD1306_SETHIGHCOLUMN | (add >> 4))); 
    OLED_Command((0x0f & add));                         
}
 
void OLED_PutPicture(const uint8_t *pic)
{
    unsigned char i,j;
    for(i=0; i<5; i++) 
    {
        OLED_SetRow(i);
        OLED_SetColumn(0);
        for(j=0; j<96; j++) 
        {
            OLED_Data(*pic++);
        }
    }
}
 
void OLED_SetContrast(uint8_t temp)
{
    OLED_Command(SSD1306_SETCONTRAST);
    OLED_Command(temp);                  
}
 
void OLED_SetScale(uint8_t sx, uint8_t sy){
    _sx = sx; _sy = sy;
}
 
void OLED_Clear(void)
{
    unsigned char i,j;
    for(i=0; i<5; i++) 
    {
        OLED_SetRow(i);
        OLED_SetColumn(0);
        for(j=0; j<96; j++)  OLED_Data(0);
    }
    _x = 0; _y = 0;
    OLED_SetRow(0);
    OLED_SetColumn(0);
}
 
void OLED_Putchar(char ch)
{
    uint8_t i, j, k, byte;
    const uint8_t *f = &font[(ch-' ')*5];
    const uint8_t mask[]={1, 3, 7, 0xf };
 
    for(i=0; i<6; i++) {
        uint32_t word;
        byte = *f++ << 1;
        if (i==5) byte = 0;
        for(j=0; j<8; j++) { 
            word <<= _sy;
            if (byte & 0x80) word |= mask[_sy-1];
            byte <<= 1;
        }
        for(j=0; j<_sy; j++){ 
            OLED_SetRow(_y+j) ;
            OLED_SetColumn(_x+i*_sx);
            for(k=0; k<_sx; k++){ 
                OLED_Data(word);
            }
            word >>= 8;
        }
    }
 
    _x+= 6 * _sx;
    if (_x >= OLED_WIDTH) { 
        _x = 0; OLED_SetColumn(0);
        _y += _sy;
        if (_y >= 5-_sy) { 
            _y = 0;
        }
        OLED_SetRow(_y);
    }
}
 
void OLED_Puts(char x, char y, char *s)
{
    _y = y; _x = x;
    OLED_SetRow(_y);
    OLED_SetColumn(_x);
    while(*s) {
        OLED_Putchar(*s++);
        _x++;
    }
}

Los códigos mas la librería para Arduino se puede descargar desde este link.