Machine Translated by Google

Leer datos en serie directamente en Octave

steve hageman - 23 de octubre de 2015

GNU octava 4 [1] con su interfaz gráfica está permitiendo que muchas más personas exploren MATLAB [2] lenguaje
de programación que nunca podría haberlo hecho antes debido al costo. Si bien Octave nunca tendrá las ricas opciones
de control de instrumentos disponibles para los usuarios de MATLAB, todavía hay formas de obtener datos en serie
directamente desde un dispositivo conectado a Octave.

The Octave: “Paquete de control de instrumentos” [3] se actualizó a mediados de 2015 y solucionó una serie de
problemas del puerto serie. Ahora que el puerto serie funciona más o menos, podemos hacer un trabajo real.

Nota: Estas instrucciones asumen que el lector tiene algún conocimiento previo del puerto serie y sabe cómo conectar y
usar su dispositivo. La información aquí le ayudará a poner en marcha el paquete serial en Octave.

Instale el paquete de control de instrumentos

Los pasos básicos para instalar el paquete de control de instrumentos en Windows son:

1. Descargue el último paquete de control de instrumentos [3] y colóquelo en el directorio de paquetes de Octave,

C:\Octava\Octava-4.0.0\src

Nota: La ruta exacta dependerá de la versión de Octave que esté ejecutando. El ejemplo anterior es para la versión: 4.0.0.

2. Iniciar octava.

3. Establezca el directorio actual en el directorio donde colocó el paquete de control del instrumento en el paso 1.

4. En la ventana de comandos de Octave, en el tipo de solicitud ">>",

pkg install instrument-control-0.2.1.tar.gz

Nota: Asegúrese de utilizar el nombre de archivo correcto para el paquete de control de instrumentos que está instalando.
El ejemplo anterior es para la versión 0.2.1.

5. Presione enter y espere. La instalación toma varios minutos, incluso en una computadora muy rápida.

Finalmente, el símbolo del sistema volverá y el paquete se compilará, instalará y estará listo para funcionar.
Machine Translated by Google

Usando los comandos seriales en Octave

Es necesario realizar una serie de pasos para cargar el paquete de control de instrumentos y luego configurarlo para su uso.
Deberá cargar el paquete de control de instrumentos antes de poder usarlo en su programa Octave.
En su programa Octave, deberá colocar este comando cerca del inicio de su programa.

Control-instrumento de carga de paquetes

si (existe("serie") != 3)
disp("Sin soporte serie"); terminara si

La primera línea carga el paquete. La instrucción 'si' opcional verifica el estado del puerto serie. Tres significa que
las funciones seriales están bien, cualquier otra cosa es un error y no se ha cargado ningún soporte serial. Esta
verificación es útil si su programa pudiera ejecutarse alguna vez en una computadora que no tenga instalado el Paquete
de control de instrumentos.

Para abrir el puerto serie y manejarlo para futuras lecturas y escrituras, use el comando 'Serial()' como se muestra,

% Cree una instancia del puerto serie %

Naturalmente, establezca el número de puerto COM para que coincida con su
dispositivo % Utilice esta loca notación para cualquier número de puerto COM: 1 - 255 s1 =
serial("\\\\.\\COM15") % Abra el puerto pausa(1); % de espera opcional para que el dispositivo
se despierte

El valor devuelto 's1' es el identificador del puerto abierto que se utiliza en operaciones de puerto posteriores.
Es posible que su dispositivo tarde un poco en activarse cuando se abre, por lo que es posible que se necesite una pausa () después de
abrir el puerto.

Si intenta abrir un puerto COM que no existe, obtendrá este error en la línea de comando,

error: serial: Error al abrir la interfaz: No existe tal archivo o directorio

La solución a este error es: conectar, encender o especificar el puerto COM adecuado para su dispositivo.

El siguiente paso es configurar el puerto serie para los parámetros de funcionamiento adecuados. La interfaz get/set es la
forma preferida de acceder al puerto serie. Y los parámetros básicos son,

