Consola serial en PIC en XC16

Chan ya es famoso por ser el autor de la librería para manejo de archivos FAT32 en memorias SD pero tiene muchas otras creaciones geniales. Aquí describiré un ejemplo para usar la librería xprint que permite dotar de forma sencilla a casi cualquier microcontrolador de una pequeña consola de operación o depuración. Usaré un PIC24FJ32GA002 pero entendiendo la idea general se puede portar facilmente a cualquier otro dispositivo.  Primero, deben descargar los archivos xprinf.h y xprintf.c. Esta librería está escrita en ANSI C por lo que es independiente de la plataforma y el compilador. Las tres funciones más importantes que contiene son:

• void xputs (const char* str)          : análoga a la función puts()
• void xprintf (const char* fmt, ...) : análoga a la función printf()
• int xgets (char* buff, int len)        : similar a la función gets()

 xputs() permite escribir una cadena simple. como un "Bienvenidos al programa". xprintf() nos permite dar formato a la cadena, como ("Temperatura %d",temp), como lo haríamos en un C en una PC. xgets() es muy útil y la que la dará mucha presentación a un programa para microcontrolador. Es en esencia muy distinta a su contraparte gets(). Lo que hace xgets es ir capturando en tiempo real lo que se vaya recibiendo el microcontrolador del puerto serial hasta que se presiona ENTER. La misma función va enviado simultáneamente cada carácter a Tx como espejo (aunque esta opción puede desactivarse en los macros del header). ¡Permite incluso borrar caracteres!    

La librería no puede funcionar por si sola. Es necesario asociarla a funciones de escritura y lectura bajo nivel. Lo que sigue ahora es crear un programa que contenga las rutinas para enviar y recibir un byte por puerto serial con la siguiente forma:

//-- Poner byte en el registro Rx
unsigned char uart_getc(void);

//-- Poner byte en el registro Tx
void uart_putc(unsigned char d);

Esta parte del programa siempre será dependiente del dispositivo y compilador. Estas dos rutinas pueden tener cualquier nombre siempre y cuando se asocien en el código principal de la siguiente manera:

//-- Unir UART con funciones de consola
xdev_in(uart_getc);        
xdev_out(uart_putc);

La implementación de las funciones de comunicación serial también están basadas en la implementación de Chan pero las he reescrito de una forma más clara y comentadas lo mejor que pude. Esta implementación utiliza dos colas (registros FIFO), una de envío y otra de recepción. Esto es muy útil porque permite aprovechar las interrupciones de la UART para no perder bytes. Las referencias a páginas son para la data del GB004 pero es la misma información.   

Aislamiento

Si están utilizando baterías para alimentar al PIC o van a estar realizando depuración es una buena práctica utilizar opto-acopladores. Esto también permite utilizar módulos de conversión USB-Serial que no tengan salida de 3.3v:

 

