y ESP32 - FirtecOnlinefirteconline.com.ar/XC8/demo_XC8.pdf · Los operadores tienen cierto orden de...

Cualquier soft que funciona en Win7 funcionará en la máquina virtual, Pickit, MPLAB, etc.

El sistema que se ve en las capturas es Debian en su última versión corriendo Virtual Box de Oracle.La computadora es una notebook con 4GB de RAM asignando al sistema virtual un espacio de 40GB. Para un uso ágil del sistema el procesador debería ser al menos un I3 y 4GB de RAM. Con este Hardware podemos quitarle a Windows la conexión a internet y usar la computadora de manera normal con Debian (Navegar, Mail's, Oficina, etc) y también trabajar con microcontroladores con el software original windows.

Existe software nativo para trabajar con microcontroladores PIC desde Linux, si claro que existe, el propio MPLABX puede hacerlo, pero la verdad es que para los que tenemos toda la estructura en Windows funcionando sin problemas pero de esta forma podemos migrar la estructura para electrónica a Linux sin cambiar nada y seguir trabajando de manera normal hasta que las herramientas Linux para microcontroladores alcancen el grado de madurez que tienen en Windows.

El lenguaje C.C es un lenguaje de programación creado en 1972 por DennisM. Ritchie en los Laboratorios Bell como evolución delanterior lenguaje B. Al igual que B, es un lenguaje orientado ala implementación de Sistemas Operativos, concretamenteUnix. C es apreciado por la eficiencia del código que produce yes el lenguaje de programación más popular para crear softwarede sistemas, en la actualidad es la principal herramienta deprogramación para electrónica y el desarrollo de sistemasembebidos con microcontroladores. Se trata de un lenguaje débilmente tipificado de medio nivel pero con muchas características de bajo nivel. Dispone de las estructuras típicas de los lenguajes de alto nivel pero, a su vez, dispone

Programación en XC8 y ESP32 Pagina 15 de 176

caso no se usan símbolos angulares sino “ ” como veremos mas adelante. Tdos los archivos H son llamados de cabecera (head) y son engeneral archivos que contienen definiciónes da variables o colecciones de funciones.

Una función no es otra cosa que un trozo de código que hace algo específico, lo que en ensambladorllamábamos subrutina. En C las funciones están contenidas por llaves de apertura y cierre { }.

Nombre_de_la_función(void)

{

Código de la función.

}

La línea:

#pragma config OSC=HS,PWRT=ON,MCLRE=OFF,LVP=OFF,WDT=OFF

Son los fusibles de configuración para el controlador.

• OSC=HS Cristal oscilador de alta velocidad por encima de 4Mhz.• PWRT=ON Es un hardware interno que mantiene un estado de reset durante unos 72 ms

hasta que se estabilice la tensión de alimentación. Utiliza un circuito oscilador RC interno yun contador para conseguir ese tiempo, el tiempo en que está activo PWRT puede ser distinto entre distintos PIC, según el valor de Vcc, la temperatura y otras variables, esto es muy útil cuando tenemos periféricos lentos y debemos esperar a que inicien por ejemplo un LCD.

• MCLRE=OFF No contamos con reset por Hardware, el pin de reset pasa a ser un pin de puerto.

• LVP=OFF No nos interesa la programación en bajo voltaje, si lo activo el pin del puerto donde este asignado quedará dedicado a la programación y se perderá del puerto.

• WDT=OFF No tenemos activo el perro guardian o Watch Dog .

La línea #define _XTAL_FREQ 20000000 especifica que usaremos un cristal de 20Mhz, necesaria esta línea para informar la velocidad del cristal para las funciones que calculan tiempos.La línea #define led PORTBbits.RB0 le dice al compilador que toda vez que se haga referencia a led este entienda que tiene que actuar sobre el puerto B específicamente RB0.Por ejemplo en un PIC18F4620 al ejecutar led=1 el pin 33 (RB0) pasará a tener un nivel alto, con led=0 el pin 33 pasará a tener cero voltio.Utilizar #define xxxxxx es interesante por ejemplo para vincular una alarma, un motor, un botón, etc a algún pin o puerto del controlador y así hacer referencia a esto de manera mas intuitiva o familiar para el propio programador.

En el archivo principal de proyecto encontramos la función principal (todo programa en C tiene unafunción principal y solo una) la función main().

int main(void){ TRISB=0; // Todo el puerto B como salida


Veamos un ejemplo, en este programa vamos a visualizar el estado de un contador a través de un display de siete segmentos tipo cátodo común.

/********************************************************************************* Descripción : Contador de un dígito ** Target : PIC18F4620** Compilador : Microchip XC8** XTAL : 20MHZ ** Autor : Firtec - www.firtec.com.ar** ****************************************************************************/#include <xc.h>#pragma config OSC=HS,PWRT=ON,MCLRE=OFF,LVP=OFF,WDT=OFF #define _XTAL_FREQ 20000000


Recordar que C diferencia entre mayúsculas y minúsculas.

El operador & es utilizado generalmente para llevar a cero ciertos bits. Por ejemplo:

El operador | es utilizado para setear ciertos bits. Por ejemplo:

Los operadores tienen cierto orden de precedencia, esta jerarquía es obedecida por elcompilador, la precedencia se basa en la asociatividad de las variables, siendo la demayor precedencia la que se ejecutará prioritariamente.

Estructuras de Control. if().Esta estructura se utiliza para ejecutar instrucciones en forma condicional, de acuerdo con la evaluación de la expresión. Por ejemplo realizar una acción si una variable es mayor que otra:

if(a>b){//Ejecutar este código si es verdadero

}Podríamos decir también:

if-else.En este caso se agrega la instrucción else. Ahora se evalúa una condición original, si es verdadera, se ejecuta y sino no lo es, se ejecuta el bloque debajo de else.

if(a>b){//Ejecutar este código si es verdadero

}else{

//Ejecutar este código si lo primero no es verdadero }while().

Ejecuta un conjunto de instrucciones mientras una condición sea verdadera. La principal característica de esta estructura es que, antes de comenzar el bucle, verifica la condición, por lo que es posible que el bucle no llegue a ejecutarse.Do-while.Es parecida a un while solo que la condición se evalúa al final, por lo que el bucle se ejecutara por


unidad = resto % 10; // El resto es la unidadbandera = 1; // Evita que se cuente el mismo número mas de una vez. }PORTB=Digito[unidad]; // Escribe la unidad en el puerto BPORTDbits.RD2 = 1; // Pone el pin 21 Delay1KTCYx(5); // Espera 5mSPORTDbits.RD2 = 0; // Pone a 0 el pin 21 PORTB=Digito[decena]; // Escribe la decena en el puerto BPORTDbits.RD1 = 1; // Pone a 1 el pin 20 Delay1KTCYx(5); // Espera 5mSPORTDbits.RD1 = 0; // Pone a 0 el pin 20 PORTB=Digito[centena]; // Escribe la centena en el puerto BPORTDbits.RD0 = 1; // Pone a 1 el pin 19 Delay1KTCYx(5); // Espera 5mSPORTDbits.RD0 = 0; // Pone a 0 el pin 19 if(PORTAbits.RA0!=0) // Espera que se libere el pulsador para contar solobandera=0; // un número por vez. }}

En la imagen anterior se pueden apreciar los tiempos del multiplexador generando ventanas de conducción para cada transistor de 5 milisegundos y los mismos tiempos de apagado, solo un display está activo mientras que los otros dos permanecen apagados.


int main(void){lcd_init(); // Configura el LCD a valores por defecto.lcd_gotoxy(3,1); // Coloca el cursor en la tercera columna primer fila (línea)lcd_puts(Buffer);// En ese lugar imprime los caractereslcd_gotoxy(1,2); // Cursor en el segundo renglón primer casillero (columna)

voltios = (512 * 5.0)/1024; sprintf(str_float,"F:%2.2f ", voltios); lcd_puts(str_float);

lcd_gotoxy(8,2); sprintf(str_int,"E:%04d ", dato_entero); lcd_puts(str_int);

while(1); }

Resultado al ejecutar el programa.

La clave para la presentación de los datos en el LCD está en la línea:

sprintf(str_float,"F:%2.2f", voltios);

Sprintf() es una función de C que se utiliza para darle formato a variables, en este caso estamos tomando el dato float contenido en voltios y lo convertimos en una cadena de caracteres que lo representará en el LCD. Queremos ver el dato con un formato de dos enteros y dos decimales la letra f indica que estamos haciendo referencia a un float. Esta cadena se almacena en str_float, incluso guardará la letra F:

Es importante notar que la cadena char str_float[7] tiene el espacio suficiente para contener esta conversión ASCII.La línea sprintf(str_int,"E:%04d ", dato_entero)hace lo mismo pero le da formato a un entero reservando cuatro lugares para decimal mas la letra E (E:%04d ) la cadena se almacena en str_int y el dato origen viene de dato_entero.

2


Otra de sus características es que tiene dos pines de referencia donde podemos dar la tensión de referencia para todas o algunas de las entradas del conversor.

Otra posibilidad es configurar el tiempo de adquisición de datos, pues tiene un registro habilitado especialmente pare esto.

Se recomienda que la máxima resistencia de entrada (Rs) sea de 2.5K, para un correcto ajuste de impedancias.(Esto último para la serie 18 de pic´s. En la serie 16 la R de entrada es de 10K).Recuerde, solo hay un modulo Analógico/Digital con varias entradas que se pueden vincular a el para hacer mediciones.


Circuito propuesto para la aplicación.

Lectura de un sensor LM35 con el conversor A/D./* ***************************************************************************** Descripción : Conversor & LM35 sensor de Temperatura ** Target : 40PIN PIC18F4620** Compilador : Microchip XC8** www.firtec.com.ar** ***************************************************************************/

#include <xc.h>#include <stdio.h>#include <stdlib.h>#include <plib/adc.h> // Librería para el ADC


#define _XTAL_FREQ 20000000

void leer_conversor(void); // Se declara la función que leerá el conversor A/Dvoid Mostrar_Conversor(void); // Función que mostrará los datos

const unsigned char Digito[16] ={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x67,0x77,0x7C,0x39,0x5E,0x79,0x71};

unsigned char contador =0;unsigned char unidad=0, decena=0, centena=0;unsigned int conversion=0;

void delay(unsigned int t){ while(t--) __delay_ms(1);}


Funcionamiento de la USART

En la actualidad y ante la ausencia de puertosRS232 en las computadoras, acostumbramos atrabajar con puentes USB-RS232 que solucionanmuchos o todos los problemas a la hora devincularnos con computadoras a través del viejoprotocolo 232.Es interesante comentar que debido a ladesaparición de estos puertos en arquitecturas de computadoras uno tiende a pensar que el puerto RS-232 está extinguido, nada mas alejado de la realidad ya que arquitecturas en 16 y 32 bits no soloincorporan uno de estos puestos sino varios.

El controlador no resuelve la capa física, es decir que para implementar las comunicaciones deberemos utilizar ya sea el clásico MAX232 o los modernos puentes USB-232.Esto es particularmente interesante porque con esta tecnología podemos reutilizar los viejos programas en puertos COM que por cuestiones de licencias o complejidad son mas simples de implementar que las aplicaciones USB nativas.

El ejemplo que vamos a ver recibe los datos enviados desde el teclado de una PC y los re-transmite como un eco por el mismo puerto serial.

/* ******************************************************************************* Nombre : main.c** Descripcion : Uso de la memoria EEPROM interna del PIC ** Autor : Firtec - www.firtec.com.ar** IDE : Microchip MPLAB-X ** Compilador : XC8** XTAL : 20MHZ ** ****************************************************************************/#include <xc.h>#include <stdio.h>#include <stdlib.h>

#include <plib/usart.h>

#pragma config OSC=HS,PWRT=ON,MCLRE=OFF,LVP=OFF,WDT=OFF#define _XTAL_FREQ 20000000

#include "C:\ELECTRÓNICA\EJERCICIOS_XC8\USART.X\lcd_xc8.c"#include "C:\ELECTRONICA\EJERCICIOS_XC8\USART .X\lcd_xc8.h"volatile char Data, Kbhit=0;

Se discrimina el origen de la interrupciónvoid interrupt high_isr (void){if (PIR1bits.RCIF==1){ // Discrimina la interrupciónData=getcUSART(); // Se lee dato recibidoKbhit=1; // Indica que se ha recibido un datoPIR1bits.RCIF=0; // Borra bandera de interrupción }}


Memoria 24LC256 con XC8./* ***************************************************************************** File Name : 24LC256.c** Version : 1.0** Description : Control de una memoria 24LC256** Memoria de 32Kx8=256Kbit 64Bytes x Paginas** Target : 40PIN PIC18F4620** Compiler : Microchip XC8 ** IDE : Microchip MPLAB IDE v8.50** XTAL : 20MHZ ** ****************************************************/#include <xc.h>#include <stdio.h>#include <stdlib.h>#include <plib/i2c.h>

#include "24LC256.h"


#define _XTAL_FREQ 20000000

#include "C:\ELECTRÓNICA\Programas PIC\2014\EJERCICIOS_XC8\24LC256.X\lcd_xc8.c"#include "C:\ELECTRÓNICA\Programas PIC\2014\EJERCICIOS_XC8\24LC256.X\lcd_xc8.h"

FUNCIÓN PRINCIPAL DEL PROGRAMAvoid main(void){unsigned char dir_hi =0, dir_low= 500;unsigned char Dato=54; // Dato cualquiera a guardar en Memoriachar str_int[14]; lcd_init(); OpenI2C(MASTER,SLEW_OFF); // Modo Master SSPADD = 49; // 100KHz para 20MHz Escribe_Byte(0xA0,dir_hi,dir_low,Dato); // Escribe la memoria

lcd_putrs(" Memoria 24C256"); lcd_gotoxy(1,2); sprintf(str_int,"Dato memoria:%02d ",Lee_Byte(0xA0,dir_hi,dir_low)); lcd_puts(str_int);while(1);}

Para el funcionamiento de este ejemplonecesitamos de dos archivos encargados delidiar con las funciones relativas a lamemoria I2C.

• 24LC256 Contiene las funciones decontrol de la memoria.

• 24LC256.H Contiene lasdeclaraciones de estas funciones.

Todo lo referente al propio bus I2C estacontenido en el archivo de cabecera i2c.hprovisto por el compilador.


Frecuencias posibles desde el registro de control.

Mapa de memoria

Circuito de la Aplicación

El pin siete del DS1307 ha sido configurado a través del registro de control para genera un pulso cada segundo, este pulso se conecta al pin 35 (INT2) del controlador generando una interrupción cada segundo.

Esta interrupción cambia el estado de una bandera que se utiliza como indicativo que hay valores del reloj a actualizar en pantalla. Cada vez que se actualizan los datos en pantalla se cambia de estado el LED colocado en el pin 38 para tener una indicación visual que la interrupción esta funcionado al ritmo de un segundo.


num = ~num +1; // Ajusta la temperatura si es negativa sprintf(temperatura,"-%d ",num); // Completa el string para el LCD } else{ sprintf(temperatura,"+%d ",num); // Temperatura positiva. } lcd_gotoxy(8,2); lcd_puts(temperatura); // Muestra la temperatura. delay(500); } }

PCF8574.

Es un expansor de puertos compatible con la mayoría demicrocontroladores, permite una comunicación bidireccional, necesitandosolo dos líneas a través del bus I2C.

Características del módulo• Tensión de alimentación de 2.5 a 6 V CC. • Bajo consumo en standby (máximo 10 microamperios). • Conversión de datos de I2C a paralelo y viceversa. • Un Pin de interrupción de salida a drenador abierto (necesita resistencia pul-up). • Un puerto cuasi-bidireccional de ocho bits (necesitan resistencias pul-up). • Tres pines disponible para configurar por hardware la dirección del dispositivo. • Disponible en encapsulados DIP y SMD.


while(1){ Medir_Temperatura(); // Inicia la conversion Grados = Leer_DS18B20(); // DS18B20 12 BITS //Grados = Leer_DS18S20(); // DS1820 10 BITS sprintf(TempStr,"%2.1f", Grados); lcd_gotoxy(13,2); // Coloca el cursor en posición lcd_puts(TempStr); }}

Como se comentó anteriormente, estos microcontroladores no tienen puerto nativo para esta comunicación por lo que es necesaria construirlo por software.El archivo que contiene todo el saber de esta comunicación es 1wire.c donde encontramos funcionespara leer temperatura tanto con el DS18B20 o con el veterano DS1820 a 10 bits de resolución.El contenido del archivo 1wire.c contiene la librería para el manejo de este dispositivo en XC8.

/////////////////////////////////////////////////////////////////////////// Driver para el manejo de las comunicaciones entre un pic y un //////// dispositivo Dallas/Maxim 1-wire //// //// Los tiempos han sido calculados para un cristal de 20Mhz //////// El pin de datos se ha dispuesto por RA4 //////// WEB: www.firtec.com.ar //////// mail: [email protected] ///////////////////////////////////////////////////////////////////////////// NOTA: No olvidar la resistencia de 4,7K entre el pin RA4 y Vdd. ///////////////////////////////////////////////////////////////////////

#include <xc.h>


float ftemp;Escribir_Byte(0xCC);Escribir_Byte(0xBE);for (k=0; k<8; k++)

get[k]=Leer_Byte();temp = get[0];if (get[1] > 0x80)

temp = temp * -1;ftemp = temp;

return (ftemp/2);}/*********************** Leer_DS18B20() ***************************//* Esta función lee la temperatura de un sensor DS18B20. *//* Argumentos: ninguno *//* Retorna: La temperatura con signo *//******************************************************************/float Leer_DS18B20(void){ unsigned char temp1, temp2; int temp3; float result; Reset_1wire(); Escribir_Byte(0xCC); Escribir_Byte(0x44); Reset_1wire(); Escribir_Byte(0xCC); Escribir_Byte(0xBE); temp1 = Leer_Byte(); temp2 = Leer_Byte(); temp3 = (( int) (((( int )( temp2 )) << 8 ) + ((int )( temp1 )))) ; result = (float) temp3 / 16.0; return(result);}

Programa en ejecución.


Pines de control y contraste.

Como manejar la pantalla.

El mayor problema que presenta el manejo de estas pantallasradica en que se debe disponer de mucha memoria en eldispositivo de control del GLCD, ya sea el microcontrolador o elprocesador que se conecte a el debe ser capaz de manejar lainformación necesaria para “pintar” los pixeles. Cada grupo de 8pixeles requiere de una posición de memoria para almacenarlo(cada uno de estos bytes verticales debe ser guardado parareproducir la imagen).Para pintar una pantalla completa, digamos un marco de fondo donde se pintaran los datos se necesitan de 1024 bytes. (1024 x 8 = 8192 pixeles disponibles en la pantalla). Un ejemplo de esto puede verlo aquí. En la imagen superiorse observa la pantalla funcionando mostrando un fondo y eldespliegue del dato capturado desde el conversor A/D. En laimagen blanco y negro se observa la pantalla de fondo talcual como se la creo con el Paint de Windows. Esta imagense dibuja con cualquier programa, lo importante es que laimagen debe ser Blanco y Negro y desde luego debe respetar el tamaño de pantalla, en este caso la pantalla es 128x64 pixeles.

Como termina la imagen en ByN dentro de la memoria del microcontrolador?.Aquí la respuesta:


El Puerto USB.El concepto básico de USB fue para una interfaz que sea capaz de conectar unavariedad de dispositivos periféricos, como teclados y ratones, a los PC. Sin embargo,desde su introducción, las solicitudes de USB se han ampliado y se ha utilizado paramuchos otros fines, incluyendo la medición, automatización y una gran variedad deartilugios electrónicos.En términos de rendimiento, USB 1.1 puede transferir 12 Mbps, pero con la introducción del USB 2.0 la velocidad máxima es de 480 Mbps.Respecto a USB 3.0, la principal novedad técnica será que eleva a 4.8 gigabits/s la capacidad de transferencia que en la actualidad es de 480 Mb/s. Se mantendrá el cableado interno de cobre para asegurarse la compatibilidad con las tecnologías USB 1.0 y 2.0.

Si en USB 2.0 el cable dispone de cuatro líneas, un par para datos, una de corriente y una de toma de tierra, en USB 3.0 se añade cinco líneas. Dos de ellas se usarán para el envío de información y otras dos para la recepción, de forma que se permite el tráfico bidireccional, en ambos sentidos al mismo tiempo. El aumento del número de líneas permite incrementar la velocidad de transmisión desde los 480 Mb/s hasta los 4,8 Gb/s. De aquí se deriva el nombre que también recibe esta especificación: USB Superspeed.La cantidad de energía que transporta un cable USB 1.x y 2.0 resulta insuficiente en muchas ocasiones para recargar algunos dispositivos, especialmente si utilizamos concentradores donde hayconectados varios de ellos. En USB 3.0, se aumenta la intensidad de la corriente de 100 miliamperios a 900 miliamperios, con lo que pueden ser cargados más dispositivos o hacerlo más rápido. Este aumento de la intensidad podría traer consigo un menor rendimiento energético. Pero pensandoen ello, USB 3.0 utiliza un nuevo protocolo basado en interrupciones, al contrario que el anterior que se basaba en consultar a los dispositivos periódicamente.El aumento de líneas en USB 3.0 provoca que el cable sea más grueso, un inconveniente importante. Si hasta ahora los cables eran flexibles, con el nuevo estándar estos tienen un grueso similar a los cables que se usan en redes Ethernet, siendo por tanto más rígidos.Afortunadamente, igual que pasa entre USB 1.1 y USB 2.0 la compatibilidad está garantizada entre USB 2.0 y USB 3.0, gracias al uso de conectores similares, cuyos contactos adicionales se sitúan enparalelo, de forma que no afectan en caso de usar algún puerto que no sea del mismo tipo.

En operación, el host USB detecta automáticamente cuando un dispositivo nuevo se ha conectado y a continuación, pide la identificación del dispositivo y configura correctamente los controladores. La topología de bus permite que hasta 127 dispositivos se conecten simultáneamente en un puerto. Por el contrario, el puerto serie clásico admite un solo dispositivo por puerto. Mediante la adición de Hubs, más puertos se pueden agregar a un host USB.

La norma ha sido mejorada para satisfacer las crecientes necesidades de la comunidad de usuarios. Como resultado hay un número de diferentes estándares USB, pero afortunadamente estos son compatibles.

1. USB 1.1: Esta fue la versión original del bus USB, Universal Serial y fue lanzado en septiembre de 1998, después de algunos problemas con el USB 1.0 lanzado en enero de 1996. Es siempre una interfaz Maestro / Esclavo y una topología en estrella que es capaz de soportar hasta 127 dispositivos y un máximo de seis niveles o hubs. El maestro o dispositivo"Host" es normalmente una computadora con los esclavos o "dispositivos" vinculados a través del cable. Uno de los objetivos de la norma USB era reducir al mínimo la complejidad en el dispositivo permitiendo al anfitrión realizar el proceso de control. Esto


Las transferencias, como se puede apreciar, se dividen en las tramas sucesivas hasta que se han completado. Esta estrategia de comunicación tiene una razón de ser. Se comparte los frames para los diferentes dispositivosconectados al bus, de talmanera que cada uno tieneparte de la trama. Lastransferencias Interrupt yasíncronas tienen privilegiosde transmisión en las tramas,siéndoles asignadas unporcentaje configurable de latrama.

Elementos de lasTransferencias.

Básicamente los elementos enlas transferencias son losendpoints y los enlacesvirtuales, es por ello que en elpresente capítulo se resumensus características másrelevantes.

EndPoint.

En el caso del PIC18F4550 lasespecificaciones USB definenun endpoint como, unaporción del dispositivo USBcon una dirección única que esfuente de información en unacomunicación entre el host yel dispositivo. Esto sugiereque la información solo fluyeen una dirección. Esto escierto aunque los endpoints de control es un caso especial de flujo bidireccional. Todas las transmisiones viajan desde o hacia un endpoint del dispositivo. Un endpoint es un buffer que guarda múltiples bytes. Típicamente es un bloque de memoria de datos es decir unos registros en el microcontrolador. En el caso del PIC18F4550 estos buffers se encuentran en la memoria RAM, concretamente en el banco 4 (400h) hasta el banco 7 (7FFh) cada uno de ellos, de 256 bytes. Cuando el modulo USB está inhabilitado estas posiciones de memoria pueden usarse como registros de propósito general. Pero cuando el modulo USB está habilitado, la memoria de esos


Encendiendo un LED con PIC16F84.

#include <stdio.h>#include <stdlib.h>#include <xc.h> #define _XTAL_FREQ 4000000 // Frecuencia de reloj

// Configuración del controlador#pragma config FOSC = INTOSCIO #pragma config WDTE = OFF #pragma config PWRTE = OFF #pragma config MCLRE = OFF #pragma config BOREN = ON #pragma config LVP = OFF #pragma config CPD = OFF #pragma config CP = OFF

FUNCIÓN PRINCIPAL DEL PROGRAMAvoid main (){ TRISB = 0b00000000; // Configura puerto B como salidas while (1) // Bucle infinito { PORTBbits.RB0 = 0; // Apaga pin RB0 __delay_ms(500); PORTBbits.RB0 = 1; // Enciende pin RB0 __delay_ms(500); }}

Manejando botones y LED´s con PIC12F629 ************************************************************************** ** Asignación de Pines: ** GP1 = Led que indica botón presionado ** GP2 = LED ** GP3 = Botón activo con nivel bajo ** *************************************************************************/

#include <stdio.h> #include <stdlib.h> #include <xc.h> // Librería XC8

#define _XTAL_FREQ 8000000 // Frecuencia de reloj

#pragma config FOSC=INTOSCIO,PWRTE=ON,MCLRE=OFF,BOREN=ON,CPD=OFF,CP=OFF,WDTE=OFF

// Pines del micro.#define START GPIObits.GP2 // LED´s#define SUCCESS GPIObits.GP1

#define BUTTON GPIObits.GP3 // Pulsador#define MAXRT 200 // Maximum reaction time in ms

FUNCIÓN PRINCIPAL DEL PROGRAMAvoid main(){


Porque mezclar ESP32 con PIC's?

La respuesta podría ser simplemente “Y porqué no”.Es barato, fácil de conseguir, fácil de usar y se puede conectar con cualquier PIC y brindar conectividad TCP-IP.Que hay PIC's que tiene conectividad TCP-IP es cosa sabida y no se pretende entrar en una competencia tecnológica, la idea es conecta a Internet un desarrollo con un simple PIC12Fxx o un PIC16Fxx y no tener que portar todo el código a un micro mas actual.Para eso sirve ESP32, permite conectar todo con todo. Imagine enviar datos con un PIC clásico a unprotocolo como MQTT, tendríamos un PIC (Sin importar de que tipo) conectado a un protocolo hecho para el Internet de las Cosas.ESP32 incorpora la mayoría de los módulos clásicos que se encuentran en los microcontroladores, conversor, comunicaciones y pines GPIO configurables.Sin embargo y a no ser que nuestra aplicación sea de extrema simpleza, el verdadero poder de ESP32 está en la forma eficiente que logra conectividad WiFi y Bluetooth.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. Y si es engorroso conectar una pantalla gráfica, porque no construir una “pantalla” que se pueda verdesde cualquier lado y con cualquier equipo que tenga un navegador.Observe la siguiente imagen.

Un clásico voltímetro mostrado en un navegador. No hemos agregado gráfica en este ejemplo pero


<HTML><HEAD><TITLE>Prueba HTML </TITLE> </HEAD><BODY><meta charset="UTF-8"><center> <P> <IMG SRC= "./firtec.png "><H1>Pagina HTML Simple </H1><br><hr Size=3 noshade/> <H4>by. Firtec Argentina </H4></center> </body></html>Si copia el texto anterior y lo guarda con el nombre de index.html, al hacer doble click el navegador mostrará la siguiente imagen.

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>Delimita y engloba toda la página web, que consta de cabecera y cuerpo.<HEAD> … </HEAD>Delimita y engloba la cabecera de una página.<TITLE> … </TITLE>Dentro de la cabecera (HEAD), lo que se incluye aquí se muestra en la barra del título o la ventana del navegador.


Se ha marcado en azul las funciones JavaScript que modifican la variable “dato” que usaremos como contador. JavaScript define las variables anteponiendo la palabra “var “.Los “;” al final de cada linea no son obligatorios pero si de “buenas costumbres”.Las funciones JavaScript, o los bloques de código que corresponden a JavaScript se contienen dentro de “<script>” donde inicia y “</script>” donde termina. Adentro de estas etiquetas las reglas de sintaxis y semántica son JavaScript y puede haber tantas como necesitemos en una web.Normalmente una función JavaScript realiza un trabajo cuyo resultado se muestra en algún lugar de la página, para esto podemos definir una sección donde mostrar los datos.“<div id="textoDiv"></div>” hace justamente eso, crea una sección con el identificador textoDiv.En la función JavaScript vemos la línea “var div = document.getElementById("textoDiv")” donde sedefine la variable div que es igual a “conseguir un elemento por el ID que coincida con textoDiv”.Esto dicho de manera muy simplista porque como vamos a ver mas adelante, el método GET() es bastante complejo con muchas posibilidades y propiedades.TextContent es una propiedad de document.getElementById por lo tanto cuando vemos la línea “div.textContent = dato”el punto que conecta con textContent permite el acceso a la propiedad y el dato con el estado del contador se muestra en la página en el lugar indicado por la sección <div>.La palabra “function” define una función en JavaScript, en esta pagina hay dos, “contador()” y “borrar_contador()”. Pero como se las llama desde la propia página?Mirando fuera dela función JavaScript encontramos las definiciones de los botones, analicemos uno.


Botón de programación en la placa ESP32 Thing.

Voltímetro web con Ajax.

Vamos a intentar construir una aplicación simple que se vea como la siguiente imagen.

Para hacer esto posible necesitamos tres cosas.


setTimeout('Leer_Sensor()', 10);

}</script>

</head><body onload="Leer_Sensor()"><meta charset="UTF-8"><center><img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAOAAAABjCAYAAACCCQyXAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAAZdEVYdFNvZnR3YXJlAEFkb2JlIEltYWdlUmVhZHlxyWU8AAAeCUlEQVR4Xu2dB5RURdbH70RmBoY0hJGMASRnXVCCgAoKGBAFM67iWWF1TfDBqmfBhOsaEUURVPCYcAUkJ8MKElyQnINkJsEEJvV0d331r67X/br7dU+/DtMNWz/OO/Oq6nV6vFt1761bt+IYhxQKRVSIl38VCkUUUAKoUEQRJYAKRRRRAqhQRBElgApFFFECqFBEESWACkUUUQKoUEQRJYAKRRHcu3evOBSKi5kqDUWzWM9STtEPlHP+Zyoq20d553+lzs2mUYuM0fIKBxaLhapVqyZLDjp16kQDBgygO+64g3r27ClrFYoLm4gLYEHpTjqeN5dOFywii+0cJcSnUnxcMsXFJVIcH4Ct9hIa1P6gvNrBmjVraODAgbJkzKBBg2jKlCnUo0cPWaNQXHhETAU9kvsRrdrdgdYduJFOFiwQApeSlElJCbWkECbxugSy2c9ThbVAvsrBiRMn5Jlvli9fTldddZUYKb/77jtZq1BcWIRdAA9kvUFLtCC">

<FONT COLOR = "red"> <H1 align="center">PIC con Ajax</h1> <H2></FONT><hr size="7"align="center"noshade=""> <div id="dato_t"></H2></center> <hr size="7"align="center"noshade="">  <H5 align="center">by. Firtec Argentina  </body></html>

En este caso y aprovechando que el sitio web se encuentra en una memoria SD con una capacidad yvelocidad aceptables, se ha agregado a la web la siguiente imagen (firtec.png).

Lo interesante es la forma en que la imagen se ha incorporado al sitio web. Si observa el código de la página web encontrara donde se carga la imagen en las líneas.<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAOAAAABjCAYAAACCCQyXAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZU.............. etc....etc....Data URI es una manera avanzada de generar una imagen es que en lugar de cargarla en la memoriay “linkearla” en el HTML, la imagen se genera con puro código de base64. Es como si la propia imagen es parte del código del sitio web.Y como convertir una imagen en código URI64?Simple, como la codificación URI está siendo muy popular por la ventajas que ofrece hay muchas herramientas de uso libre que permiten estas conversiones, incluso muchas funcionan en línea.Para el uso con microcontroladores la codificación URI para imágenes tiene la ventaja de la simpleza de uso pero el código final de sitio web crece en Bytes con el tamaño de o las imágenes


https://dopiaza.org/tools/datauri/index.php

Los disipadores auto adhesivos que vienen para placas como Raspberry PI son ideales.

Lectura de un sensor DS18B20 desde una WEB.

Partiendo de este circuito electrónico.

Vamos a intentar publicar la temperatura que también vemos en la pantalla LCD, en una página web.Teniendo claro los conceptos vistos anteriormente observe la simpleza de este trabajo, básicamente es lo mismo, solo hemos cambiado el aspecto de la página web para que se vea diferente y muestre los datos de temperatura en lugar del voltaje.


El código en el PIC es el mismo que vimos en el manejo del protocolo 1-Wire con el sensor DS18B20 al que hemos sumado las rutinas de comunicaciones.

#include <xc.h>#include <stdio.h>#include <stdlib.h>#include <plib/usart.h>

#pragma config OSC=HS,PWRT=ON,MCLRE=ON,LVP=OFF,WDT=OFF

#include "C:\ELECTRÓNICA\Programas PIC\2018\LCD\lcd_xc8.c"#include "C:\ELECTRÓNICA\Programas PIC\2018\LCD\lcd_xc8.h"

#include "1wire.h"

void xputsUSART (char *data); void xputrsUSART (const char *data);

#define _XTAL_FREQ 10000000#define bit_set(bit,ubicacion) (ubicacion |= 1<<bit)#define bit_clr(bit,ubicacion) (ubicacion &= ~(1<<bit))

volatile unsigned char DatoRX, bandera =0;

void delay(unsigned int t){


Que es un Socket de Red?

Puede ocurrir que no necesitamos un sitio web, que solo queremos recibir datos desde un sensor porla red y aquí donde los Socket son muy útiles.Seguramente encontrará variadas definiciones de lo que es un Socket en redes informáticas, sin embargo desde el punto de vista de la electrónica con microcontroladores, podríamos simplemente decir que es el RS-232 de TCP-IP. Una de las formas mas simples de conectar un microcontrolador, PLC o electrónica en general a una computadora es a través de una UART con el conocido protocolo RS-232. Un socket hace eso mismo, establece una conexión entre dos puntos, sin importar donde se encuentren estos puntos y esto si es una gran diferencia con el viejo RS-232.Podemos hacer una medición de voltaje, temperatura, humedad o lo que fuera necesario verificar y transmitir estos datos a cualquier parte del mundo por TCP-IP para esto solo necesitamos tres cosas:

1. Una dirección IP donde enviar los datos. 2. Un puerto virtual donde los datos será recogidos. 3. El conocimiento para darle forma a la idea

Hay varios tipos de socket pero dos son de uso mas común.

• Los socket de flujo (SOCK_STREAM) que son transportados por TCP (Protocolo de Control de Transmisión) y asegura que los mensajes lleguen en el mismo orden que fueron enviados y sin errores. Telnet, los navegadores y muchas aplicaciones usan este tipo de conexión fiable y segura.

• Los socket de datagrama (SOCK_DGRAM) son transportados por UDP (Protocolo de Datagramas de Usuario), Es la forma mas simple de enviar datos por la red. Simplemente montamos un paquete le damos una dirección destino y un puerto y listo!! El SOCK_DGRAMes mas rápido que el anterior pero claro aquí no importa el orden en que los paquetes llegan y varias cosas mas no son tomadas en cuenta motivo por el cual es mas rápido. Pero cuando lo que enviamos son simples datos de una medición o el estado de una máquina y solo estaremos usando la conexión para enviar datos sueltos y esporádicos (mismo que hacemos con RS-232 y microcontroladores) este tipo de socket es ideal para mover datos con nuestra electrónica.

Enviando un contador por un Socket con un PIC.


Que es el protocolo 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 • Consume muy poca energía • Es muy rápido y posibilita un tiempo de respuesta superior al resto de protocolos web

actuales • Permite una gran fiabilidad si es necesario • Requiere pocos recursos procesadores y memorias lo que lo covierte en el candidato ideal

para ser usado con microcontroladores.

El MQTT no es el único protocolo que intenta imponerse: otros como XMPP, REST API y CoAp también tienen ciertas ventajas.

Como funciona MQTT?

Como se dijo, es un servicio de publicación/suscripción basado en TCP/IP, es sencillo y sumamente ágil. El servidor, llamado broker, recopila los datos que los publishers, los clientes o nodos que publican los tópicos. Determinados datos recopilados por el broker se enviarán a determinados nodos que previamente así se lo hayan solicitado al broker.El principio de intercambio se parece mucho al de Twitter donde los publishers envían los mensajes a un canal llamado topic. Los suscriptores pueden leer esos mensajes. Los topics (o canales de información) pueden estar distribuidos jerárquicamente de forma que se puedan seleccionar exactamente las informaciones que se desean. Los mensajes enviados por los nodos pueden ser de todo tipo pero no pueden superar los 256 Mbit.


MQTT, para entrar en tema la que estamos mostrando es sencilla y fácil de configurar.

Pasos para subscribir a un tópico

Teniendo los datos de conexión al servidor,pasamos a subscribir o publicar un tópico, debemos actuar sobre las correspondientes solapas de la aplicación.

SUBSCRIBE para conectarnos con el PIC y PUBLISH para publicar algo desde el móvil al PIC.Por ejemplo podemos agregar un botón para cambiar el estado del pin 17.

El nombre no importa, es solo informativo pero se debe configurar el tópico que debe ser tal cual el que hemos definido en nuestro programa en el microcontrolador ESP32.


Simplemente desde el control de librerías podemos instalar esta biblioteca.Vamos a crear una aplicación MQTT donde se publique la temperatura leída desde un sensor DS18B20, todos los nodos subscritos al tópico tendrán acceso al dato de temperatura, también vamos a controlar el estado de un LED conectado en el pin 17 del PIC.Para esto los móviles que deseen tener acceso a los datos del PIC se deben subscribir al tópico y a su vez el PIC se debe subscribir al tópico del móvil para poder controlar el LED.

El programa completo del ESP32 para conectar con MQTT es el siguiente.En rojo se ha marcado el código que conecta ESP32 con el PIC18F4620.

#include <WiFi.h> // Biblioteca para la conexión WiFi#include <PubSubClient.h> // Biblioteca laMQTT#include "driver/uart.h" // Biblioteca para el puerto UARTHardwareSerial Serial2(0); // El puerto UART en uso es el 2

const char* ssid = "firtec"; // Datos para la conexión de red (pass y ssid)const char* password = "";const char* mqtt_server = "192.168.1.11"; // IP del servidor MQTT

WiFiClient espClient; // Crea una instancia del cliente PubSubClientPubSubClient client(espClient);const char led = 5; // Dos led se usan para verificar si hay erroresconst char led2 = 4;

// Se definen los tópicos o temas#define TEMP_TOPIC "firtec/ds1820"#define LED_TOPIC "firtec/dato1/led" // 1 SI 0 NO

long lastMsg = 0;char msg[20]; // Donde se guardan los datos de MQTTchar buffer[5]; // Donde se guardan los datos de la UART

//-----------------------------------------------------------------------// Lee el mensaje publicado desde el móvil para controlar el pin 17.void receivedCallback(char* topic, byte* payload, unsigned int length) { if ((char)payload[0] == '1') {


y ESP32 - FirtecOnlinefirteconline.com.ar/XC8/demo_XC8.pdf · Los operadores tienen cierto orden de...

Documents

Transcript of y ESP32 - FirtecOnlinefirteconline.com.ar/XC8/demo_XC8.pdf · Los operadores tienen cierto orden de...