% Configure los parámetros del puerto

(s1, 'baudrate', 115200); % Ver la lista a continuación
set(s1, 'bytesize', 8); % 5, 6, 7 u 8 set(s1, 'paridad', 'n'); %
'n' o 'y' set(s1, 'stopbits', 1); % 1 o 2 conjuntos (s1, 'tiempo
de espera', 123); % 12.3 Segundos como ejemplo aquí

Los términos anteriores deberían ser familiares para la mayoría de las personas que alguna vez configuraron un puerto serie.

Algunas cosas a tener en cuenta:

Machine Translated by Google

• El protocolo de enlace está establecido en: Ninguno. En este momento, no hay soporte de código para ninguna otra
configuración. • Las líneas de control Listo para terminal de datos (DTR) y Listo para enviar (RTS) están habilitadas de forma
predeterminada cuando se abre el puerto. Si es necesario, puede usar los siguientes comandos para establecer el estado en
cualquier cosa que necesite.

% Comandos opcionales, estos pueden ser 'on' o 'off' set(s1,

'requesttosend', 'on'); % Establece la línea RTS en set(s1,
'dataterminalready', 'off'); % Desactiva la línea DTR

• Baudrate puede ser: 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800, 9600, 19200,
38400, 57600, 115200 y 230400.
• El tiempo de espera se especifica en unidades de 1/10 de segundo. -1 significa que no hay tiempo de espera y el puerto esperará para siempre
a que se complete la operación especificada.

Dependiendo de su dispositivo, es posible que deba vaciar los búferes de entrada y salida en serie, así que
hago algo como esto:

% Opcional Vaciar búferes de entrada y salida srl_flush(s1);

Leer y escribir datos

Leer y escribir datos

Ahora que hemos abierto y configurado el puerto COM, es hora de leer y escribir datos. Los ejemplos que siguen
usan un puerto serial con un conector loopback conectado [4].

Un básico "¡Hola mundo!" se puede enviar y recibir de la siguiente manera,

% Ejemplo usando srl_write & srl_read srl_write(s1,

"¡Hola mundo!");

% Lee 12 bytes como una matriz de enteros read_back_int =

srl_read(s1, 12);

% Convierte los enteros en una cadena read_back_str

= char(read_back_int);

El comando srl_write() escribe todo en el búfer y bloquea su ejecución hasta que el búfer esté vacío. El comando
srl_read() lee el número de bytes especificado como una matriz de enteros. Una conversión a una cadena se realiza
fácilmente como se muestra.

Si hay menos caracteres para leer que los especificados en la llamada srl_read(), la lectura se bloqueará hasta que
se agote el tiempo de espera del puerto. Si hay más caracteres para leer de los que especifica, se dejarán en la entrada
Machine Translated by Google

buffer.

Naturalmente, este requisito de conocer la longitud de la cadena de entrada es muy restrictivo y pone un freno real a
la usabilidad del puerto serie, pero es exactamente el comando de nivel más bajo que necesitamos para construir.

Dado que la mayoría de los instrumentos se comunican mediante algún tipo de carácter de terminación, ya sea un
retorno de carro, un salto de línea o ambos, podemos simplemente leer cada carácter a medida que entra y terminar
la lectura cuando lleguemos al carácter de terminación especificado.

Esta necesidad me llevó a mi humilde incorporación a las operaciones del puerto serie y nació la función:
ReadToTermination() (Apéndice A). Su uso es el siguiente,

return_string = ReadToTermination(serialport, {termination_char})

Primero, devuelve una cadena, que se puede analizar para obtener números más tarde o se puede usar como base
para funciones modificadas que pueda necesitar para sus necesidades específicas, como devolver un doble.

En segundo lugar, sigue leyendo el puerto serie un carácter a la vez hasta que se lee {termination_char}. Si deja
{termination_char} en blanco, el carácter predeterminado que se utiliza es el retorno de carro ('\r'). Si, en cambio, su
dispositivo utiliza la nueva línea ('\n') o algún otro carácter de terminación, puede especificarlo según sea necesario.

El {term_character} se especifica como un int de 8 bits sin signo. Los códigos de terminación más comunes se
enumeran a continuación. Puede buscar otros códigos si es necesario en un gráfico ASCII.

Retorno de carro = '\r' = = 13dic (Predeterminado) = 10dic

Nueva línea '\n'

Puede buscar otros códigos si es necesario en un gráfico ASCII.

Como ejemplo del uso de la función ReadToTermination(), considere lo siguiente:

% Utilice ReadToTermination para volver a leer una línea completa % utilizando la

terminación por defecto_char = Carriage Return srl_write(s1, "Hello world!\r");
read_back = ReadToTermination(s1);

La notación a continuación también funcionará exactamente como la anterior, solo especifica el carácter de terminación.

srl_write(s1, "¡Hola mundo!\r"); read_back =

ReadToTermination(s1, 13);

Del mismo modo, para usar un carácter de nueva línea ('\ n'), esto se puede escribir como,

% Utilice ReadToTermination para volver a leer una línea completa % utilizando la

nueva línea como terminación_char srl_write(s1, "¡Hola, mundo!\n"); read_back =
ReadToTermination(s1, 10);
Machine Translated by Google

Finalmente, este ejemplo muestra cómo leer y escribir varias líneas.

% Lee dos líneas hacia atrás

srl_write(s1, "¡Hola mundo!\r Siguiente línea\r"); línea1 =
LeerParaTerminar(s1); línea2 = LeerParaTerminar(s1);

Después de ejecutar las líneas anteriores, el resultado

será: línea1 = "Hola mundo" línea2 =
“
Proxima linea"

El Apéndice B enumera todo el programa de demostración.

Envolviéndolo todo

Ahora debería tener suficiente información para poder configurar y abrir la lectura y escritura en el puerto serie utilizando
las funciones primitivas srl_read() y srl_write() y las funciones ReadToTermination() de nivel superior descritas.

La función ReadToTermination() es una función de nivel superior que supera las limitaciones de tener que saber
el número exacto de caracteres que se van a leer utilizando en su lugar el método más común: Leer hasta que se
encuentre un carácter de terminación.

Si bien mi versión simple de ReadToTermination() actualmente solo devuelve una cadena, el lector notará lo fácil que
sería modificar esta función para cualquier propósito, ya que el código es extremadamente sencillo y fácil de modificar.

Ahora debería tener un Octave listo para usar con su Arduino o Rasberry PI e incluso con equipos de laboratorio
como ese gran multímetro antiguo HP34401 en su banco de trabajo. ¡Disfrutar!

Información del autor

Steve Hageman es un adicto a lo analógico confirmado desde el quinto grado cuando construyó
su primer receptor de onda corta. Después de adquirir su primera computadora Apple en 1982, continuó
usando software para controlar hardware analógico y construyendo sistemas de medición útiles. Steve
ha tenido el placer de diseñar productos tan diversos como sistemas modulares de adquisición de
datos, fuentes de alimentación conmutadas, sistemas de prueba RFIC, radios definidos por software y,
más recientemente, amplificadores de bloqueo de alta frecuencia para la investigación de muestras
biológicas. Estará encantado de hablar sobre las necesidades de su proyecto personalizado y puede comunicarse con él
a través de su sitio web AnalogHome.

Apéndice A

Listado de códigos de la función ReadToTermination()

función [char_array] = ReadToTermination (srl_handle, term_char)

El parámetro % term_char es opcional, si no se especifica % entonces CR = '\r'

= 13dec es el predeterminado. si (nargin == 1)

term_char = 13;
Machine Translated by Google

fin

no_terminado = verdadero;
yo = 1; matriz_int = uint8(1);

mientras no_terminado

val = srl_read(srl_handle, 1);

if(val == term_char)
not_terminated = false;
fin

% Agrega el carácter recibido a la

matriz int_array(i) = val; yo = yo + 1;

fin

% Cambie la matriz int a una matriz char y devuelva una matriz de cadenas
char_array = char(int_array);

función final

Puede colocar esta función en un archivo llamado "ReadToTermination.m" y colocarlo en el directorio de

trabajo actual de su proyecto.

apéndice B

El programa de demostración completo para usar con una conexión serial loopback [4].

% de octava - Prueba en serie - Uso de una conexión de bucle invertido

clc; claro;

% Cargue el paquete
paq carga instrumento-control

% Comprobar si existe soporte serial if

(exist("serial") != 3)
disp("Sin soporte serie"); terminara
si

% Cree una instancia del puerto serie

% Naturalmente, configure el número de puerto COM para que coincida
con su dispositivo % Utilice esta loca notación para cualquier número de puerto
COM: 1 - 255 s1 = serial("\\\\.\\COM10"); pausa(1); % Espere un segundo, ya
que algunos puertos tardan un poco en activarse

% Establecer los parámetros del puerto

Machine Translated by Google

set(s1, 'tasa de baudios', 115200);

set(s1, 'tamaño de bytes', 8); set(s1,
'paridad', 'n'); set(s1, 'stopbits', 1);
conjunto (s1, 'tiempo de espera', 123);
% 12.3 Segundos como ejemplo aquí

% Comandos opcionales, estos pueden ser 'on' o 'off' %set(s1,

'requesttosend', 'on'); % Establece la línea RTS
%set(s1, 'dataterminalready', 'on'); % Establece la línea DTR

% Opcional: vaciar los búferes de entrada y salida

srl_flush(s1);

%----- Prueba de comunicación de bucle invertido -----

% Looback usando srl_write & srl_read srl_write(s1,

"¡Hola mundo!");

% lee 12 bytes como enteros read_back_int =

srl_read(s1, 12);

% Convierte los enteros en una cadena

read_back_str = char(read_back_int);

% Use ReadToTermination para leer una línea completa srl_write(s1, "Hello

world!\r"); read_back = ReadToTermination(s1);

% Cambiar el carácter de terminación a nueva línea ('\n' = 10) srl_write(s1,

"¡Hola mundo!\n"); read_back2 = ReadToTermination(s1, 10);

% Leer dos líneas hacia atrás

srl_write(s1, "¡Hola mundo!\r Siguiente línea\r"); línea1 =
LeerParaTerminar(s1); línea2 = LeerParaTerminar(s1);

% Finalmente, cierra el puerto

fclose(s1);

Referencias

1. Octava GNU
2. MATLAB es una marca registrada de The Mathworks, Inc.
3. El paquete de control de instrumentos más reciente se puede descargar aquí. Este artículo está escrito para
versión: 0.2.1 (2015-02-05). Las versiones futuras pueden cambiar las cosas significativamente. Asegúrese de
consultar las notas de la versión. Allí también se encuentra más información sobre las funciones contenidas en el paquete.
4. Una simple búsqueda en la Web encontrará muchos ejemplos de cómo hacer un conector de bucle invertido para su serie.
Puerto.
Machine Translated by Google

¿Quieres más programación? Únase a más de 2000 profesionales técnicos y desarrolladores de

hardware, software y firmware de sistemas integrados en ESC Minneapolis del 4 al 5 de noviembre
de 2015 y conozca las últimas técnicas y consejos para reducir el tiempo, el costo y la complejidad
en el proceso de desarrollo integrado.

Asegúrese de seguir las actualizaciones sobre las charlas, programas y anuncios de ESC Minneapolis en ESC
Collection y cuentas de redes sociales Twitter, Facebook, LinkedIn, y Google+.

La Conferencia de Sistemas Embebidos y EDN son propiedad de UBM Canon.