Programa completo:

	/*
	* File: GA_UART_main.c
	* Author: ChaN & Rodolfo Escobar
	*
	* Created on 27 de junio de 2020, 05:54 PM
	*/
	//--- Bits de configuración ---
	#pragma config POSCMOD = XT // Primary Oscillator Select (XT Oscillator mode selected)
	#pragma config FNOSC = PRIPLL // Oscillator Select (Primary Oscillator with PLL module (HSPLL, ECPLL))
	#pragma config FWDTEN = OFF // Watchdog Timer Enable (Watchdog Timer is disabled)
	#pragma config JTAGEN = OFF // JTAG Port Enable (JTAG port is disabled)
	//-----------------------------
	#include "xc.h"
	#include "xprintf.h"
	#define FCY 16000000UL
	#include "libpic30.h"
	#define BUFFER_SIZE 128 // Buffer UART
	#define _DI() __asm__ volatile("disi #0x3FFF") //Deshabilitar todas las interrupciones
	#define _EI() __asm__ volatile("disi #0") //Habilitar todas interupciones
	//-- Estructuras de datos para UART --
	static volatile int TxRun; // Bandera de recepción activa
	static volatile struct {
	int ri, wi, ct; // Read index, Write index, Data counter
	unsigned char buff[BUFFER_SIZE]; // FIFO buffer (Cola)
	} TxFIFO, RxFIFO;
	//------------------------------------
	//-- Interrupciones UART --
	// Rutina de interrupción Rx
	void __attribute__((interrupt, auto_psv)) _U1RXInterrupt(void){
	unsigned char d;
	int i;
	d = (unsigned char)U1RXREG; // Tomar dato del registro Rx
	IFS0bits.U1RXIF = 0; // Bajar bandera de interrupción
	i = RxFIFO.ct; // Número de bytes en el RxFIFO
	if(i < BUFFER_SIZE){ // No hacer nada si esta lleno
	RxFIFO.ct = ++i;
	i = RxFIFO.wi;
	RxFIFO.buff[i++] = d; // Encolar dato
	RxFIFO.wi = i % BUFFER_SIZE; //Actualizar indice
	}
	}
	// Rutina de interrupción Tx
	void __attribute__((interrupt, auto_psv)) _U1TXInterrupt(void){
	int i;
	IFS0bits.U1TXIF = 0;
	i = TxFIFO.ct; //Indice del dato en la cola
	if(i){ // Hace envio si es diferente de cero
	TxFIFO.ct = --i;
	i = TxFIFO.ri;
	U1TXREG = TxFIFO.buff[i++]; // Envia byte
	TxFIFO.ri = i % BUFFER_SIZE;// Actualiza indice
	}
	else{ // Cola vacía
	TxRun = 0; // Terminar transmisión
	}
	}
	//---------------------------
	//-- Inicializar modulo UART
	void uart_init(unsigned long BaudRate);
	//-- Poner byte en el registro Rx
	unsigned char uart_getc(void);
	//-- Poner byte en el registro Tx
	void uart_putc(unsigned char d);
	//-- Programa principal --
	char Line[256]; // Buffer de entrada de consola
	int main(void){
	//-- Setup --
	TRISBbits.TRISB4 = 0; // Tx
	TRISBbits.TRISB5 = 1; // Rx
	// Mapeo de pines para UART (ver Sec. 10.4, pag. 129)
	RPINR18bits.U1RXR = 5; // Rx -> RP5/RB5 (Tab. 10-2,pag. 130)
	RPOR2bits.RP4R = 3; // Tx -> RP4/RB4 (Tab. 10-3, pag. 131)
	// Inicializar módulo UART
	uart_init(9600);
	__delay_ms(100);
	// Unir UART con funciones de consola
	xdev_in(uart_getc);
	xdev_out(uart_putc);
	//-----------
	//-- Prueba de envío de caracter
	uart_putc('H');
	uart_putc('o');
	uart_putc('l');
	uart_putc('a');
	uart_putc('\r');
	//-- Prueba de biblioteca de consola
	int dato = 342;
	xputs("-- Consola en PIC24 --\n");
	xprintf("El dato en binario es: %016b\n",dato);
	xputs("$> "); // prompt
	xgets(Line, sizeof Line); // Captura todo antes del enter (permite borrar)
	xputs(Line);
	xputs("\nFin del programa.\n");
	while(1);
	return 0;
	}
	//-- Initializar modulo UART
	void uart_init (unsigned long BaudRate){
	//-- Desactivar interrupcines Rx/Tx
	IEC0bits.U1RXIE = 0; // Pag. 82
	IEC0bits.U1TXIE = 0; // Pag 82
	//-- Inicializar UART1 (baja velocidad))
	U1MODEbits.BRGH = 0; // Modo de baja velocidad
	U1BRG = FCY / 16 / BaudRate - 1; // EQ. 17-1 (pag. 190)
	U1MODEbits.UARTEN =1;
	U1STAbits.UTXEN = 1;
	// Limpiar FIFOs Rx/Tx
	TxFIFO.ri = 0; TxFIFO.wi = 0; TxFIFO.ct = 0;
	RxFIFO.ri = 0; RxFIFO.wi = 0; RxFIFO.ct = 0;
	TxRun = 0;
	//-- Habilitar interrupciones Rx/Tx
	IEC0bits.U1RXIE = 1; // Pag. 82
	IEC0bits.U1TXIE = 1; // Pag 82
	}
	//-- Poner byte en el registro Rx
	unsigned char uart_getc(void){
	unsigned char d;
	int i;
	while(!RxFIFO.ct); //Esperar a que haya algo en el FIFO
	//-- Desencolar byte --
	i = RxFIFO.ri;
	d = RxFIFO.buff[i++];
	//---------------------
	RxFIFO.ri = i % BUFFER_SIZE;
	_DI();
	RxFIFO.ct--;
	_EI();
	return d;
	}
	//-- Poner byte en el registro Tx
	void uart_putc(unsigned char d){
	int i;
	while (TxFIFO.ct >= BUFFER_SIZE) ;// Esperar hasta que TxFIFO tenga espacio
	//-- Poner dato en la cola de escritura --
	i = TxFIFO.wi;
	TxFIFO.buff[i++] = d;
	TxFIFO.wi = i % BUFFER_SIZE; // actualizar indice de escritura
	//----------------------------------------
	_DI();
	TxFIFO.ct++;
	if (!TxRun) {// Si no se está tramitiendo...
	TxRun = 1;
	IFS0bits.U1TXIF = 1; //Forzar interrupción
	}
	_EI();
	}

