Vous êtes sur la page 1sur 35

Programación de Microcontroladores

Jairo Miguel Vergara Avila


Programar microcontroladores significa:

Conocer y aprender a usar todos sus


recursos, para luego aplicarlos en el
diseño deseado.

Es un proceso continuo, sistemático y


que demanda mucha paciencia.
El curso de microcontroladores abarca tres áreas:
1. Conocer el microcontrolador.
Un microcontrolador es un circuito integrado genérico cuyas partes debemos
configurar para que funcionen según los requerimientos de nuestro diseño.
Obviamente no podríamos programar lo que no conocemos.

2. Conocer los periféricos externos.


Un microcontrolador no sería muy útil si no tiene nada qué controlar. Muchos
dispositivos a controlar o mediante los cuales se va a controlar son comunes
en la electrónica analógica y digital, como transistores, relés, diodos LED,
registros de desplazamiento, displays, LCDs, motores de pasos, sensores de
temperatura análogos y digitales, etc.

3. Conocer un lenguaje de programación.


Un microcontrolador para que funcione hay que programarlo por lo tanto
requiere del conocimiento de un lenguaje de programación.
Es raro que una persona trate de conocer un microcontrolador al mismo
tiempo que va aprendiendo el lenguaje.
Arquitectura básica de un computador

El término proviene de la computadora Harvard Mark I basada en relés, que almacenaba las
instrucciones sobre cintas perforadas (de 24 bits de ancho) y los datos en interruptores
electromecánicos

Arquitectura basada en la descrita en 1945 por el matemático y físico John von Neumann
en un informe de la computadora EDVAC.
Microcontroladores con Instrucciones RISC o CISC
RISC Significa Reduced Instruction Set Computer. Es una
característica propia de los microcontroladores actuales como los
AVR. Estos microcontroladores cuentan con instrucciones sencillas y
en un número mínimo. Sin embargo, cuando se desarrollan
proyectos mucho más complejos, el uso del lenguaje ensamblador
se torna cada vez más engorroso.

CISC Significa Complex Instruction Set Computer. Es complejo


porque consta de muchas instrucciones, complicadas y difíciles de
recordar a la hora de programar en lenguaje ensamblador. Además,
al crecer el número de instrucciones también crecerán los códigos
de las instrucciones
¿Qué diferencias hay entre un Microcontrolador y un Microprocesador?
Principalmente, la capacidad de funcionalidad autónoma del μC frente al microprocesador
¿Qué es un sistema embebido?
Es un sistema electrónico que está pensado para realizar
determinadas funciones específicas en servicio de un sistema electrónico
mayor del que forma parte, generalmente en formato de tarjeta o placa de
circuito impreso. El Arduino Mega es un buen ejemplo de sistema embebido
basado en un microcontrolador, Atmega 2560 de 8-bits, al que se añaden
otros Circuitos Integrados que agregan funcionalidades adicionales inicialmente
no integradas en el microcontrolador.
ESP32
Una potencia y rendimiento de IoT diferente
El ESP32 es una serie de Soc's (System on Chip), desarrollado por Espressif
Systems. Contiene un microprocesador Tensilica Xtensa LX6, WiFi y
Bluetooth integrado.

Desarrollada para un bajo consumo y bajo costo, y es una opción muy


interesante para los fabricantes o desarrolladores de productos.

Se puede encontrar en algunas variaciones, desde el chip que pasa por los
módulos y las placas de desarrollo. El uso de placas de desarrollo tiende a
ser la mejor opción.

También existe la facilidad de usar convertidores USB-serie en estas placas


de desarrollo que facilitan mucho el proceso de comunicación con ESP32.

Las placas de desarrollo también se pueden encontrar en una amplia


gama de modelos, algunos muy similares y otros con instalaciones muy
específicas
Algunos ejemplos de placas que son compatibles
Arduino vs ESP32
Diagramas de bloques funcionales del Espressif ESP32