view raw GA_UART_main.c hosted with ❤ by GitHub

Renombrar archivos automaticamente en Linux

El comando rename permite renombrar archivos utilizando la versatilidad de las expresiones regulares de perl. Recomiendo hacer un respaldo de la carpeta con los archivos a renombrar porque los errores de renombramiento pueden ser difíciles de revertir. Pueden utilizar el argumento '-n' o crear una nueva carpeta con las copias de algunos archivos para practicar primero.

Las expresiones de sustitución tiene la forma general:

's/PATRON/REMPLAZO/'modificador

dónde algunos de los modificadores más usados son:

• i :  Patrón insensible a las mayúsculas.
• x : Permitir uso de espacios para mayor claridad.
• g : Remplaza todas las ocurrencias del patrón.

Cuando estaba haciendo mi tesis de licenciatura ocurrió que generé desde Linux cientos de archivos con la hora en el nombre dejando el simbolo ':' como separador. En Linux no es un problema pero en Windows se vuelven inaccesibles. No iba renombrar manualmente esos cientos de archivos, por supuesto. Tomaré este caso como primer ejemplo. Supongamos que tenemos montones de archivos con esta forma:

datos_10:34:01.txt 

Lo que necesitamos hacer es sustituir todas las ocurrencias de ':' por '_'. Por lo tanto el comando para renombrar es:

$ rename -v -- 's/\:/\_/'g *.txt

Notese que si no colocamos el modificador 'g' al final de la expresión entonces solo se sustituirá la primera ocurrencia del patrón e ignorará a las posteriores. Los caracteres ':' y '_' pueden ir sin la barra '\' pero es buena costumbre colocar la barra para distinguir los caracteres del patrón con los operadores de las expresiones regulares.

La expresiones regulares son lo que necesitamos para realizar renombramientos más complejos. Si nunca habían escuchado ese concepto recomiendo ver este video. En pocas palabras es un sub-lenguaje de descripción de patrones de cadenas de símbolos. He aquí una referencia rápida:

.        : carácter único.
\s      : espacio en blanco.
\S     : carácter diferente a espacio en blanco.
\d     : dígito (0-9).
\D     : no-dígito.
\w     : caracter de palabra (a-z, A-Z, 0-9,_)
\W     : no caracter de palabra
[aeiou] : Identifica sólo un carácter del conjunto entre bracetes.
[^aeiou] : Identifica sólo un caracter fuera del conjunto entre bracetes.
(foo|bar|baz) : operador or. Identifica cualquiera de las expresiones dadas.
^   : principio de cadena.
$   : final de cadena.

Cuantificadores
*         : cero o más apariciones de la expresión o símbolo previo.
+        : una o mas apariciones de la expresión o símbolo previo.
{5}    : 5 o más apariciones...
{3,7} : entre 3 y 7 apariciones.
{6,}    : 6 o más apariciones.

 Aprender a escribir expresiones regulares complejas requiere de práctica. Al principio puede ser frustrante pero después de muchos ejercicios se entiende la idea general.

El ejemplo final de esta nota será una demostración del uso de variables. Supongamos que tenemos un directorio con miles de archivos con nombres con la siguiente estructura:

resultados_Rodolfo_Escobar.txt

y se quiere modificar a la forma:

Escobar_Rodolfo_resultados.txt

De nuevo, nadie quiere pasar por la pesadilla de renombrar los archivos a mano. Para crear una expresión de sustitución debemos tener claro el patrón que necesitamos. Tenemos 3 campos separados por _'s. No podemos saber de antemano cuantas letras tendrá cada campo pero si sabemos que contendrán caracteres de palabra, así que debemos describir el patrón como (\w+)_(\w+)_(\w+). Los paréntesis permiten manejar subpatrones de cadenas. Para reutilizar estos supatrones (moverlos de lugar), podemos manejarlos como $n dónde n es el orden en el que aparecen de izquierda a derecha. El comando completo es:

$ rename -v -- 's/(\w+)_(\w+)_(\w+)/$3_$2_$1/' *.txt

Hilma af Klint (1862-1944)

Más allá de lo visible. Hilma af Klint.

Trazos

Mi persona es como el meme del dibujo del caballo. Algunas partes están muy bien definidas y estilizadas, y quien me conozca sólo desde esos ángulos suele intimidarse o tenerme por una persona con los cabos bien atados. No digo que se equivoquen en todo pero si quiero señalar que pocos saben que el resto de mi son solo bosquejos y garabatos. No digo esto por complejo de inferioridad como podría pensarse, o como alguna vez si lo fue. Es lo que he visto en mis introspecciones y hay, diría, razones históricas. Con la misma evaluación honesta se también que soy perfectamente capaz de tomar un lápiz y terminar de dibujarme. Pero hoy no. Aún no sé que dibujar sobre muchos de los espacios en blanco ni sobre las lineas pobremente trazadas. Sigo inacabado y a veces me lo recuerda una que otra amarga circunstancia.

Optimización en Python con SciPy

Resolver problemas de optimización es una herramienta esencial para la ingeniería y la ciencia y debería ser una prioridad en los programas académicos. La bibliografía para aprender la teoría que podría sugerir es el capítulo 7 del libro gratuito Mathematics for Machine Learning. Por ahora me concentraré a detallar una nota para usar la función minimize() del modulo SciPy. Me estoy basando en gran parte en el ejemplo de APmonitor. No sólo será un traducción sino que añadiré detalles importantes que fueron omitidos en su tutorial.

En la jerga de optimización, se le llama función objetivo a la función que se desea optimizar alguno o algunos de sus argumentos. En este ejemplo la función objetivo a minimizar será:

La solución del problema de minimización consiste en encontrar los valores del vector x para los cuales la salida de la función objetivo sea mínima. En la práctica la función objetivo está sujeta a restricciones por lo que este ejemplo no será la excepción:

Restricción 1. El producto de todas las variables debe ser mayor o igual a 25.

Restricción 2. La suma de los cuadrados de las variables debe ser igual a 40.

Finalmente hay que considerar los intervalos que acotan a cada una de las variables:  