La capacidad criptográfica permite que este módulo se convierta en el rey de IoT (Internet of thing).
Periféricos ESP32
El chip ESP32 viene con 48 pines con múltiples funciones. No todos los pines están
expuestos en todas las placas de desarrollo ESP32, y algunos pines no se pueden usar.

 18 canales de conversión de analógico a digital (ADC)


 3 interfaces SPI
 3 interfaces UART
 2 interfaces I2C
 16 canales de salida PWM
 2 convertidores de digital a analógico (DAC)
 2 interfaces I2S
 10 GPIOs de detección capacitiva
Convertidor analógico a digital (ADC)
El ESP32 tiene 18 canales de entrada de12 bits.
1. ADC1_CH0 (GPIO 36)
2. ADC1_CH1 (GPIO 37)
3. ADC1_CH2 (GPIO 38)
4. ADC1_CH3 (GPIO 39)
5. ADC1_CH4 (GPIO 32)
6. ADC1_CH5 (GPIO 33)
7. ADC1_CH6 (GPIO 34)
8. ADC1_CH7 (GPIO 35)
9. ADC2_CH0 (GPIO 4)
10. ADC2_CH1 (GPIO 0)
11. ADC2_CH2 (GPIO 2)
12. ADC2_CH3 (GPIO 15)
13. ADC2_CH4 (GPIO 13)
14. ADC2_CH5 (GPIO 12)
15. ADC2_CH6 (GPIO 14)
16. ADC2_CH7 (GPIO 27)
17. ADC2_CH8 (GPIO 25)
18. ADC2_CH9 (GPIO 26)

Los canales de entrada ADC tienen una resolución de 12 bits. Esto significa que puede obtener lecturas
analógicas que van de 0 a 4095, en las que 0 corresponde a 0V y 4095 a 3.3V. También tiene la capacidad de
establecer la resolución de sus canales en el código, así como el rango de ADC.
GPIOs capacitivos táctiles
El ESP32 tiene 10 sensores táctiles internos capacitivos. Estos pueden
detectar variaciones en cualquier cosa que tenga una carga eléctrica, como
la piel humana.

Esos sensores táctiles internos están conectados a estos GPIOs:


•T0 (GPIO 4)
•T1 (GPIO 0)
•T2 (GPIO 2)
•T3 (GPIO 15)
•T4 (GPIO 13)
•T5 (GPIO 12)
•T6 (GPIO 14)
•T7 (GPIO 27)
•T8 (GPIO 33)
•T9 (GPIO 32)
Convertidor digital a analógico (DAC)
Hay 2 canales DAC de 8 bits en el ESP32 para convertir señales digitales en salidas de señal de
voltaje analógicas. Estos son los canales DAC:

• DAC1 (GPIO25)
• DAC2 (GPIO26)

Pines de solo entradas


Los GPIOs 34 a 39 son GPIs - solo pines de entrada. Estos pines no tienen pull-ups internos o
resistencias de pull-down. No se pueden usar como salidas, así que use estos pines solo como
entradas:

• GPIO 34
• GPIO 35
• GPIO 36
• GPIO 37
• GPIO 38
• GPIO 39
PWM

El controlador ESP32 LED PWM tiene 16 canales independientes que pueden


configurarse para generar señales PWM con diferentes propiedades.
Todos los pines que pueden actuar como salidas pueden usarse como pines
PWM, excepto los GPIO 34 a 39 no pueden generar PWM.

Para establecer una señal PWM, necesita definir estos parámetros en el código:

• Frecuencia de la señal;
• Ciclo de trabajo;
• Canal PWM;
• GPIO donde quieres que salga la señal.
I2C
Cuando use el ESP32 con el IDE de Arduino, debe usar los pines por defecto de
ESP32 I2C (compatibles con la biblioteca de Wire):

•GPIO 21 (SDA)
•GPIO 22 (SCL)