Para escribir el programa de Python usando el submódulo optimize de SciPy necesitamos saber lo siguiente. La función minimize() tomará, para este ejemplo, estos argumentos:

func. Una función que debe definirse con un único argumento vectorial y retornando un único escalar.
method. La lista de métodos de minimización disponibles aparecen en la documentación. Es importante saber que los únicos métodos que permiten optimización con restricciones son ''COBYLA", "SLSQP" y "trust-constr".
bounds. Lista de tuplas con las cotas para cada variable.
constraints. Lista de diccionarios donde cada uno tiene la esctructura:

• 'type': Tipo de restricción. 'eq' para igualdad o 'ineq' para desigualdad
• 'func': Nombre de la función que describe la desigualdad (debe crearse) 

Código completo:

	#!/usr/bin/env python3
	# -*- coding: utf-8 -*-
	"""
	Created on Sun Jun 7 17:53:45 2020
	@author: Rodolfo Escobar
	"""
	import numpy as np
	from scipy.optimize import minimize
	def f_objetivo(x):
	"""
	Esta es la función que queremos optimizar
	"""
	x1 = x[0]
	x2 = x[1]
	x3 = x[2]
	x4 = x[3]
	return x1*x4*(x1+x2+x3)+x3
	#---- Restricciones ----
	def restric_1(x):
	"""
	Restricción de tipo >= 0
	Nota: Si no está en esa forma debe rescribirse
	con manipulación algebraica
	"""
	return x[0]*x[1]*x[2]*x[3]-25
	def restric_2(x):
	"""
	Restricción de igualdad a 0
	Nota: Si no está en esa forma debe rescribirse
	con manipulación algebraica
	"""
	cuadrados = [x[i]*x[i] for i in range(len(x))]
	return 40 - np.sum(cuadrados)
	#---------------------
	#---- Diccionarios de restricciones ---
	# Restricción de desigualdad:
	r1 = {'type':'ineq','fun':restric_1}
	# Restricción de igualdad:
	r2 = {'type':'eq','fun':restric_2}
	rest = [r1,r2]
	#--------------------------------------
	#---- Cotas ----
	# En este ejemplo todas las variables están acotadas
	# al mismo intervalo.
	cotax1 = (1.0,5.0)
	cotas = (cotax1,cotax1,cotax1,cotax1)
	#---------------
	#--- Suposición inicial ---
	x0 = [1,5,5,1]
	#--------------------------
	#---- Optimización -----
	# NOTA: Sólo los métodos 'COBYLA', 'SLSQP' y 'trust-constr'
	# permiten hacer optimización con restricciones
	sol = minimize(f_objetivo,x0,method='SLSQP',bounds=cotas,constraints=rest)
	print('La solución es:\n',sol.x)

view raw ejemplo_optimizacion.py hosted with ❤ by GitHub

El libro del tiempo

En la novela corta "La Historia de tu Vida" del escritor de ciencia ficción Ted Chiang se menciona que Borges tenía un argumento en contra de la pre-definición del futuro que me parece demoledor. Supongamos que el libro de mi vida existe y que en el está cada detalle de mi pasado y futuro. Supongamos ahora que encuentro ese libro. Verifico que es autentico porque en el reconozco mis recuerdos hasta el momento exacto en el que tomo ese mismo libro en mis manos. Lo que ocurre después es extraño. Sé ahora todo lo que "voy" a hacer después de ese momento por el resto de mi vida. ¿Pero de verdad voy a hacer todo lo que dice ahora que tengo esa información? ¿Qué me obliga a seguir la historia de ese libro? Nada. Tengo la opción de elegir. Esto hace que la existencia del libro de mi vida sea lógicamente imposible. Borges hace otra observación. Es posible que ese libro exista si se cumple una condición: la historia del universo debe estar hecha de tal manera que yo nunca tenga acceso a él. Sospecho que este argumento debe estar en los ensayos contenidos en "Otras Inquisiciones" que espero conseguir algún día.