SPI
Por defecto, la asignación de pines para SPI es:

SPI MOSI MISO CLK CS

VSPI GPIO 23 GPIO 19 GPIO 18 GPIO 5

HSPI GPIO 13 GPIO 12 GPIO 14 GPIO 15


Programar el ESP32 con IDE de Arduino
Instalar la placa ESP32
Para instalar la placa ESP32
en su IDE de Arduino, siga las
siguientes instrucciones:

1) Abra la ventana de
preferencias desde el IDE
de Arduino. Ir a Archivo
Preferencias.

2) Ingrese
https://dl.espressif.com/dl/p
ackage_esp32_index.json

3) Luego, haga clic en el


botón “Ok".
Open boards manager. Go to Tools  Search for ESP32 and press install button for the
Board Boards Manager… “ESP32 by Espressif Systems“:
Probando la instalación
ESTRUCTURA BÁSICA DEL PROGRAMA (Arduino)
Se compone de tres secciones principales:

1. Sección de declaración de variables: Ubicadas al inicio.

2. Sección llamada “void setup”:

Delimitada por llaves de apertura y cierre. Es la primera función a ejecutar en el programa. Se ejecutan una
única vez en el momento de encender o resetear la placa ARDUINO.
Se usa para inicializar:
 Los modos de trabajo de los pins E/S (PinMode)
 Comunicación en serie

3. Sección llamada “void loop()”:


Delimitada por llaves de apertura y cierre; incluye el código que se ejecuta continuamente leyendo
entradas, activando salidas, etc. Esta función es el núcleo de todos los programas ARDUINO y hace la
mayor parte del trabajo. Se ejecutan justo después de la sección “void setup()” infinitas veces hasta que la
placa se apague (o se resetee).
ESTRUCTURA DE CONTROL:
BLOQUES CONDICIONALES

1. Bloque “if” , “if/else” y “If/else if” :


Las sentencias if comprueban si cierta condición ha sido alcanzada y ejecutan todas las
sentencias dentro de las llaves si la declaración es cierta. Si es falsa el programa ignora la
sentencia.

Las sentencias if/else permiten un mayor control sobre el flujo del código que la declaración
if básica, por permitir agrupar múltiples comprobaciones. “Si esto no se cumple haz esto otro”.

Las sentencias if/else if pueden realizar múltiples comprobaciones en una misma estructura
de condiciones. Cada comprobación procederá a la siguiente sólo cuando su propio resultado
sea FALSE. Cuando el resultado sea TRUE, su bloque de código contenido, será ejecutado, y el
programa esquivará las siguientes comprobaciones hasta el final de la estructura de
comprobaciones.
int numero;
//*******************************************************
void setup(){
Serial.begin(9600);
}
//******************************************************
void loop(){
if (Serial.available() > 0) {
numero=Serial.parseInt();
if (numero == 23){
Serial.println("Numero es igual a 23");
}
else if (numero < 23) {
Serial.println("Numero es menor que 23");
}
else {
Serial.println("Numero es mayor que 23");
}
}
}
//*******************************************************
Estructura de programa en el IDE Arduino
const int buttonPin = 4; // GPIO del pushbutton
const int ledPin = 16; // GPIO LED
int buttonState = 0; // variable para almacenar el estado del pushbutton
//*************************************************
void setup() {
pinMode(buttonPin, INPUT);
pinMode(ledPin, OUTPUT);
}
//*********************************************
void loop() {
buttonState = digitalRead(buttonPin);
if (buttonState == HIGH) {
digitalWrite(ledPin, HIGH);
}
else {
digitalWrite(ledPin, LOW);
}
}

GPIO (General Purpose Input/Output). Entrada/Salida de Propósito General, es un pin genérico en un chip, cuyo comportamiento
(incluyendo si es un pin de entrada o salida) se puede controlar (programar) por el usuario en tiempo de ejecución.