RobotyPic

2032-04-15T16:52:00.010+02:00

COMUNICACIONES ENTRE PC y PIC

Serie de ejemplos dedicados a la comunicación y control de los PIC desde el PC por diversos medios. Puertos serie y USB además de internet como medio de transmisión. Software desarrollado bajo VB6 para podernos comunicar con el PIC desde el PC.

[+/-] Ver / Ocultar publicaciones

COMUNICACIONES ENTRE PICs

Existen diferentes formas de comunicar PIC entre sí; bus I2C, bus serie, infrarrojos, entre otros. Sección dedicada a la comunicación de los PIC entre sí por diversos buses y métodos.

[+/-] Ver / Ocultar publicaciones

SENSORES CON PIC

Los sensores permiten a los sistemas electrónicos y robots recibir información del entorno en el que se encuentran para gestionarla y tomar decisiones consecuentes. En esta sección se muestra el control con PIC de algunos de los más utilizados en la robótica didáctica.

[+/-] Ver / Ocultar publicaciones

COMPONENTES CON PIC

Cuando el PIC, y por extensión los Robots tienen que comunicarse con nosotros, necesitaremos del uso de componentes que nos ofrezcan dicha información de una forma legible, sea en LCD, por voz, etc.

[+/-] Ver / Ocultar publicaciones

ACTUADORES CON PIC

Para reaccionar ante ciertas circunstancias del entorno necesitaremos saber controlar diversos mecanismos como servos, motores, etc.

[+/-] Ver / Ocultar publicaciones

PROCESOS CON PIC

Control de diferentes procesos o funciones usando algunas de las características de los PIC.

[+/-] Ver / Ocultar publicaciones

ROBOTS CON PIC

No podríamos entender el mundo en pleno siglo XXI sin los robots. En esta sección, los artículos desarrollados muestran algunos modelos didácticos. Por supuesto controlados con PIC.

[+/-] Ver / Ocultar publicaciones

Comunicación no estándar entre dos PIC.

2017-06-04T01:22:00.002+02:00

Sabemos que existen diversos sistemas de comunicación para transmitir datos entre PICs (comunicación serie, SPI, I2C, etc.). Aquí vamos a desarrollar un sistema de comunicación propio para la transmisión de bytes de datos de un PIC maestro a uno esclavo y viceversa. No se trata de competir con los sistemas estándar de comunicación existentes sino de disponer de un recurso cuando tenemos que transferir datos de un PIC a otro sin demasiadas exigencias. La única condición en el código desarrollado es que ambos PICs, maestro y esclavo, trabajen con la misma frecuencia de reloj.

El proceso se ha pensado para un bus de 4 líneas:

- Mx_pin es unidireccional y transfiere información del PIC Maestro al PIC Esclavo.

- Ex_pin hace la misma función que el anterior pero la transferencia es del PIC Esclavo al Maestro.

- Inicio_pin también es unidireccional y se emplea para avisar al PIC Esclavo desde el Maestro de que se va a producir una transferencia de información.

- Sincro_pin es bidireccional y su misión es sincronizar el envío de información de uno de los PIC con su recepción por el otro PIC.

Para enviar un byte al Esclavo, el PIC maestro comienza el proceso poniendo a '1' Inicio_pin. Este pulso alerta al PIC esclavo para atender la petición del maestro. Previamente, el maestro ha asegurado el Mx_pin a '0'. Cuando el Esclavo atiende a la solicitud, lee el estado del Mx_pin. Un '0' significa que el maestro le va a enviar un byte de datos. Un '1' significa que el maestro le va a solicitar leer un byte de datos.

Cuando el esclavo ya ha accedido a la solicitud del maestro y leído el estado del Mx_pin, da un pulso en el Sincro_pin para avisar al maestro de que puede mandarle el primer bit del byte a transmitir, comenzando por el bit más significativo b7. El PIC esclavo espera unos 5 uS para asegurar que el maestro pase al Mx_pin el siguiente bit. Cuando el esclavo lee el valor vuelve a dar un pulso en Sincro_pin para avisar al maestro. El proceso se repite para los 8 bits del byte transmitido. Después de leer el último bit, el esclavo da un pulso de unos 10uS en el pin Ex_pin como confirmación de recepción del byte completo.

Para solicitar un byte al Esclavo, el PIC maestro comienza el proceso asegurando el pin Mx_pin a '1'. A continuación da un pulso de comienzo de comunicación en el pin Inicio_pin. Este pulso alerta al esclavo para que atienda el requerimiento del maestro. El esclavo lee el estado del pin Mx_pin. El valor '1' le avisa de que el maestro le solicita un byte para leer. El esclavo confirma su lectura mediante un pulso en Sincro_pin. En ese momento el control del pin Sincro_pin pasa al maestro (pasa a ser salida en el maestro y entrada en el esclavo).

Ahora es el esclavo quien trasmite el byte de datos bit a bit por Ex_pin y el maestro quien advierte al esclavo de que ya ha leído el bit en curso mediante un pulso en la linea Sincro_pin.

Finalizada la recepción del byte completo por el maestro este lo indica con un pulso de 10uS en Mx_pin.

Tanto en el maestro como en el esclavo, la estrategia empleada, a nivel de código para enviar un byte (8 bits) bit a bit por una única línea, consiste en emplear una variable de valor inicial 0x80 (0b10000000) con la que haremos una comparación AND con el byte a enviar. Si el byte a enviar tiene ese mismo bit a '1', el resultado de la función AND será 1 y si es 0 será 0. Y ese será el valor que enviaremos del bit. Rotaremos el bit de la variable una posición (0b01000000=> mascara = 0x40) para comparar el siguiente bit del byte (b6) y así sucesivamente para los 8 bits.

int mascara = 0x80;

/** Envío del byte de datos **/

for (bit=8; bit>=1; bit--){ //Para los 8 bits

if ((dato & mascara)>0) output_high(Mx_pin); //Si bit en curso es 1

else output_low (Mx_pin); //Si bit en curso es 0

mascara = mascara >> 1; //Preparación proximo bit

}

Al otro lado está el PIC que recibe el byte bit a bit. Cuando el bit recibido es 0 realiza una función OR entre la variable temporal (que inicialmente tiene valor 0) y la constante mascara0 (con valor 0b00000000). Cuando el bit recibido es 1 realiza la función OR entre la variable temporal y la constante mascara1. Rota una posición los bits de la variable temporal y vuelve a recibir el siguiente bit. Así hasta los 8 bits.

int mascara0 = 0;

int mascara1 = 0x01;

int temporal = 0;

/** Lectura de los 8 bits del byte enviado **/

for (bit=8; bit>=1; bit--){

delay_us (5);

if (input_state (Ex_pin)) temporal|=mascara1; //Si bit recibido es 1

else temporal|=mascara0; //Si bit recibido es 0

DatoE_RyP_COM=temporal; //Guarda recepción

temporal = temporal << 1 ; //Preparación para recibir siguiente bit

}

Todas las funciones necesarias para realizar la comunicacion entre los dos PICs se ha incluido en una librería <RyP_COM.c> que es la que deberemos llamar en el código principal.

#include <RyP_COM.c>

Previamente deberemos definir si el PIC lo vamos a utilizar como Maestro...

#define MASTER 1 //PIC como Maestro

O como esclavo...

#define SLAVE 1 //PIC como Esclavo

También deberemos definir, antes de cargar la librería, los pines del bus a emplear. Se pueden elegir los que se deseen pero, sino se especifica ninguno, la librería cargará los que tiene por defecto.

#define Mx_pin PIN_B1
#define Ex_pin PIN_B2
#define Inicio_pin PIN_B3
#define Sincro_pin PIN_B4

En el código del PIC maestro, para enviar un byte al esclavo, llamaremos a la función...

Tx_RyP_COM (Dato_Maestro); //Envío de un dato al esclavo

Donde "Dato_Maestro" será la variable que contiene el byte a enviar.

Cuando lo que se quiere es leer un byte del esclavo, la función es...

Rx_RyP_COM (Dato_Esclavo); //Solicitud de dato al esclavo

El byte recibido se almacena en la variable "Dato_Esclavo".Los nombres de las variables se pueden elegir a voluntad.

En el esclavo, la función a invocar es...

Test_RyP_COM (Dato_Esclavo, Dato_Maestro);

Se encarga de testear las posibles solicitudes del PIC maestro. En la variable "Dato_Maestro" se almacena el byte recibido y se envía el byte contenido en "Dato_Esclavo". También para esta función los nombres de las variables se pueden elegir a voluntad, siempre y cuando sean previamente declaradas.

El código de ejemplo aquí mostrado es una muestra de su uso. El PIC Maestro lee el valor de su conversor A/D y lo envía al Esclavo. De la misma forma solicita el valor de la lectura del conversor A/D del Esclavo. Ambas lecturas se muestran en los displays de los respectivos PICs.

En esta animación vemos su funcionamiento y las señales generadas.

[+/-] Ver / Ocultar código PIC Maestro

/*****************************************************************************/ /* */ /* COMUNICACIÓN ENTRE PICS POR BUS DE 4 LINEAS */ /* CON PIC16F876A */ /* */ /* MAESTRO */ /* Robotypic (c) 2017 */ /* */ /*****************************************************************************/ /* Consiste en un sistema de comunicación entre PICs utilizando 4 pines: */ /* Mx_pin trasmite datos del Maestro al Esclavo */ /* EX_pin trasmite datos del Esclavo al Maestro */ /* Inicio_pin señal de inicio de la comunicación */ /* Sincro_pin señal de sincronización en la trasmisión de datos */ /*****************************************************************************/
#include <16F876A.h> //Driver del PIC a emplear #fuses HS,NOWDT,NOPROTECT,NOLVP,NODEBUG
#device adc=8 #use delay(clock=20000000) //Uso de un cristal de cuarzo 20MHz
#define MASTER 1 //PIC como Maestro
/* Configuración del control del LCD */ #define use_portc_lcd TRUE //Puerto c para uso del lcd #include <LCDportc.c> //Librería lcd para puerto c
#include <RyP_COM.c> /*************************** FUNCIÓN PRINCIPAL *******************************/
void main() { /* Variables locales **/ byte Dato_Esclavo; //Dato a recibir del Esclavo byte Dato_Maestro; //Dato a enviar al esclavo /** Inicialización LCD **/ lcd_init(); /** Configuración de entradas y salidas **/ set_tris_c (0x00); //Configuración entradas y salidas puerto c /** Configuración conversor AD **/ setup_adc_ports(AN0); setup_adc(ADC_CLOCK_INTERNAL ); /** Mensaje en LCD **/ lcd_gotoxy(1,1); printf(lcd_putc,"Maestro"); while (true){ /** Lecura canal analógico 0 **/ set_adc_channel(0); delay_us(20); Dato_Maestro = read_adc(); /** Comunicación con el Esclavo **/ Tx_RyP_COM (Dato_Maestro); //Envío de un dato al esclavo delay_ms (100); Rx_RyP_COM (Dato_Esclavo); //Solicitud de dato al esclavo delay_ms (100); /** Visualización en LCD de las lecturas **/ lcd_gotoxy(1,2); printf(lcd_putc, "M:%2x E:%2x",Dato_Maestro, Dato_Esclavo); } }

[+/-] Ver / Ocultar código PIC Esclavo

/*****************************************************************************/

/* */

/* COMUNICACIÓN ENTRE PICS POR BUS DE 4 LINEAS */

/* CON PIC16F876A */

/* */

/* ESCLAVO */

/* © Robotypic 2017 */

/* */

/*****************************************************************************/

/* Consiste en un sistema de comunicación entre PICs utilizando 4 pines: */

/* Mx_pin trasmite datos del Maestro al Esclavo */

/* EX_pin trasmite datos del Esclavo al Maestro */

/* Inicio_pin señal de inicio de la comunicación */

/* Sincro_pin señal de sincronización en la trasmisión de datos */

/*****************************************************************************/

#include <16F876A.h> //Driver del PIC a emplear

#fuses HS,NOWDT,PUT,NOPROTECT,NOLVP

#device adc=8

#use delay(clock=20000000) //Uso de un cristal de cuarzo 20MHz

#define SLAVE 1 //PIC como esclavo

#define use_portc_lcd TRUE //Puerto c para uso del lcd

#include <LCDportc.c>

#include <RyP_COM.c> //Llamada a la librería de comunicación

/*************************** FUNCIÓN PRINCIPAL *******************************/

void main() {

/** Variables locales **/

byte Dato_Esclavo; //Variable para dato solicitado por el Maestro

byte Dato_Maestro; //Variable para dato recibido del Maestro

/** Inicialización LCD **/

lcd_init(); //Inicialización de LCD

/** Configuración de entradas y salidas **/

set_tris_c(0x00);

/** Configuración conversor AD **/

setup_adc_ports(AN0);

setup_adc(ADC_CLOCK_INTERNAL );

/** Mensaje en LCD **/

lcd_gotoxy(1,1);

printf(lcd_putc,"Esclavo");

while (true){

/** Lecura canal analógico 0 **/

set_adc_channel(0);

delay_us(20);

Dato_Esclavo = read_adc();

/** Visualización en LCD de las lecturas **/

lcd_gotoxy(1,2);

printf(lcd_putc,"M:%2x E:%2x ",Dato_Maestro,Dato_Esclavo );

delay_ms (10);

/** Comprobación si el Maestro solicita comunicación **/

Test_RyP_COM (Dato_Esclavo, Dato_Maestro);

}

[+/-] Ver / Ocultar código librería

/*****************************************************************************/

/* */

/* LIBRERÍA PARA COMUNICACIÓN ENTRE PICS POR BUS DE 4 LINEAS */

/* <RyP_COM.c> */

/* */

/* © Robotypic 2017 */

/* */

/*****************************************************************************/

/* Consiste en un sistema de comunicación entre PICs utilizando 4 pines: */

/* Mx_pin trasmite datos del Maestro al Esclavo */

/* EX_pin trasmite datos del Esclavo al Maestro */

/* Inicio_pin señal de inicio de la comunicación */

/* Sincro_pin señal de sincronización en la trasmisión de datos */

/* */

/* Condición:PIC Maestro y PIC Esclavo deben funcionar a la misma frecuencia */

/* de reloj. */

/* */

/* Se deben definir los pines deseados en el código principal. Si no se */

/* definen, por defecto quedan: */

/* #define Mx_pin PIN_B1 */

/* #define Ex_pin PIN_B2 */

/* #define Inicio_pin PIN_B3 */

/* #define Sincro_pin PIN_B4 */

/* */

/* Se debe definir si se trata del Maestro o Esclavo: */

/* #define MASTER 1 //Para el Maestro */

/* #define SLAVE 1 //Para el Esclavo */

/* */

/* Se debe cargar la librería: <RyP_COM.c> */

/* */

/* Para enviar un dato al esclavo, el maestro debe invocar la función: */

/* Tx_RyP_COM (Dato); //Dato es la variable que contiene valor a enviar */

/* Para solicitar un dato al esclavo, el maestro debe invocar la función: */

/* Rx_RyP_COM (Dato); //Dato es la variable que contiene valor recibido */

/* */

/* Para que Esclavo atienda a las solicitudes del Maestro se debe invocar */

/* periodicamente a a función: */

/* Test_RyP_COM (Dato1,Dato2); //Dato1 es dato enviado,Dato2 es dato recibido*/

/*****************************************************************************/

/** Variables globales **/

byte DatoM_RyP_COM;

/********************* CÓDIGO PARA MASTER ***********************************/

/*****************************************************************************/

#if (defined (MASTER)) && (MASTER == 1)

/** Definición de pines del bus por defecto **/

#ifndef Mx_pin

#define Mx_pin PIN_B1

#endif

#ifndef Ex_pin

#define Ex_pin PIN_B2

#endif

#ifndef Inicio_pin

#define Inicio_pin PIN_B3

#endif

#ifndef Sincro_pin

#define Sincro_pin PIN_B4

#endif

/**************************** FUNCIÓN ENVIO DATO *****************************/

/*****************************************************************************/

/* Función para el envío de un byte al esclavo */

/* Señal con Mx_pin. Bajo => Envío a esclavo. Alto => lectura del esclavo */

/* Pulso con Inicio_pin para aviso de comunicación al esclavo */

/* Espera de confirmación por Sincro_pin de aviso recibido por el esclavo */

/* Envío del byte bit a bit */

/*****************************************************************************/

void Tx_RyP_COM (int Dato){

/* Variables locales */

int mascara = 0x80;

int bit;

/** Indicación de envio (Bajo=>Envío,Alto=>Recepción) a esclavo **/

output_low (Mx_pin);

/** Señal de inicio **/

output_low (Inicio_pin);

output_high (Inicio_pin);

/** Confirmación del esclavo **/

while (!input_state(sincro_pin)){}; //Espera respuesta del esclavo

output_low (Inicio_pin); //Se deja Inicio_pin en bajo

/** Envío del byte de datos **/

for (bit=8; bit>=1; bit--){ //Para los 8 bits

if ((dato & mascara)>0) output_high(Mx_pin); //Si bit en curso es 1

else output_low (Mx_pin); //Si bit en curso es 0

mascara = mascara >> 1; //Preparación proximo bit

while(!input_state(Sincro_pin)){} //Espera a que esclavo lea el bit

}

output_low (Mx_pin); //Finalizado envío deja Mx_pin en bajo.

}

/************************** FUNCIÓN LECTURA DATO *****************************/

/*****************************************************************************/

/* Función para la lectura de un byte del esclavo */

/* Señal con Mx_pin. Bajo => Envío a esclavo. Alto => lectura del esclavo */

/* Pulso con Inicio_pin para aviso de comunicación al esclavo */

/* Espera de confirmación por Sincro_pin de aviso recibido por el esclavo */

/* Envío del byte bit a bit */

/*****************************************************************************/

void Rx_RyP_COM (int &DatoE_RyP_COM){

/* Variables locales */

int mascara = 0x80;

int mascara0 = 0;

int mascara1 = 0x01;

int temporal = 0;

int bit;

/** Indicación de lectura (Bajo=>Envío,Alto=>Recepción) del esclavo **/

output_high (Mx_pin);

/** Señal de inicio **/

output_low (Inicio_pin);

output_high (Inicio_pin);

/** Confirmación del esclavo **/

while (!input_state(sincro_pin)){}; //Espera respuesta del esclavo

output_low (Inicio_pin); //Se deja Inicio_pin en bajo

/** Fin de indicación de lectura al esclavo **/

output_low (Mx_pin); //Puesta en bajo bus Mx_pin

/** Control del Sincro_pin por el Maestro **/

output_low (Sincro_pin); //Asegura Sincro_pin a bajo

/** Lectura de los 8 bits del byte enviado por el Esclavo **/

for (bit=8; bit>=1; bit--){

delay_us (5); //Da tiempo a Master que ejecuteinstrucciones para mandar bit

if (input_state (Ex_pin)) temporal|=mascara1; //Si bit recibido es 1

else temporal|=mascara0; //Si bit recibido es 0

DatoE_RyP_COM=temporal; //Guarda recepción

temporal = temporal << 1; //Preparación para recibir siguiente bit

/** Maestro avisa a Esclavo de que ya ha leído el bit en curso**/

output_high (Sincro_pin);

output_low (Sincro_pin);

}

/** Maestro manda confirmación de byte completo leído **/

output_high (Mx_pin);

delay_us(10);

output_low (Mx_pin);

output_low (Mx_pin); //Asegura el estado bajo de Mx_pin al finalizar trasmisión

/* Sincro_pin control por esclavo **/

output_float (Sincro_pin);

}

/********************* CÓDIGO PARA ESCLAVO **********************************/

/*****************************************************************************/

#elif (defined (SLAVE)) && (SLAVE == 1)

/** Definición de pines del bus por defecto **/

#ifndef Mx_pin

#define Mx_pin PIN_B1

#endif

#ifndef Ex_pin

#define Ex_pin PIN_B2

#endif

#ifndef Inicio_pin

#define Inicio_pin PIN_B3

#endif

#ifndef Sincro_pin

#define Sincro_pin PIN_B4

#endif

/***************** FUNCIÓN ATENCIÓN A LA COMUNICACIÓN ************************/

/*****************************************************************************/

/* Función de atención a la comunicación solicitada por el Maestro */

/* Señal Inicio_pin en alto => Solicitud de comunicación por el Maestro */

/* Señal en Mx_pin. Bajo => Maestro va a enviar. Alto => Maestro va a leer */

/* Espera de confirmación por Sincro_pin de aviso recibido por el esclavo */

/* Envío del byte bit a bit */

/*****************************************************************************/

void TxR_Dato (int DatoE_RyP_COM, int &DatoM_RyP_COM ){

int mascara = 0x80;

int mascara0 = 0x00;

int mascara1 = 0x01;

int bit;

int temporal;

delay_us (5); //Espera a que termine master de ejecutar las instrucciones

/** Si Master ha puesto Mx_pin a 0 => Master va a enviar dato **/

if (!input_state (Mx_pin)){

/** Señal para aviso a master de que ya se ha leido estado de Mx_pin **/

output_high (Sincro_pin);

output_low (Sincro_pin);

/** Lectura de los 8 bits del byte enviado por el Master **/

for (bit=8; bit>=1; bit--){

delay_us (5); //Da tiempo a Master que ejecute instrucciones para mandar bit

if (input_state (Mx_pin)) temporal|=mascara1;

else temporal|=mascara0;

DatoM_RyP_COM=temporal;

temporal = temporal << 1;

/** Esclavo avisa a Master de que ya ha leído el bit **/

output_high (Sincro_pin);

output_low (Sincro_pin);

}

/** Esclavo manda confirmación de byte completo leído **/

output_high (Ex_pin);

delay_us(10);

output_low (Ex_pin);

}

/** Si Master ha puesto Mx_pin a 1 => Master va a leer dato **/

else {

/** Señal para aviso a master de que ya se ha leido estado de Mx_pin **/

output_high (Sincro_pin);

output_low (Sincro_pin);

output_float (Sincro_pin); //Sincro_pin control por el maestro

/** Envío del byte de datos **/

for (bit=8; bit>=1; bit--){

if ((DatoE_RyP_COM & mascara)>0) output_high(Ex_pin);

else output_low (Ex_pin);

mascara = mascara >> 1;

while(!input_state(Sincro_pin)){} //Espera a que esclavo lea el bit

}

output_low (Ex_pin); //Asegura el estado bajo de Ex_pin al finalizar

}

/***************** FUNCIÓN AVISO A ESCLAVO DE COMUNICACIÓN *******************/

/*****************************************************************************/

/* Función de aviso a esclavo de solicitud de comunicación del Master */

/* Si Maestro pone Inicio_pin en alto, esclavo responde a la solicitud de */

/* comunicación */

/*****************************************************************************/

void Test_RyP_COM (int Dato_Esclavo,int &DatoM_RyP_COM){

if (input_state (Inicio_pin)){TxR_Dato(Dato_Esclavo, DatoM_RyP_COM);}

}

/******************************************************************************/

#endif

Los archivos del proyecto se pueden descargar en este enlace:

Descargar archivos "Comunicación no estandar entre 2 pic"

El proyecto contenido en el artículo ha sido diseñado y probado con éxito utilizando las siguientes versiones de software:
- Windows 10 (64 bits)
- Proteus V7.7 SP2
- CCS PIC C COMPILER v5.015

Servidor Web con PIC18F4550 y ENC28j60

2015-07-13T21:35:00.000+02:00

En este proyecto se va a tratar un ejemplo básico de conexión de un PIC 18F4550 a una red ethernet por mediación del enc28j60. El control del PIC se realiza accediendo mediante una dirección IP que mostrará una página web, alojada en la propia memoria del PIC, y accesible con el explorador de internet desde cualquier dispositivo conectado a dicha red.

La web nos mostrará una página principal (\index). Desde ella podremos activar 3 salidas del PIC mediante sendos botones. También podremos enviar textos que veremos representados en un display lcd. Una página secundaria, accesible desde la principal, nos monitorizará las lecturas realizadas por el PIC (el canal analógico AN0 y el estado del bit 0 del puerto E).

Se va a mostrar el ejemplo simulándolo bajo proteus. Para ello, será necesario instalar WinPcap.

A la hora de crear el programa del PIC lo primero es especificar los criterios de configuración elegidos que se van a tener en cuenta a la hora de cargar el stack tcpip y que van a determinar que opciones van a ser utilizadas.

#define STACK_USE_ICMP 1 //Módulo de respuesta ICMP (ping)

#define STACK_USE_ARP 1 //Para solucionar direccionamiento MAC de las IP

#define STACK_USE_TCP 1 //Para enviar paquetes TCP

#define STACK_USE_HTTP 1 //Uso de las funciones http del stack.

#define STACK_USE_CCS_PICENS 1 //CCS PICENS 18F4620 + ENC28J60

#define STACK_USE_MCPENC 1 //Uso del enc28j60 por el stack (stacktsk.c)

#define STACK_USE_MAC 1 //Uso de la tarjeta de red

También hay que incluir el número de puerto, necesario cuando accedamos a través de internet.

#define HTTP_SOCKET 80 //Nº de puerto asociado al socket.

El PIC se comunica con el enc28j60 mediante el bus SPI. Para definir los pines del PIC que van a ser utilizados para este propósito existen 3 posibilidades:

Opción 1.

No definir nada, en cuyo caso se implementará una comunicación SPI por software y se tomará la definición de patillas establecida dentro del archivo enc28j60.c

#define PIN_ENC_MAC_SO PIN_D7

#define PIN_ENC_MAC_SI PIN_D6

#define PIN_ENC_MAC_CLK PIN_D5

#define PIN_ENC_MAC_CS PIN_D4

#define PIN_ENC_MAC_RST PIN_D3

#define PIN_ENC_MAC_INT PIN_D2

#define PIN_ENC_MAC_WOL PIN_D1

Opción 2.

Definir todas las patillas para la comunicación SPI, con lo que se implementará una comunicación SPI por software con la definición de patillas elegida. La definición existente dentro del archivo enc28j60.c será en este caso ignorada. Por ejemplo...

#define PIN_ENC_MAC_SO PIN_C4

#define PIN_ENC_MAC_SI PIN_C5

#define PIN_ENC_MAC_CLK PIN_B4

#define PIN_ENC_MAC_CS PIN_B5

#define PIN_ENC_MAC_RST PIN_B6

#define PIN_ENC_MAC_INT PIN_B7

Opción 3.

Habilitar el uso de SPI por hardware del PIC y definir las patillas ajenas al hardware del módulo SPI (CS, INT y RST). En este caso es imprescindible definir también la patilla SO para que el stack (dentro del archivo enc28j60.c) no habilite el SPI por software. Da igual que patilla SO se defina, la que se deberá cablear será la SO real, así como SI y CLK.

#define ENC_MAC_USE_SPI 1 //Uso del SPI por hardware

#define PIN_ENC_MAC_SO PIN_B0 //Entrada serie de datos

//#define PIN_ENC_MAC_SI PIN_C7 //Salida serie de datos(no necesario definir)

//#define PIN_ENC_MAC_CLK PIN_B1 //Señal de reloj (no necesario definir)

#define PIN_ENC_MAC_CS PIN_B2 //Chip select

#define PIN_ENC_MAC_RST PIN_B3 //Reset

#define PIN_ENC_MAC_INT PIN_B4 //Interrupción

Una observación. Aunque estamos definiendo también las patillas RST e INT, en este ejemplo, no van a ser cableadas.

Con todas las opciones definidas se puede cargar el stack tcpip.

#include "tcpip/stacktsk.c" //Carga el stack TCP/IP de Microchip

La dirección MAC identificará el dispositivo hardware dentro de la red. No puede haber, por tanto, dos dispositivos con la misma dirección MAC conectados a una misma red.

MY_MAC_BYTE1=0;

MY_MAC_BYTE2=2;

MY_MAC_BYTE3=3;

MY_MAC_BYTE4=4;

MY_MAC_BYTE5=5;

MY_MAC_BYTE6=6;

Esta asignación se ha definido dentro de la función MACAddrInit() a la que accederemos desde la función principal main(), antes de ejecutar las tareas del stack tcpip.

Lo mismo para la función IPAddrInit(). Dentro de la cual se ha especificado cual va a ser la dirección IP de nuestro servidor web, la dirección IP de la puerta de enlace y la máscara de subred.

//Elección de la dirección IP.

MY_IP_BYTE1=192;

MY_IP_BYTE2=168;

MY_IP_BYTE3=1;

MY_IP_BYTE4=15;

//Elección de la dirección de puerta de enlace.

MY_GATE_BYTE1=192;

MY_GATE_BYTE2=168;

MY_GATE_BYTE3=1;

MY_GATE_BYTE4=1;

//Elección de la máscara de subred.

MY_MASK_BYTE1=255;

MY_MASK_BYTE2=255;

MY_MASK_BYTE3=255;

MY_MASK_BYTE4=0;

Antes ejecutar las tareas del stack tcpip hay que inicializarlo:

StackInit(); //Inicializa el stack

Y posteriormente mantenerlo funcionando mediante un bucle infinito:

while(TRUE) {

StackTask();

}

Con el stack funcionando, cuando apliquemos la ip del servidor web en la barra de direcciones del explorador de internet de otro dispositivo conectado a la misma red, deberá aparecer la página que se encuentra contenida dentro del código del pic. De ello se encarga la función:

int32 http_get_page(char *file_str){}

Definida por el stack, localiza la posición de memoria dentro del PIC donde se encuentra el código correspondiente a la página solicitada. Previamente habremos diseñado la página web con código html y lo habremos introducido dentro del código del PIC como una constante. Tanto la página principal:

const char HTML_INDEX_PAGE[]=" "

Como la página secundaria:

const char HTML_LECTURAS_PAGE[]="
 "

Con la página cargada, la aplicación web ya puede interactuar con la aplicación del PIC. Aunque en realidad, recordemos que ambas conviven como parte del código en el propio PIC. Para ello se emplean otras dos funciones igualmente definidas por el stack.

La función:

void http_exec_cgi(int32 file, char *key, char *val) {}

Recibe los cambios producidos en la aplicación web y los refleja en el código del PIC. Dentro de ella, programaremos las actuaciones que deben ejecutarse en función de los cambios producidos en la página web. En nuestro caso, activar 3 salidas o recibir un texto para mostrar sobre el lcd.

Por ejemplo, la parte del código html que crea uno de los botones es:

</FORM>

Cuando en la aplicación web se pulsa dicho botón, se envía la información "boton1" por mediación de la variable key. En el código del PIC se detecta el cambio cuando dentro de la función se compara dicha información con ciertas variables preestablecidas. Si la información es coincidente con alguna de ellas, se ejecutará la actuación correspondiente.

static char boton1_key[]="boton1";

static char boton2_key[]="boton2";

static char boton3_key[]="boton3";

if (stricmp(key,boton1_key)==0) {

output_toggle(PIN_C0);

}

La otra función:

int8 http_format_char(int32 file, char id, char *str, int8 max_ret) {}

Informa a la aplicación web del estado de las variables medidas por el PIC. Dicha función ofrece los valores que han de representarse en la página web cuando ésta se carga. Por ejemplo, la parte del código referente a la representación del valor de la lectura del canal analógico:

Mostrará, por mediación de la función anterior, el valor de la variable virtual %0 que corresponderá con la lectura física del canal analógico del PIC.

case '0':

set_adc_channel(0);

delay_us(100);

AD0=read_adc();

sprintf(new_str,"0x%X",AD0);

len=strlen(new_str);

break;

[+/-] Ver / Ocultar código C PIC (Código principal)

////////////////////////////////////////////////////////////////////////////////

// //

// SERVIDOR WEB CON PIC 18F4550 Y ENC28J60 //

// //

// ccs PIC C compiler v4.104 //

// //

// (c) RobotyPic 2015 //

// //

////////////////////////////////////////////////////////////////////////////////

// Conmuta encendido-apagado de 3 leds controlados desde la aplicación web //

// Muestra variables leídas por el PIC: Canal analógico An0 y estado bit RE0 //

// Representa en lcd el texto introducido desde la aplicación web //

////////////////////////////////////////////////////////////////////////////////

#include <18F4550.h>

#device ADC=8

#use delay(clock=20000000)

#fuses HS,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,VREGEN,NOPBADEN,WRTB

#byte porte = 0xF84

/** Configuración para el uso del stack tcip **/

#define STACK_USE_ICMP 1 //Módulo de respuesta ICMP (ping)

#define STACK_USE_ARP 1 //Para solucionar direccionamiento MAC de las IP

#define STACK_USE_TCP 1 //Para enviar paquetes TCP

#define STACK_USE_HTTP 1 //Uso de las funciones http del stack.

#define STACK_USE_CCS_PICENS 1 //CCS PICENS (Embedded Ethernet) 18F4620 + ENC28J60

#define STACK_USE_MCPENC 1 //Uso del enc28j60 por el stack (stacktsk.c)

#define STACK_USE_MAC 1 //Uso de la tarjeta de red

#define HTTP_SOCKET 80 //Nº de puerto asociado al socket.

/********** Definición del patillaje de conexión al enc28j60 ******************/

/* Existen varias posibilidades:

Opción 1. No definir nada, en cuyo caso se implementará una comunicación SPI por

software y se tomarán la definición de patillas establecida en enc28j60.c

SO PIN_D7 ---- ENC >>>> PIC

SI PIN_D6 ---- PIC >>>> ENC

CLK PIN_D5

CS PIN_D4

RST PIN_D3

INT PIN_D2

WOL PIN_D1

Opción 2. Definir todas las patillas de la comunicación SPI, en cuyo caso se

implementará una comunicación SPI por software con la definición de patillas

elegida. Por ejemplo...

#define PIN_ENC_MAC_SO PIN_C4 //Entrada serie de datos

#define PIN_ENC_MAC_SI PIN_C5 //Salida serie de datos

#define PIN_ENC_MAC_CLK PIN_B4 //Señal de reloj

#define PIN_ENC_MAC_CS PIN_B5 //Chip select

#define PIN_ENC_MAC_RST PIN_B6 //Reset

#define PIN_ENC_MAC_INT PIN_B7 //Interrupción

Opción 3. El que aquí se ha utilizado, que consiste en habilitar el uso de SPI

por hardware del PIC y definir las patillas ajenas al hardware del módulo SPI

(CS, INT y RST). En este caso es imprescindible definir también la patilla SO

para que el stack (dentro de enc28j60.c) no habilite SPI por software. Da igual

que patilla SO se defina, la que se deberá cablear será la SO real del PIC */

#define ENC_MAC_USE_SPI 1 //Uso del SPI por hardware

#define PIN_ENC_MAC_SO PIN_B0 //Entrada serie de datos

//#define PIN_ENC_MAC_SI PIN_C7 //Salida serie de datos (no necesario definir)

//#define PIN_ENC_MAC_CLK PIN_B1 //Señal de reloj (no necesario definir)

#define PIN_ENC_MAC_CS PIN_B2 //Chip select

#define PIN_ENC_MAC_RST PIN_B3 //Reset

#define PIN_ENC_MAC_INT PIN_B4 //Interrupción

/******************************************************************************/

#define use_portd_lcd TRUE //Uso del puerto d para control del lcd

#include <LCD420PIC18F_RyP.c> //Carga librería del lcd de 4x20 para familia 18F

#include "tcpip/stacktsk.c" //Carga el stack TCP/IP de Microchip

/********************* PAGINA WEB A MOSTRAR **********************************/

/* Página principal INDEX (/) */

const char HTML_INDEX_PAGE[]="

<center><H1>Servidor WEB con PIC 18f4550 </H1></center>

<BR><center><H2>ROBOTYPIC</H2></CENTER>

</FORM>

</FORM>

</FORM>

</FORM>

<P><A HREF=\"/lecturas\">Lecturas del PIC</A>

</BODY></HTML>

/* Página secundaria (\lecturas). Accesible desde la página principal */

const char HTML_LECTURAS_PAGE[]="

<center><H1>Servidor WEB con PIC 18f4550 </H1></center>

<BR><center><H2>ROBOTYPIC</H2></CENTER>

<br><center>LECTURAS</center>

<BR/>

<BR/>

</BODY></HTML>

/* Elección de MAC. No puede haber 2 dispositivos con misma MAC en una misma red

Microchip Vendor ID MAC: 00.04.A3.xx.xx.xx. */

void MACAddrInit(void) {

MY_MAC_BYTE1=0;

MY_MAC_BYTE2=0x04;

MY_MAC_BYTE3=0xA3;

MY_MAC_BYTE4=0x06;

MY_MAC_BYTE5=0x07;

MY_MAC_BYTE6=0x08;

}

void IPAddrInit(void) {

//Elección de la dirección IP.

MY_IP_BYTE1=192;

MY_IP_BYTE2=168;

MY_IP_BYTE3=1;

MY_IP_BYTE4=15;

//Elección de la dirección de puerta de enlace.

MY_GATE_BYTE1=192;

MY_GATE_BYTE2=168;

MY_GATE_BYTE3=1;

MY_GATE_BYTE4=1;

//Elección de la máscara de red.Si no se indica nada se tomará 255.255.255.0

MY_MASK_BYTE1=255;

MY_MASK_BYTE2=255;

MY_MASK_BYTE3=255;

MY_MASK_BYTE4=0;

}

/*************************** FUNCIÓN GET PAGE ******************************/

/* Esta función devuelve la posición de memoria donde se encuentra la página web

a mostrar. En este caso se trata de una web con 2 páginas. Una principal index(/)

y una secundaria(/lecturas) */

int32 http_get_page(char *file_str) {

int32 file_loc=0;

static char index[]="/";

static char lecturas[]="/lecturas";

printf(lcd_putc,"\fRequest %s ",file_str); //Muestra en lcd solicitud

/* Busca la posición de memoria donde se encuentra la página solicitada */

if (stricmp(file_str,index)==0) //Si es la principal...

file_loc=label_address(HTML_INDEX_PAGE); //...toma su posición en la memoria

else if (stricmp(file_str,lecturas)==0) //O si es la secundaria...

file_loc=label_address(HTML_LECTURAS_PAGE); //...toma su posición en la memoria

/* Muestra en lcd la página solicitada */

if (file_loc){ //Si existe...

printf(lcd_putc,"\n(FILE=%LU)",file_loc); //...muestra en lcd pos. de memoria

}

else{ //Si no existe...

printf(lcd_putc,"\n(File Not Found)"); //...muestra en lcd mensaje

}

/* Devuelve la posición en la memoria donde se encuentra la página a mostrar */

return(file_loc);

}

/************************** FUNCIÓN FORMAT CHAR *****************************/

/* Con la función http_format_char interconectamos las variables virtuales de

la página web con las variables del programa del PIC. Se encarga de enviar los

cambios producidos en la aplicación del PIC y reflejarlos en la aplicación web.

Muestra,por tanto, las lectura obtenidas por el PIC y las representa en la

aplicación de la página web

%0 es la variable virtual para representar el valor de la lectura del canal

analógico

%1 es la variable virtual para representar el valor de la lectura del bit 0 del

puerto E.

int8 http_format_char(int32 file, char id, char *str, int8 max_ret) {

char new_str[20];

int8 len=0;

int8 AD0;

int8 RE0;

*str=0;

switch(id) {

case '0':

set_adc_channel(0);

delay_us(100);

AD0=read_adc();

sprintf(new_str,"0x%X",AD0);

len=strlen(new_str);

break;

case '1':

RE0=bit_test(porte,0);

sprintf(new_str,"%d",RE0);

len=strlen(new_str);

break;

default:

len=0;

}

if (len)strncpy(str, new_str, max_ret);

else *str=0;

return(len);

}

/*************************** FUNCIÓN EXEC CGI ******************************/

/* Con la función http_exec_cgi interconectamos las variables virtuales de la

página web con las variables del programa del PIC. Se encarga de recibir

los cambios producidos en la aplicación web y reflejarlos en el hardware del PIC.

Ejecuta, por tanto, la acción elegida según el valor de la variable virtual recibida

de la página web

key es la variable virtual que viene de la pagina web

val es el valor de una variable virtual de la página web

file es la dirección de la página web devuelta por http_get_page ()

void http_exec_cgi(int32 file, char *key, char *val) {

static char boton1_key[]="boton1";

static char boton2_key[]="boton2";

static char boton3_key[]="boton3";

static char lcd_key[]="lcd";

printf(lcd_putc,"\fCGI FILE=%LD", file);

printf(lcd_putc,"\nKEY=%S", key);

printf(lcd_putc,"\nVAL=%S", val);

/* Se ejecutará al pulsar el botón "Botón 1" en la aplicación web */

if (stricmp(key,boton1_key)==0) {

output_toggle(PIN_C0);

}

/* Se ejecutará al pulsar el botón "Botón 2" en la aplicación web */

if (stricmp(key,boton2_key)==0) {

output_toggle(PIN_C1);

}

/* Se ejecutará al pulsar el botón "Botón 3" en la aplicación web */

if (stricmp(key,boton3_key)==0) {

output_toggle(PIN_C2);

}

/* Se ejecutará al pulsar el botón "Enviar texto" en la aplicación web */

if (stricmp(key,lcd_key)==0) {

printf(lcd_putc,"\f%s",val); //Muestra en el lcd el texto recibido

}

/************************** FUNCIÓN PRINCIPAL *********************************/

void main(void) {

/* Habilitación y configuración del canal analógico 0 */

setup_adc(ADC_CLOCK_INTERNAL);

setup_adc_ports(AN0);

set_adc_channel(0);

delay_ms(1);

/*Reset de las salidas */

output_low(PIN_C0);

output_low(PIN_C1);

output_low(PIN_C2);

/* Inicialización del lcd */

lcd_init();

printf(lcd_putc,"\fROBOTYPIC WEB SERVER"); //Mensaje de inicio en lcd

delay_ms(1000);

/* Inicialización del Stack */

MACAddrInit(); //Se asigna la dirección MAC elegida

IPAddrInit(); //Se asigna IP, mascara de red y puerta de enlace elegidos

StackInit(); //Inicializa el stack

/* Muestra la IP elegida en lcd */

printf(lcd_putc,"\n\n IP: %u.%u.%u.%u", MY_IP_BYTE1, MY_IP_BYTE2, MY_IP_BYTE3, MY_IP_BYTE4);

printf(lcd_putc,"\n %u", HTTP_SOCKET);

delay_ms(10);

while(TRUE) {

StackTask();

}

Para hacerlo funcionar, conectamos el PIC a la red ethernet del router. Desde otro dispositivo conectado a la misma red (al router), en la barra de direcciones del explorador, tecleamos la dirección IP que hemos asignado a nuestro servidor web (162.168.1.15). Si todo va bien nos aparecerá la página que hemos cargado en el PIC y desde la que podremos interactuar.

En esta simulación se ha visto como acceder al PIC desde un dispositivo conectado a la red ethernet interna. Si lo que queremos es acceder desde el exterior por internet, en la barra de direcciones del explorador deberemos escribir la dirección IP con la que se identifica nuestro router en internet y el número de puerto (puerto 80). Por ejemplo 87.64.15.102:80

Previamente, deberemos haber configurado el router de forma que redirija el trafico que le llega desde el exterior hasta el servidor web. En dicha configuración, tendremos que abrir el puerto 80 TCP para la dirección IP del servidor web (192.168.1.15).

Para saber la dirección IP de nuestro router en internet, podemos ayudarnos de muchas páginas que nos la pueden proporcionar. Una de ellas es http://www.cualesmiip.com/.

Esquema completo para el montaje real:

Descarga de los archivos del proyecto:

Webserver PIC18F4550+ENC28j60

El proyecto contenido en el artículo ha sido diseñado y probado utilizando las siguientes versiones de software:

- Windows xp, windows 7 (32 bits) y windows 8 (64 bits)

- Proteus V7.7 SP2

- CCS PIC C COMPILER v4.104

Artículo relacionado>> Servidor Web PIC18f4620+enc28j60

Servidor Web con PIC18F4620 y ENC28J60 con wizard de CCS

2015-07-13T21:34:00.003+02:00

En este proyecto se va a mostrar la creación de un Servidor Web, similar al del artículo "Servidor Web con PIC18F4550 Y ENC28j60", aunque en este caso mediante el uso del wizard del ccs PIC c compiler de la versión v5.15. El control del PIC se realiza igualmente por medio de una página web, alojada en la propia memoria del PIC, y accesible desde cualquier dispositivo, conectado a la red.

La página que se va a crear para permitir el acceso al control del PIC consistirá en 2 botones que nos permitirán activar dos salidas en el PIC, conmutando entre el encendido y apagado de unos leds. Por otro lado monitorizará la lectura del canal analógico AN0.

El wizard nos va a crear el código del PIC y la propia página web. Lo único que deberemos programar es lo que queramos que ocurra cuando pulsemos los botones en la web (conmutar las salidas en el PIC) o lo que queramos que aparezca en la misma proporcionado por los eventos ocurridos en el PIC (mostrar el valor de la lectura de una entrada analógica). En los comentarios del código del PIC generado por el wizard, identificaremos rápidamente dónde debemos colocar nuestro propio código.

En este ejemplo emplearemos la versión v5.015 del ccs pic c compiler. La opción del servidor web en el wizard no está disponible en las primeras versiones del ccs v5, y por tanto tampoco en ninguna de las del ccs v4.

Se va a mostrar el ejemplo simulado bajo proteus, para ello habrá que instalar WinPcap. Software que se puede descargar gratuitamente.

En la siguiente animación se muestra todo el proceso de configuración con el wizard para la creación del código del PIC y la página web asociada.

No obstante, se expone a continuación paso a paso todo el proceso:

Ejecutar CCS PIC C compiler.

En el menú seleccionar <File> <new> <Project Wizard>

Indicar el nombre y ruta donde guardar el proyecto con los archivos que se van a generar.

Se abre la pantalla del Wizard. En la opción “Device” elegiremos el PIC deseado. En este caso hemos optado por el PIC18F4620. Este es uno de los permitidos por el Wizard. No todos son admitidos a la hora de compilar.

En la opción “Analog” elegimos la entrada analógica que vamos a emplear (AN0) y el número de bits (8bits => 0-255)

En la opción “TCP/IP” marcamos “use TCP/IP”. Al hacerlo nos permitirá elegir el uso del ENC28J60, elegir la dirección MAC y seleccionar los pines del PIC para el bus SPI. EN concreto para el reset (B3 en este ejemplo) y para el Chip select (B2). El resto de los pines del bus SPI no se pueden cambiar puesto que al usar el módulo hardware se emplearán los pines físicos propios del bus.

Continuando dentro de “TCP/IP”, en la pestaña “IP” desmarcamos “use DHCP” que nos permitirá elegir las direcciones IP (192.168.1.15), puerta de enlace (192.168.1.1) y máscara de subred (255.255.255.0)

Sin salir de “TCP/IP”, en la pestaña “Webserver”, seleccionando “use http Server”, podremos indicar cuantos campos de lectura del PIC y los botones a mostrar en la web.

Elegidas todas estas opciones podemos pulsar ya el botón <Create Project>. Aparecerá el código del archivo fuente principal creado. Sobre este código deberemos programar los efectos que queramos que ocurran al pulsar los botones en la web por ejemplo.

La información procedente del PIC que queramos que aparezca en la web la programaremos dentro de la función http_format_char(). A continuación muestro el código resultante de dicha función. En rojo, el código que hemos creado para leer el canal analógico y enviarlo a la web. El resto de código es el propio creado por el wizard.

unsigned int8 http_format_char(char* file, char id, char *str, unsigned int8 max_ret)

{

char new_str[20];

int8 len=0;

int8 AD0;

/* TODO: This is a callback function to the HTTP stack.

'id' is the char for the dynamic element to be updated.

For each dynamic element you create, you need to parse

and save a result to 'str'. *str is where the callback

function must save the formatting result, and it should

not store more than max_ret characters to this pointer

(buffer-overrun protection).

Example:

switch(id) {

case 0x00:

set_adc_channel(0);

delay_us(100);

i=read_adc();

sprintf(new_str,"0x%X", i);

.....

strncpy(str, new_str, max_ret);

if (id == 0)

{

//TODO: Handle dyn0 field and save result to str

set_adc_channel(0);

delay_us(100);

AD0=read_adc();

sprintf(new_str,"0x%X",AD0);

len=strlen(new_str);

strncpy(str, new_str, max_ret);

}

Dentro de la función http_exec_cgi() escribiremos el código de lo que queramos que ocurra cuando se pulsan los botones en la web. Cambiaremos el estado de dos de los pines del PIC para encender y apagar unos leds. Como en el caso anterior, en rojo se ha representado el código introducido manualmente. Una vez más, los comentarios generados por el wizard nos ayudan a saber dónde se debe colocar.

void http_exec_cgi(char* file, char *key, char *val)

{

/* TODO: This is a callback function to the HTTP stack.

This function is called with each key/value pair read in

the GET/POST request before any web data is sent to the

web browser. 'key' matches the name of the field and

'val' is the value it was changed to.

Example:

int8 v = atoi(val);

if (stricmp(key,led1_key)==0)

LedSet(0, v);

if (strcmp(key, "button00") == 0)

{

//TODO: Handle button00

output_toggle(PIN_C0);

}

if (strcmp(key, "button01") == 0)

{

//TODO: Handle button01

output_toggle(PIN_C1);

}

Con esto ya funcionaría nuestro ejemplo. No hemos intervenido para nada en la programación de la página web. Todo el código html lo ha creado el wizard. Ahora bien, quizá deseemos modificar el código creado para personalizar el diseño a nuestro gusto o adaptarlo a nuestra necesidad. Detallo a continuación el procedimiento para hacerlo. No se trata de mostrar como programar una aplicación web, sino del proceso a seguir para compilar de nuevo el ejemplo una vez modificada la página web creada.

Deberemos localizar el archivo “index.html” que se ha creado dentro de la carpeta “pages” en el directorio donde se nos ha compilado el proyecto. Este archivo es la página web que el wizard ha creado.

Para modificarlo, debemos abrirlo con cualquier editor HTML como PageBreeze, Microsoft Office FrontPage, etc. Una vez modificado guardar los cambios.

Ahora se debe cargar el nuevo diseño web en el código del PIC. Para ello ejecutamos el archivo “make mpfsimg” también creado en el mismo directorio del proyecto.

Compilamos una vez más el archivo fuente con el ccs pic c compiler.

Al ejecutar de nuevo el proyecto deberemos ver los cambios producidos en la web.

Para hacerlo funcionar, ya sea con la web personalizada o la creada originalmente, en la barra de direcciones del explorador web de cualquier dispositivo conectado a la misma red ethernet, tecleamos la dirección IP que hemos asignado a nuestro servidor (162.168.1.15). Aparecerá la página que hemos cargado en el PIC.

Cuando queramos acceder desde el exterior por internet, en la barra de direcciones del explorador deberemos escribir la dirección IP con la que se identifica nuestro router en internet y el número de puerto (puerto 80). Por ejemplo 87.64.15.102:80

Es necesario haber configurado el router de forma que redirija el trafico que le llega desde el exterior hasta el servidor web. Deberemos abrir el puerto 80 TCP para la dirección IP del servidor web (192.168.1.15).

La dirección IP de nuestro router en internet, la podremos obtener por mediación de alguna de las muchas páginas que nos la pueden proporcionar. Una de ellas es http://www.cualesmiip.com/.

El esquema completo para un montaje real:

Descarga de los archivos del proyecto:

Servidor Web PIC18f4620+ENC28j60

El proyecto contenido en el artículo ha sido diseñado y probado utilizando las siguientes versiones de software:

- Windows xp, windows 7 (32 bits) y windows 8 (64 bits)

- Proteus V7.7 SP2

- CCS PIC C COMPILER v5.015

Artículo relacionado>> Servidor Web PIC18F4550+enc28j60

CMUcam4 con PIC

2013-10-27T18:37:00.000+01:00

En el artículo "CMUcam4 controlado por un PC" se ha mostrado como contactar con una CMUcam4 desde un PC con la intención de tener un primer contacto y familiarizarnos con ella. Aquí, las actuaciones que en ese artículo se han mostrado desde el PC las vamos a realizar controlando la cámara con un PIC. Es decir, vamos a rastrear un objeto de un color concreto con la cámara soportada por los servos PAN y TILT. Los comandos enviados así como la respuesta recibida de la cámara lo mostraremos en un LCD.

Para la conexión eléctrica del PIC con la CMUcam hay que tener en cuenta un detalle muy importante. En la comunicación serie, los datos son transmitidos por el PIC a 5V. Sin embargo, los datos recibidos los envía la CMUcam a niveles en torno a los 3,3V, por lo que aunque la tarjeta de la cámara entiende los comandos del PIC, éste no es capaz de descifrar la información que recibe de la CMUcam y en el LCD aparecen caracteres ilegibles. Por tanto va a ser necesario pasar esos niveles de 3,3V a niveles de 5V detectables por el PIC bien por comparadores, puertas AND, etc., o como aquí se ha hecho, con el MAX232 conectado como se ve en el esquema.

Se han empleado algunos comandos. La totalidad de ellos con su descripción y forma de usarlo se puede consultar en la documentación técnica del componente.

Para programar el PIC, por tanto, habrá que configurar la conexión serie con las características que por defecto lleva la CMUcam.

#use rs232(baud=19200,xmit=pin_c6,rcv=pin_c7,bits=8,stop=1,parity=n, errors)

Hay que considerar que la CMUcam tarda más tiempo en reiniciarse que el PIC. Le daremos un tiempo antes de enviar el primer comando para evitar que se bloquee. Aquí, mientras espera, muestra un mensaje en el LCD.

/** Espera hasta que CMUcam se reinicie **/

printf(lcd_putc, "\f Iniciando... ");

delay_ms (6000); //Tiempo para inicio de la CMUcam

En esta demostración se envían varios comandos antes de rastrear el objeto como muestra de cual es la respuesta de la cámara. Solicitamos obtener la versión.

/** Valor del la versión de la CMUcam **/

strcpy (CMUcam_comando, "GV"); //En CMUcam_comando se guarda comando

puts(CMUcam_comando); //Envío del comando a la CMUcam

strcpy guarda la cadena GV en la variable CMUcam_comando. Y luego se envía por el puerto serie a la cámara con puts. Estas dos instrucciones C pueden sustituirse por una sola:

puts("GV"); //Envío del comando a la CMUcam

Pero el comando que enviamos a la cámara lo guardamos en una variable para mostrarlo también en el LCD.

/** Muestra los primeros 16 caracteres del comando en la primera línea **/

for(i=0;i<strlen(CMUcam_comando);i++)

printf(lcd_putc,"%c",CMUcam_comando[i]);

/** Muestra los caracteres posteriores al 16 recibidos en la segunda línea **/

if (strlen(CMUcam_comando)>16){

lcd_gotoxy(1,2); //En 2ª linea y 1ª columna del LCD...

for(i=16;i<strlen(CMUcam_comando);i++)

printf(lcd_putc,"%c",CMUcam_comando[i]);

}

strlen nos dice cuantos caracteres tiene la cadena contenida en CMUcam_comando para imprimir en el LCD los 16 primeros en la primera linea y el resto en la segunda.

El siguiente comando solicita la lectura de los valores umbral del color a rastrear. Por defecto la cámara ajusta todo el rango de 0 a 255 de cada uno de los 3 colores primarios.

/** Valores actuales umbral rastreo de color **/

strcpy (CMUcam_comando, "GT"); //En CMUcam_comando se guarda comando

puts(CMUcam_comando); //Envío del comando a la CMUcam

A continuación se envía a la cámara los valores umbral deseados correspondientes al color del objeto que vamos a rastrear. Hasta ahora los comandos ejecutados no eran imprescindibles, se trataba tan solo de una demostración, pero este comando si es necesario. Estos valores umbral se han obtenido con el software CMUcam4GUI tal como se muestra en el artículo "CMUcam4 controlada desde un PC".

/** Fija nuevos valores umbral rastreo de color **/

strcpy (CMUcam_comando, "ST 58 107 152 188 46 97");/

puts(CMUcam_comando); //Envío del comando a la CMUcam

Ahora, en el programa ejemplo, hacemos de nuevo una lectura de los valores umbral como se ha hecho antes para verificar que han sido adquiridos por la cámara. Normalmente suelen variar algo con respecto a los enviados.

El siguiente paso es poner los servos PAN y TILT en modo automático.

/** Control automático del servo PAN para rastreo de color **/

strcpy (CMUcam_comando, "AP 1 1"); //En CMUcam_comando se guarda comando

puts(CMUcam_comando); //Envío del comando a la CMUcam

/** Control automático del servo TILT para rastreo de color **/

strcpy (CMUcam_comando, "AT 1 1"); //En CMUcam_comando se guarda comando

puts(CMUcam_comando); //Envío del comando a la CMUcam

Se ha empleado el modo inverso puesto que los servos empleados así lo requerían. Cuando el servo en cuestión se desplaza en sentido contrario al movimiento del objeto hay que cambiarle el modo de funcionamiento de directo a inverso.

Ahora mismo la cámara está lista para detectar el objeto cuyo color hemos definido. En un bucle while() además vamos a leer y mostrar en un LCD las posiciones de los servos a tiempo real. Primero la del servo TILT...

/** Lectura del valor del pulso de control servo TILT en mseg.**/

puts("GS 0"); //Envío del comando a la CMUcam

//Si el 4º caracter recibido no es un número lo borra del buffer recepción

if((CMUcam_recepcion[3]<48)||(CMUcam_recepcion[3]>57))CMUcam_recepcion[3]=' ';

lcd_gotoxy(1,1); //En primera linea y primer caracter del LCD...

//...muestra valor obtenido

printf(lcd_putc,"Servo TILT: %c%c%c%c", CMUcam_recepcion[0], CMUcam_recepcion[1], CMUcam_recepcion[2], CMUcam_recepcion[3]);

...y a continuación en la segunda línea del LCD la del servo PAN.

/** Lectura del valor del pulso de control servo PAN en mseg.**/

puts("GS 1"); //Envío del comando a la CMUcam

//Si el 4º caracter recibido no es un número lo borra del buffer recepción

if((CMUcam_recepcion[3]<48)||(CMUcam_recepcion[3]>57))CMUcam_recepcion[3]=' ';

lcd_gotoxy(1,2); //En segunda linea y primer caracter del LCD...

//...muestra valor obtenido

printf(lcd_putc,"Servo PAN: %c%c%c%c", CMUcam_recepcion[0], CMUcam_recepcion[1], CMUcam_recepcion[2], CMUcam_recepcion[3]);

Solo se mostrarán los caracteres numéricos, es decir, se evitará mostrar el carácter ":" con el que finaliza el envío la CMUcam.

Para la recepción de datos de la CMUcam se ha habilitado la interrupción por recepción serie.

enable_interrupts(int_rda); // Habilita Interrupción RDA

Cuando el PIC detecta que ha recibido algo, salta a la función de la interrupción. Allí obtiene el último carácter recibido y lo añade al buffer de recepción donde se guarda la cadena de texto completa de respuesta de la CMUcam.

siguiente_caracter=getc(); // se descarga y ...

//...se añade el caracter recibido al Buffer de recepción

CMUcam_recepcion[indice_buffer]=siguiente_caracter;

Después de recibir un carácter, se incrementa su indice en 1 para dejarlo preparado para la recepción del siguiente de la cadena de texto completa.

/** Indice del buffer para el próximo caracter a recibir **/

indice_buffer++;

Dentro de la cadena de texto recibida, se encuentra el ACK o NCK. Estos 3 caracteres son extraídos y guardados en un buffer aparte para ser tratados de la forma que más convenga.

/** Si recibe ACK o NCK lo guarda en un buffer aparte **/

if (CMUcam_recepcion[indice_buffer]=='K'){

if (CMUcam_recepcion[indice_buffer-1]=='C'){

if (CMUcam_recepcion[indice_buffer-2]=='A'){

strcpy (CMUcam_ACK, "ACK"); //En CMU_ACK se guarda texto 'ACK'

for (i=indice_buffer-2;i<=indice_buffer;i++)CMUcam_recepcion[i]=' ';

indice_buffer=255; //Reinicio del indice del buffer

}

else if (CMUcam_recepcion[indice_buffer-2]=='N'){

strcpy (CMUcam_ACK, "NCK"); //En CMU_ACK se guarda texto 'NCK'

for (i=indice_buffer-2;i<=indice_buffer;i++)CMUcam_recepcion[i]=' ';

indice_buffer=255; //Reinicio del indice del buffer

}

En este ejemplo, este ACK o NCK tan solo se muestra en las últimas posiciones del LCD separados del resto de la cadena recibida.

/** Muestra ACK o NCK en los 3 últimos dígitos del LCD **/

lcd_gotoxy(14,2); //En 2ª linea y columna 14 del LCD...

printf(lcd_putc,"%s",CMUcam_ACK);

[+/-] Ver / Ocultar programa completo en C

En este vídeo se muestra el resultado de todo lo hasta aquí argumentado.

Y en este enlace de descarga disponibles todos los archivos y documentación.

Descargar CMUcam4 con PIC

Artículo relacionado>> Control CMUcam4 desde un PC

El proyecto contenido en el artículo ha sido diseñado y probado utilizando estas versiones de software:
- Windows 7
- CCS PIC C COMPILER v4.084

CMUcam4 controlada desde un PC

2013-10-27T18:13:00.000+01:00

Aunque la intención es controlar la CMUcam4 con PIC, en este artículo se va a tratar de conectar la cámara a un PC. En primer lugar mediante el software CMUcam4GUI proporcionado por el fabricante. Con este software, además de comprobar el funcionamiento de la cámara de una forma sencilla, nos va a permitir familiarizarnos con el componente, ya que prácticamente todos los controles de los que el software dispone de una manera gráfica, son los que podemos emplear con el PIC en forma de comandos.

La conexión de comunicación al PC se realiza por el puerto serie. Para ello, y como viene siendo habitual en las comunicaciones serie con el PC, será necesario adaptar los niveles de tensión del bus mediante un circuito externo como puede ser un MAX232.

Energizamos ahora todo el conjunto. Se encenderá el led verde de la tarjeta de la CMUcam como testigo de que está alimentada. Transcurridos unos segundos se encenderá el led rojo, indicando que la CMUcam está ya operativa.

Ejecutamos el software de testeo de la CMUcam4 en el PC. Pulsamos el botón verde del menú superior "Begin" para realizar la conexión a la cámara. En el desplegable que aparece hay que elegir el puerto COM al que está conectada en el PC y aceptamos. Inmediatamente a continuación pulsamos el botón "Reset" de la CMUcam4 para que se reinicie y se conecte. Puede ser necesario pulsar varias veces hasta conseguirlo. Detectaremos que queda comunicada con el PC cuando el botón "End" del menú pasa de un estado inactivo de color gris a un estado activo y de color rojo.

Con PC y cámara en comunicación se puede ya ejecutar su control. En el vídeo que se muestra a continuación se representa el proceso de configuración para detectar un objeto por su color.

Dentro del software de control, en la sección "tracking Parameters" de la pestaña "options", podemos ver los valores umbral de los colores del objeto capturado. Estos valores nos servirán para introducirlos como argumento de comando con el PIC o mediante Terminal serie mostrado más adelante de este artículo.

Si ademas queremos usar los servos PAN & TILT, la CMUcam4 dispone de los conectores para que la propia tarjeta realice la función de seguimiento con dichos servos. La tarjeta tiene, junto a los conectores de los servos, los pines para aplicarles la tensión de alimentación que les corresponda según el tipo de servo empleado. La alimentación de estos servos por estos pines no alimenta al resto de componentes de la tarjeta. Es una alimentación independiente.

En este otro vídeo se muestra el proceso de configuración para realizar el rastreo con estos servos. Como se muestra al final del vídeo, se pueden controlar también de una forma manual.

Existen otras muchas opciones pero aquí lo que se pretende es tener un primer contacto con la cámara o verificar su funcionamiento antes de pasar a controlarla con un PIC.

Siguiendo con esta intención, mostramos ahora como controlarla mediante comandos utilizando un visor de puerto serie como puede ser el hyperterminal u otro similar. Aquí vamos a utilizar el "Parallax Serial Terminal (PST)" que es el que recomienda el fabricante en la documentación y que además es de uso libre. Esta es la forma más parecida al control con un PIC.

Ejecutamos el programa para comunicación por el puerto serie. Se selecciona el puerto COM al que está conectada la cámara y se elige una velocidad de 19200 baudios.

Habilitamos la comunicación y pulsamos el botón Reset de la tarjeta de la CMUcam. Se debería establecer la comunicación entre PC y CMUcam. Lo confirmaremos cuando en el escritorio del programa visor aparezca la versión del componente.

A partir de este momento ya podemos enviar comandos a la tarjeta de la cámara. Estos comandos consistirán en dos caracteres ASCII seguidos de su argumento cuando lo necesiten y la confirmación con un "ENTER" (Retorno de carro). Si la cámara entiende el comando, responderá con un ACK y la información solicitada a continuación, si es el caso. Si no entiende el comando responderá con un NCK o con ERR seguido de la descripción del error producido.

La lista de todos los comandos y de su uso junto a sus argumentos se pueden ver en la documentación del fabricante. Aquí se van a probar algunos de ellos. En concreto, lo que se va a hacer es configurar la CMUcam para seguimiento del color con los servos, tal como se ha hecho con el software gráfico, pero en este caso por comandos.

El proceso puede verse en este vídeo.

Se puede ver que con el comando "ST" se introducen unos valores numéricos. Estos valores corresponden a los valores que obtenemos con el software CMUcam4GUI en la captura del color que queremos rastrear.

Librería C para sensor SHT11 con PIC

2013-09-14T23:20:00.000+02:00

Se trata de una librería C, SHTxx_RyP.c, para el control del sensor SHT11 con un PIC. Un ejemplo de su aplicación se puede ver en el artículo: "Sensor de temperatura y humedad SHT11 con PIC". Es válida para toda la gama de sensores SHT10, SHT11, SHT15, SHT71 y SHT75.
Cuando se emplee la versión v3 o v4 del sensor SHT71 o SHT75, la librería alternativa es SHT7xv3_RyP.c que contiene los coeficientes de cálculo adecuados correspondientes a dichas versiones.

Dentro de la librería C encontraremos el código estructurado en diferentes secuencias y funciones.

La SECUENCIA DE INICIO DE TRANSMISIÓN consistente en:

- Poner a “0” la línea DATA mientras SCK está a “1”.

- Poner a “0” SCK mientras DATA continua a “0”.

- Volver a poner a “1” SCK sin cambiar el estado de DATA

- Finalmente pasar DATA a “1” mientras SCK está a “1”

/** secuencia de inicio de transmisión **/

void SHTxx_InicioTrans (void) {

//DATA a "0" con SCK a "1"

output_float(sht_data_pin); //línea DATA a "1"

output_low(sht_sck_pin); //línea SCK a "0"

delay_us(1);

output_high(sht_sck_pin); //línea SCK a "1"

delay_us(1);

output_low(sht_data_pin); //línea DATA a "0"

delay_us(1);

//SCK a "0" sin cambiar DATA "0"

output_low(sht_sck_pin); //línea SCK a "0"

delay_us(2);

//SCK a "1" sin cambiar DATA "0"

output_high(sht_sck_pin); //línea SCK a "1"

delay_us(1);

//DATA a "1" con SCK a "1"

output_float(sht_data_pin); //línea DATA a "1"

delay_us(1);

output_low(sht_sck_pin); //línea SCK a "0"

}

La SECUENCIA DE RESET resetea solo la interface, los registros de estado mantienen sus valores. Consiste en:

- Con la línea DATA puesta a “1”, conmutar 9 o más veces la línea SCK entre “0” y “1”.

- Debe seguirle una secuencia de Inicio.

/** secuencia de reset **/

void SHTxx_Reset (void) {

int i;

//inicio de secuencia con SCK a “0” y DATA a “1”

output_float(sht_data_pin); //línea DATA a “1”

output_low(sht_sck_pin); //línea SCK a “0”

delay_us(2);

//conmuta SCK 9 veces con DATA a “1”

for(i=0; i<9; i++) {

output_high(sht_sck_pin);

delay_us(2);

output_low(sht_sck_pin);

delay_us(2);

}

/** secuencia de inicio de transmisión **/

SHTxx_InicioTrans ();

}

Con la SECUENCIA DE ENVIO DE COMANDO se le indica al sensor la actuación que debe realizar. Son comandos de 5 bits pero se debe enviar un byte completo (8 bits), 3 bits de dirección A0 a A2 y los 5 bits del comando C0 a C4. Los bits de dirección solo permiten valor “0”.

COMANDO	Código en binario	Código hex.
Reservado	0000x	--
Medida de Temperatura	00011	0x03
Medida de Humedad Relativa	00101	0x05
Lectura del Registro de Estado	00111	0x07
Escritura en registro de Estado	00110	0x06
Reservado	0101x-1110x	--
Reset del Sofá, resetea la interface, limpia el registro a los valores por defecto. SE debe esperar un mínimo de 11msg antes del siguiente comando.	11110	0x1D

Consiste en:

- Tras una secuencia completa de Inicio de transmisión.

- Envío del comando bit a bit

- Lectura del ack

Línea fina indica su control por el PIC, línea gruesa control por el sensor.

/** secuencia de envío de comando **/

int1 SHTxx_Comando (int8 sht_comando) {

int8 bit;

int8 mascara = 0x80;

int1 ack;

delay_us(4);

//Salida del comando bit a bit

for(bit=8; bit>=1; bit--) {

output_low(sht_sck_pin); //línea SCK a "0"

//Línea DATA a "1" si MSB es "1"

if((sht_comando & mascara) > 0) output_float(sht_data_pin);

//Línea DATA a "0" si MSB es "0"

else output_low(sht_data_pin);

delay_us(1);

output_high(sht_sck_pin); //línea SCK a "1"

delay_us(1);

mascara = mascara >> 1; //siguiente bit pasa a ser MSB

}

/** lectura del ack **/

output_low(sht_sck_pin); //línea SCK a "0"

delay_us(1);

ack = input(sht_data_pin); //lectura del ack

output_high(sht_sck_pin); //línea SCK a "1"

delay_us(1);

output_low(sht_sck_pin); //línea SCK a "0"

return(ack);

}

La SECUENCIA DE ESPERA DE MEDICIÓN TERMINADA espera, una vez enviado el comando de medida de la temperatura o humedad, a que el sensor avise de la finalización del proceso de medida pasando la línea DATA de “1” a “0”. Puede durar un máximo de 20/80/320msg. para una medida de 8/12/14 bits.

Línea fina indica su control por el PIC, línea gruesa control por el sensor.

/** Secuencia de espera de medida terminada **/

void SHTxx_Espera (void) {

int16 sht_delay;

output_float(sht_data_pin); //línea DATA a "1"

output_low(sht_sck_pin); //línea SCK a "0"

delay_us(1);

//Espera a que linea DATA pase a "0" máximo 300msg.

for(sht_delay=0; sht_delay<30000; sht_delay++) {

//si linea DATA pasa a "0" => fin de la medición

if (!input(sht_data_pin)) break;

delay_us(10);

}

Con la SECUENCIA DE LECTURA DEL DATO DE UNA MEDIDA, y tras que el SHTxx haya indicado el fin de una medición, el microcontrolador reinicia el bus SCK para obtener el dato de la medida. El dato de la medida es almacenado por lo que el procesador puede hacer otras tareas hasta su lectura.

La secuencia consiste en:

- Lectura del byte alto del dato de la medida. Si es un dato de 8 bits este byte se ignora.

- El microcontrolador pone la linea DATA a “0” como reconocimiento ack.

- Lectura del byte bajo del dato de la medida.

- El microcontrolador pone la linea DATA a “0” como reconocimiento ack si va a leer el byte CRC checksum o a “1” para terminar sin lectura de CRC checksum.

- Lectura del byte del CRC checksum (opcional).

- El microcontrolador pone la línea DATA a “0” como reconocimiento ack.

Línea fina indica su control por el PIC, línea gruesa control por el sensor.

/** Secuencia de lectura del dato de la medida **/

int16 SHTxx_Lectura (void) {

int8 bit;

int16 sht_dato = 0;

const int16 mascara0 = 0x0000;

const int16 mascara1 = 0x0001;

//guarda byte alto del dato leído en byte alto de sht_dato bit a bit

for(bit=8; bit>=1; bit--) {

sht_dato = sht_dato << 1; //siguiente bit pasa a ser MSB

output_high(sht_sck_pin); //línea SCK a "1"

delay_us(1);

//si línea DATA es "1" pone bit correspondiente en sht_dato a "1"

if (input(sht_data_pin)) sht_dato |= mascara1;

//si línea DATA es "0" pone bit correspondiente en sht_dato a "0"

else sht_dato |= mascara0;

output_low(sht_sck_pin); //línea SCK a "0"

delay_us(1);

}

//Envío ack poniendo linea DATA a "0"

output_low(sht_data_pin); //línea DATA a "0"

delay_us(1);

output_high(sht_sck_pin); //línea SCK a "1"

delay_us(2);

output_low(sht_sck_pin); //línea SCK a "0"

delay_us(1);

output_float(sht_data_pin); //línea DATA a "1"

//guarda byte bajo del dato leído en byte bajo de sht_dato bit a bit

for(bit=8; bit>=1; bit--) {

sht_dato = sht_dato << 1; //siguiente bit pasa a ser MSB

output_high(sht_sck_pin); //línea SCK a "1"

delay_us(1);

//si línea DATA es "1" pone bit correspondiente en sht_dato a "1"

if (input(sht_data_pin)) sht_dato |= mascara1; //shift in data bit

//si línea DATA es "0" pone bit correspondiente en sht_dato a "0"

else sht_dato |= mascara0;

output_low(sht_sck_pin); //línea SCK a "0"

delay_us(1);

}

//Envío ack poniendo linea DATA a "1" => no lectura CRC checksum

output_float(sht_data_pin); //línea DATA a "1"

delay_us(1);

output_high(sht_sck_pin); //línea SCK a "1"

delay_us(2);

output_low(sht_sck_pin); //línea SCK a "0"

return(sht_dato);

}

La FUNCIÓN DE MEDIDA DE LA VARIABLE ejecuta todas las secuencias necesarias y en el orden correcto para obtener el valor digital de la humedad o temperatura leídas por el sensor. El proceso será:

- Secuencia de inicio de transmisión

- Secuencia de envío de comando

- Secuencia de espera hasta medición completada

- Secuencia de lectura del dato de la medición

//** Función de medida de variable **/

int16 SHTxx_Medida (sht_comando) {

int1 ack;

int16 sht_dato;

/** secuencia de inicio de transmission **/

SHTxx_InicioTrans ();

//envío del commando y lectura del ack

ack = SHTxx_Comando (sht_comando);

if(ack == 1) return; //si hay error sale de la medida

//espera a que sht termine el cálculo de la medida

SHTxx_Espera ();

//finalizada la medida, obtiene el valor digital

sht_dato = SHTxx_Lectura ();

return(sht_dato);

}

La FUNCIÓN DEL CÁLCULO DE LAS VARIABLES obtiene los valores reales analógicos partiendo de los datos digitales leídos por el sensor. Para el cálculo se emplean unos coeficientes proporcionados por el fabricante y que dependen de la resolución (nº de bits) de las medidas obtenidas.

SHTxx_calculo (int16 sht_DatoTemperatura, float &sht_temperatura, int16 sht_DatoHumedad, float &sht_humedad) {

float sht_HumedadLineal;

//Cálculo de temperatura en función de la medida digital del sensor

sht_temperatura = ((float) sht_DatoTemperatura * d2) + d1;

//Cálculo valor lineal humedad

sht_HumedadLineal = (sht_DatoHumedad * c2) + (sht_DatoHumedad * sht_DatoHumedad * c3) + c1;

//Cálculo de la humedad compensada por temperatura

sht_humedad = ((sht_temperatura - 25.0) * (t1 + (t2 * sht_DatoHumedad))) + sht_HumedadLineal;

}

La FUNCIÓN DE LECTURA DEL REGISTRO DE ESTADO obtiene el valor de configuración de dicho registro. Consistirá en:

- Secuencia de inicio de transmisión

- Secuencia de envío de comando

- Secuencia de lectura del registro de estado y cheksum

SHTxx_LECTURA_REGISTRO_ESTADO () {

int16 sht_dato; //Byte alto = registro estado, byte bajo = ckecksum

int8 sht_checksum; //Guardará el valor del checksum

/** secuencia de inicio de transmission **/

SHTxx_InicioTrans ();

/** Secuencia de envío de comando **/

SHTxx_Comando (SHTxx_REG_ESTADO_R); //Comando de lectura registro de estado

/** Lectura del registro de estado y checksum **/

sht_dato = SHTxx_Lectura ();

sht_registro = make8(sht_dato,1); //Byte alto = valor registro de estado

sht_checksum = make8(sht_dato,0); //Byte bajo = valor del checksum

return (sht_registro); //Devuelve valor del registro de estado

}

Con la FUNCIÓN DE ESCRITURA DEL REGISTRO DE ESTADO se carga el valor de configuración del sensor. Consistirá en:

- Secuencia de inicio de transmisión

- Secuencia de envío de comando

- Secuencia de escritura del valor del registro de estado

SHTxx_ESCRITURA_REGISTRO_ESTADO (sht_registro) {

/** secuencia de inicio de transmisión **/

SHTxx_InicioTrans ();

/** Secuencia de envío de comando **/

SHTxx_Comando (SHTxx_REG_ESTADO_W); //Comando de esritura registro de estado

SHTxx_Comando (sht_registro); //Argumento a cargar en el registro de estado

}

Con la FUNCIÓN DE RESET DE SOFT se envía el comando que inicializa el valor del registro a sus valores por defecto (0x00).

void SHTxx_Reset_Soft (void) {

SHTxx_Reset(); //Reset comunicación

SHTxx_Comando(SHTxx_SOFT_RESET); //Comando reset=>Reg.Estado ,valores defecto

delay_ms(15); //Espera 15 mseg.

}

[+/-] Ver / Ocultar librería C completa

Artículo relacionado>> Sensor SHT11 con PIC

Descargar archivos "SHT11 con PIC + Librerías"

Sensor de Temperatura y Humedad SHT11 con PIC

2013-09-14T23:13:00.000+02:00

En realidad, lo aquí documentado es válido para toda la gama de sensores con comunicación serie: SHT10, SHT11, SHT15, SHT71 y SHT75.

Pin	Denominación	Comentarios
1	GND	Masa
2	DATA	Entrada-Salida de datos
3	SCK	Entrada señal de reloj
4	Vcc	Alimentación (5V)
NC	NC	No conectado

Se ha desarrollado una librería para el control de este tipo de sensores <SHTxx_RyP.c>. Su documentación en detalle puede verse en el artículo "Librería C para sensor SHT11".

Aunque el sensor se puede alimentar con un rango de tensiones de 2.4v a 5.5v, la exactitud del valor de la medida de los valores ambientales dependerán de dicho valor. La librería c está desarrollada para una tensión de alimentación de 5v. Otros valores diferentes a éste pueden provocar errores en la exactitud de la medida de las variables ambientales.

Se debe colocar un condensador de desacoplo de 100nF entre los pines de alimentación y colocado lo mas cercano posible a estos en el sensor. La línea DATA también requiere de una resistencia pull up de 10k.

En la cabecera del programa habrá que llamarla mediante la directiva:

#include <SHTxx_RyP.c>

En el caso del empleo de la versión v3 o v4 del sensor SHT71 o SHT75, la librería C a emplear será <SHT7xv3_RyP.c> que contiene los coeficientes de cálculo adecuados para esas versiones.

La comunicación entre el PIC y el sensor es mediante un protocolo serie (no es válido un protocolo I2C). Los pines del PIC configurados para dicha comunicación son el RA4 para la línea DATA (Datos) y el RA3 para la línea SCK (Reloj), pero pueden ser sustituidos por los deseados modificando su definición en la cabecera de la librería C.

/************* Definición de pines del bus serie **************/

#define sht_data_pin PIN_A4

#define sht_sck_pin PIN_A3

Cargada la librería C para el sensor, y antes de cualquier otra llamada al mismo, habrá que inicializarlo:

SHTxx_init(); //Inicialización del SHT11

Para leer los valores de las medidas ambientales de Temperatura y Humedad, se llama a la función:

/** Llamada a la función de lectura de Temperatura y Humedad **/
SHTxx (sht_temperatura, sht_humedad);

Nos devolverá en las variables sht_temperatura y sht_humedad los valores de temperatura y humedad respectivamente.

Por defecto, el Registro de Estado se carga con la configuración 0x00. Es decir, emplea una resolución de 14 bits para la lectura digital de la Temperatura, 12 bits de resolución para la lectura digital de la humedad y se deja apagado el calefactor interno del sensor. Si se desea cambiar esta configuración, se deberá llamar a la función:

SHTxx_ESCRITURA_REGISTRO_ESTADO (sht_registro);

Donde sht_registro deberá contener el valor a cargar en el Registro de Estado en base a los bits que se desee activar:

Bit	Tipo	Descripción	Por defecto
7	---	Reservado	0
6	R	Detección de bajo voltaje: ‘0’ => Vcc > 2.47 V ‘1’ => Vcc < 2.47 V	Sólo lectura
5	---	Reservado	0
4	---	Reservado	0
3	---	No usar	0
2	R/W	Calefactor interno ‘0’ => off ‘1’ => on	0
1	R/W	Sin Recarga de OTP	0
0	R/W	‘0’ => resolución 12 bit RH / 14 bit Tª ‘1’ => resolución 8 bit RH / 12 bit Tª	0

Si no se desea cambiar los valores por defecto (0x00), no es necesaria la llamada a la función.

El valor actual del registro de estado se puede leer con la función:

/** Llamada a la función lectura del valor del Registro de Estado **/

sht_registro=SHTxx_LECTURA_REGISTRO_ESTADO ();

[+/-] Ver / Ocultar programa completo en C

El ejemplo que se ha realizado para confirmar el funcionamiento consiste simplemente en la muestra en un LCD de los valores de Temperatura y Humedad leídos. También se muestra el valor de configuración del Registro de Estado, que previamente se ha cargado con el valor 0x00. Aunque, como se ha hecho referencia antes, no sería necesario puesto que reside en el Registro de Estado por defecto. Tan solo se trata de una demostración de como se cargaría el valor deseado.

En esta animación se puede ver el funcionamiento.

Descargar archivos "Sensor SHT11 con PIC + Librerías C".

Artículo relacionado>> Librería C para sensor SHT11 con PIC

El proyecto contenido en el artículo ha sido diseñado y probado utilizando estas versiones de software:
- Windows 7
- Proteus V7.7 SP2 y V8
- CCS PIC C COMPILER v4.084

PINES PIC16F876A

PIC controlador de servos por I2C

2013-05-30T22:25:00.000+02:00

En el artículo "Control de 8 servos con PIC", se ha mostrado un procedimiento para controlar 8 servos mediante código en un PIC, ampliable a tantos servos como lineas de salida de puerto disponibles haya. Para según qué aplicaciones, en las que necesitamos además usar el PIC para otros menesteres, podemos encontrarnos con dos problemas. Por un lado, vamos a inutilizar para otras funciones tantos pines del PIC como servos conectemos, y esto puede ser un problema para un número alto de servos. Y por otro lado, las continuas llamadas a la interrupción por rebose del Timer para la generación de las señales de modulación de los servos, ralentiza la ejecución del resto del programa del PIC.

Para solucionar esto, en este artículo, se va a proponer el uso de un PIC secundario exclusivamente para el control de servos utilizando los conceptos mostrados en el otro artículo. Concretamente el control de 20 servos con los 20 pines I/O disponibles de un 16F876A. Y un segundo PIC, como PIC principal, que ejecutará el programa genérico de la aplicación que se desee además de controlar los 20 servos. En resumen, con dos lineas de un PIC vamos a controlar 20 servos. Y como además, estas dos lineas son el bus I2C, también podrán ser utilizadas para cualquier otro dispositivo I2C.

Por tanto, en el PIC secundario controlador de los servos, empleamos todas las lineas de los puertos como salida a excepción de los pines RC3 y RC4 del puerto C que son necesarios para el bus I2C. Otra observación; en el 16F876A es necesario emplear una resistencia pull-up en el pin RA4 cuando este se emplea como puerto de salida.

Para obtener la señal de modulación, emplearemos la interrupción por rebose del Timer0. Previamente cargado con el valor 244 se irá incrementando hasta 255, momento en el que se ejecutará la interrupción y volveremos a iniciar la cuenta desde 244.

set_timer0(244); //Carga del contador

Obtendremos un incremento en 1 de su valor cada 4 ciclos de reloj con la configuración empleada:

setup_timer_0(RTCC_INTERNAL);//Configuración interrupción generación pwm

Cada acceso a la subrutina de interrupción, es decir, cada rebose del Timer0, incrementamos la variable "Control_PWM" hasta un valor máximo de 550, momento en el cual se reinicia desde cero.

control_PWM=control_PWM+1; //Incremento cada rebose del timer0

if (control_PWM==550) control_PWM=0;

Este valor será el que determine el periodo total de la señal de modulación, en este caso 20msg. Todas las señales de modulación individuales (Bit_PWM1, Bit_PWM2, Bit_PWM3, etc.) comienzan en estado alto cuando Control_PWM se reinicia.

if (control_PWM==0){ //inicio del ciclo con todos los pulsos pwm a 1

Bit_PWMx=1; //x = nº de modulación

}

La variable Control_PWM se compara con todas las variables individuales de control de cada servo (PWM1, PWM2, PWM3, etc.). A estas variables de control de los servos se les cargará los valores de control desde el PIC principal en un rango desde 20 a 60 (correspondientes a impulsos de 0.8 msg a 2.1 msg). Cuando son comparados a la modulación en cada interrupción de rebose del Timer0 y coincide con su respectiva señal de modulación de su respectivo servo se termina el pulso de control de ese servo hasta reiniciar de nuevo el ciclo con la variable Control_PWM = 0.

if (control_PWM==PWM[x]) Bit_PWMx=0; //x = nº de servo

Para ejecutar el control de los servos, simplemente habrá que enviar por I2C el valor de las variables de nº de servo, posición y velocidad.

void PicServos_I2C(direccion, servo, posicion, velocidad){

i2c_start(); // Comienzo comunicación

i2c_write(direccion); // Dirección del esclavo en el bus I2C

i2c_write(servo); // Servo que se controlará en el esclavo

i2c_write(posicion); // Posición del servo controlado

i2c_write(velocidad); // Velocidad de cambio del servo

i2c_stop(); // Fin comunicación

delay_ms(10);

}

[+/-] Ver / Ocultar programa PIC principal en C

[+/-] Ver / Ocultar programa PIC controlador servos en C

En la simulación, reflejada en este vídeo, se puede ver el resultado de todo lo explicado. Se intenta mostrar las señales moduladas de control de los 20 servos. En el display del PIC principal, se observa el último servo que se modifica. Esta variación de giro se puede ver en la variación del ancho de pulso de la señal de modulación del correspondiente servo en las gráficas de osciloscopio.

Al final del vídeo se detalla varios tiempos de variación de los pulsos de modulación según la velocidad elegida y que actuará directamente sobre la velocidad de giro del servo.

En el siguiente enlace se pueden descargar todos los archivos.

Descargar PIC controlador de servos

El proyecto contenido en el artículo ha sido diseñado y probado con éxito utilizando las siguientes versiones de software:
- Windows 7 32 bits
- Proteus V7.7 SP2
- CCS PIC C COMPILER v4.104

Última revisión del artículo marzo de 2017

Brazo Robot de 6 ejes con PIC y SD21

2013-04-24T21:23:00.001+02:00

Consiste en el control de un brazo de 6 ejes con un PIC. En este caso se va a utilizar, junto con el PIC, una controladora de servos SD21. Por supuesto se podría prescindir de ella y controlar los servos directamente con el PIC tal como se mostró en el caso de un brazo con 4 ejes simplemente añadiendo otras dos señales moduladas para el control de los dos servos adicionales. Sin embargo, el uso de esta controladora aporta ciertas ventajas, como el poder separar la alimentación de los servos (de 6V a 7,5V) de la alimentación del circuito lógico (5V) con una única fuente de alimentación y aportar mayor fuerza a los servos al proporcionarles una tensión superior a los 5V.

Como muestra didáctica, el ejemplo realizará un ciclo repetitivo del brazo robot. Este ciclo consistirá en recoger una pieza de una posición inicial y depositarla en una segunda ubicación. Vuelve a recoger la pieza y la retorna a la posición inicial. Por supuesto todo de una forma autónoma. El ciclo se repetirá indefinidamente.

Lo primero será difinir, en la cabecera del programa, los valores de los registros del SD21 con su correspondiente eje o servo:

#define servo1 0

#define Servo2 3

#define Servo3 6

#define Servo4 9

#define Servo5 12

#define Servo6 15

Para cada uno de los ejes, deberemos enviar la información correspondiente para la nueva posición desde el PIC al módulo SD21. Esto lo haremos mediante en bus I2C. La subrutina de comunicación será la siguiente:

void sd21_servo(byte SD21_ID,int num_servo,int velocidad,int16 posicion){
i2c_start(); //Comienzo de la comunicación I2C ...

i2c_write(SD21_ID); //...con la dirección del SD21...

i2c_write(num_servo); //...apuntando al registro del servo num_servo

i2c_write(velocidad); //velocidad

i2c_write(posicion); //Parte baja de Posicion

i2c_write(posicion>>8); //Parte alta de posicion

i2c_stop (); //Finalización de la transmisión
}

Cuando queremos establecer una posición del brazo, indicamos las posiciones de cada uno de los ejes o servos además de la velocidad con la que queremos que se produzca el movimiento, y hacemos una llamada a la subrutina anterior:

velocidad = 10;

num_servo = servo1;

posicion = 1500;

sd21_servo (SD21_ID, num_servo, velocidad, posicion);

Esto para cada uno de los servos. Para cada nueva posición del brazo completo enviaremos la información de todos los ejes. Cuando alguna posición no varíe o la velocidad sea la misma no será necesario enviar esa información concreta, ya residente en el SD21:

//Movimiento nueva posición
velocidad = 10;
num_servo = servo2;
posicion = 2000;
sd21_servo (SD21_ID, num_servo, velocidad, posicion);
num_servo = servo3;
posicion = 1200;
sd21_servo (SD21_ID, num_servo, velocidad, posicion);
velocidad = 15;
num_servo = servo4;
posicion = 1850;
sd21_servo (SD21_ID, num_servo, velocidad, posicion);
num_servo = servo5;
posicion = 1500;
sd21_servo (SD21_ID, num_servo, velocidad, posicion);

Previamente habremos configurado las variables empleadas en el control:

int velocidad; //Valor de velocidad de servo

int16 posicion; //Valor de la posición del servo

int num_servo; //Identificación del servo a controlar

[+/-] Ver / Ocultar programa completo en C

Los archivos se pueden descargar en este enlace:

Descargar brazo robot 6 ejes

El proyecto contenido en el artículo ha sido diseñado con la versión v4.084 de CCS PIC C COMPILER

El servo mostrado a continuación es el modelo que se ha empleado en el diseño. Dentro de su gama es de los más económicos con respecto a sus prestaciones. No es necesario emplear el mismo servo pero se añade como orientación a la hora de elegir el modelo a emplear en este tipo de sistemas.

Configuración del EasyVR.

2013-03-19T21:09:00.000+01:00

El EasyVR es un potente módulo desarrollado por la firma VeeaR que permite el reconocimiento de voces. Bien sean propias del módulo (voces SI) o definidas por el usuario (voces SD). Permite además la reprodución de sonidos o frases.

Para la configuración del módulo necesitaremos la aplicación EasyVR Commander proporcionada por el fabricante gratuitamente desde su página. Permite la configuración del módulo de una forma sencilla desde un PC conectado al módulo por el puerto serie. Esta conexión física entre ambos es necesaria hacerla mediante la correspondiente adaptación de los niveles lógicos de tensión, por ejemplo con el típico MAX232. El fabricante dispone de un completo manual en el que poder consultar patillajes, conexiones, etc.

Cuando ejecutamos el EasyVR Comander nos encontramos un entorno gráfico con dos áreas diferenciadas. Por un lado un área dedicada a los grupos, wordsets y tabla de sonidos. Por otro lado un área donde aparecen las etiquetas asociadas a las voces contenidas en el grupo que tenemos seleccionado.

Con el módulo bajo tensión y conectado físicamente al PC, nos dará opción a elegir el puerto COM correspondiente. Con los dos comandos que se encuentran justo a la izquierda del desplegable podremos conectar o desconectar el módulo con el puerto de comunicaciones.

Con el módulo conectado podremos ver las etiquetas de las voces contenidas en los grupos (voces SD) y podemos elegir el idioma de las voces con el control superior "Set Language". Los idiomas posibles son Inglés, Italiano, Japonés, Alemán, Español y Francés.

Aprendizaje de voces.

Consiste en añadir nuevas voces a los grupos para posteriormente poder ser reconocidas. Para ello, en el grupo elegido, vamos escribiendo una a una las etiquetas para todas las voces. Etiqueta y voz no tienen necesariamente que coincidir. Cada etiqueta se crea con el comando del menú superior “Add Command”.

Con todas las etiquetas creadas, se puede ya asociar cada una a su voz correspondiente. Para ello se selecciona la etiqueta en cuestión. Con el comando del menú superior “Train Command”, nos solicitará una primera dicción de la voz a asociar. Reconocida, indicará “1” en la columna Trained y solicitará una segunda dicción. Si ambas dicciones le resultan coincidentes, indicará “2” en la columna Trained y la voz quedará asociada a la etiqueta. En caso contrario indicará el error y anulará la asociación. Este proceso hay que repetirlo para cada una de las etiquetas.

Reconocimiento de voces.

Para comprobar el reconocimiento de las voces que acabamos de asociar o las de cualquier otro grupo, seleccionamos el grupo en el que se encuentran las voces a reconocer. En la pantalla izquierda aparecerán las etiquetas asociadas.

Con el comando “Test Group” del menú, solicitará la dicción de la voz. Si reconoce la voz como una de las que se encuentra en el grupo actual, sobre-impresiona con color la etiqueta con varias intermitencias. En caso contrario, sino la reconoce o no se encuentra una voz coincidente en el grupo, indica el error.

Tabla de sonidos.

El módulo también puede reproducir sonidos o frases grabados en su memoria. Todos los sonidos a reproducir se organizan en la tabla de sonidos (Sound Table). De origen, el módulo trae esta tabla de sonidos vacía, a excepción del característico “Beep” en la primera posición de la tabla.

El usuario puede crear su propia tabla de sonidos, para ello hay que seguir el siguiente proceso:

* Crear los archivos de sonido que queremos utilizar para la tabla con cualquier software grabador y en formato .wav. Por ejemplo Audacity disponible gratuitamente en su web http://audacity.sourceforge.net/

* Abrimos QuickSynthesis para crear la tabla en función de los archivos de sonido elegidos.

* Con el programa abierto elegimos “Nuevo Proyecto”. Elegimos la opción RSC4 family. Le damos un nombre al proyecto y vamos añadiendo todos los archivos .wav que queramos que formen parte de la tabla de sonidos.

* Los seleccionamos todos y ejecutamos comprimir (Compress).

* Posteriormente ejecutamos “Built”. Aparece una nueva ventana en la que dejaremos todas las opciones que aparecen por defecto.

Creada la tabla de sonidos, ahora hay que añadírla al módulo. Para ello:

* Nos aseguramos de que no tenemos el módulo bajo tensión.

* Llevamos la patilla XM del módulo a la línea de Vcc +5V por mediación de una resistencia de 680 Ω. De esta forma tendremos el módulo en modo de actualización de tabla de sonidos.

* Volvemos a energizar el módulo, incluida la patilla XM que hemos indicado.

* Accedemos al EasyVR_Commander y ejecutamos el comando del menú superior ”Update Sound Table”.

* Nos pedirá buscar la ubicación del archivo del proyecto que habíamos creado con el QuickSyntesis (extensión .qxp).

* Elegido, nos aparece una nueva ventana con la lista de los archivos de la tabla de sonidos. Si nos indica error, abrimos el proyecto creado con el QuickSyntesis y volvemos a guardarlo para tener una versión más actualizada.

Queda cargarlos al módulo. Seleccionamos la opción “Slow transfers” y pulsamos “Download”. La tabla de sonidos se transfiere al módulo. Todos los sonidos que había anteriormente en el módulo se eliminan automáticamente a excepción del predeterminado “Beep”.

Volvemos a dejar la patilla XM del módulo al aire desconectada de Vcc.

Conectamos la comunicación del módulo con el PC y accediendo a la tabla de sonidos veremos la nueva tabla de sonidos cargada.

Para poder reproducir los sonidos con el EasyVR deberemos conectar un altavoz de 8Ω al módulo. Con el comando “Play Sound” reproduciremos los sonidos contenidos en la tabla.

Aquí se puede descargar el software y manuales:

Descargar Software&Manuales EasyVR

Artículo relacionado>> Control de un PIC por voz con el EasyVR

Control de un PIC por voz

2013-03-19T20:54:00.000+01:00

Para el control del PIC mediante órdenes verbales vamos a emplear el módulo EasyVR de Veear al que previamente le hemos creado las voces a reconocer (voces definidas por el usuario SD) y la tabla de sonidos a emplear. Aunque la enseñanza de estas voces se puede realizar desde código en el PIC, resulta más sencilla la enseñanza mediante el software EasyVR Commander a través del PC, tal como se ha explicado en el artículo correspondiente.

El ejemplo, meramente didáctico, va a consistir en reconocer voces, ya sean SI o SD, contenidas en uno de los grupos o wordset del EasyVR, reconocer parejas de voces mediante la combinación de 2 grupos y reproducir textos hablados. En el caso de voces SD, en un LCD aparecerá la etiqueta de la voz reconocida y la posición que ocupa dentro de su grupo. En el caso de voces SI, tan solo aparecerá la posición. Si se produce algún error en el reconocimiento de las voces, se mostrará el código del error y su descripción. Cada vez que se solicita el reconocimiento de una nueva voz, se indica en un mensaje de texto y simultáneamente con la reproducción de una frase. Todas estas opciones serán elegidas individualmente o de forma combinada según el estado de las entradas en el puerto A.

Este sería el procedimiento para la ejecución de un comando del PIC sobre el EasyVR:

comando = 'l'; //Comando a emplear (l = idioma)

argumento = 4; //Argumento del comando (4 = español)

putc(comando); //Envía comando elegido

putc(argumento+'A'); //Envío del argumento en su equivalente ASCII

Respuesta=getc(); //Recibe la respuesta del EasyVR

Para el reconocimiento de voces...

comando = 'd'; //Comando a emplear (d = reconocimiento voces SD)

grupo = 3; //Elección del grupo 3

putc(comando); //Envía comando reconocimiento voces SD

putc(grupo+'A'); //Envío del argumento (Grupo)

respuesta=getc(); //Recibe respuesta del EasyVR

if (respuesta == 'r'){ //Si se ha reconocido la voz

putc(' '); //Solicita siguiente dato

respuesta=getc(); //Recibe posición en el grupo

posicion = respuesta; //guarda la posición obtenida

}

if (respuesta == 'e'){ //Si no se ha reconocido la voz

putc(' '); //Solicita siguiente dato

respuesta=getc(); //Recibe 1º dato de error de 4 bits

error=respuesta; //Guarda el dato de error

putc(' '); //Solicita siguiente dato

respuesta=getc(); //Recibe 2º dato de error de 4 bits

error=(error<<4)|(respuesta); //Transforma error en un byte de 8 bits

}

Obtenida la posición o el error, los gestionaremos para hacer la función deseada sobre el PIC. En el caso de reconocimiento de voces SI el procedimiento sería el mismo pero utilizando su correspondiente comando ('i'). La respuesta en caso de reconocimiento sería 's'.

Con este otro código, reproduciremos un sonido o frase de la tabla de sonidos:

int16 indice = 1; //Posición del sonido a reproducir en la tabla

volumen = 30; //Volumen de la reproducción (entre 0 y 31)

indice_bajo=make8(indice,0); //Parte alta de indice a indice_bajo

indice_alto=make8(indice,1); //Parte alta de indice a indice_alto

putc('w'); //Envía comando

putc(indice_alto+'A'); //Envía byte más peso del indice(8 bits)

putc(indice_bajo+'A'); //Envía byte más peso del indice(8 bits)

putc(volumen+'A'); //Envía el nivel de volumen

respuesta=getc(); //Recibe un dato del EasyVR

Para leer la etiqueta asociada a una voz SD:

int i=0; //Indice del buffer

int grupo = 3; //nº de grupo

int posicion = 6; //posición en el grupo

char etiqueta [16]; //Buffer etiqueta; max.16

putc('p'); //Envía comando "lectura etiqueta"

putc(Grupo+'A'); //Envía el número de grupo

putc(posicion+'A'); //Envía posición en el grupo

respuesta=getc(); //Recibe un dato del EasyVR

putc(' '); //Solicita siguiente dato

respuesta=getc(); //Recibe un dato del EasyVR

putc(' '); //Solicita siguiente dato

respuesta=getc(); //Recibe un dato del EasyVR

putc(' '); //Solicita siguiente dato

respuesta=getc()-'A'; //Recibe nº de caracteres de la etiqueta

n_caracteres=respuesta; //Guarda nº caracteres de la etiqueta

//Llena el buffer con los caracteres de la etiqueta

for(i=0;i<n_caracteres;i++) {

putc(' '); //Solicita siguiente carácter

etiqueta[i]=getc(); //Llena el buffer

}

Finalmente el procedimiento para obtener el nº de etiquetas dentro de un grupo de voces SD:

int grupo = 3; //nº de grupo

putc('c'); //Envía comando
putc(Grupo+'A'); //Envia nº de grupo
respuesta=getc(); //Recibe un dato del EasyVR
putc(' '); //Solicita siguiente dato
respuesta=getc()-'A'; //Recibe nº de etiquetas del grupo

El programa completo que se muestra para el ejemplo de funcionamiento está estructurado con llamadas a funciones para poderlo emplear como plantilla para otros proyectos cambiando tan solo el código contenido en la función main.

[+/-] Ver / Ocultar programa completo en C

En este vídeo se muestra el resultado. Se intenta reconocer voces de dos grupos diferentes. En uno de ellos hay contenidas voces de dirección y en el otro números. Deliberadamente se le hace reconocer un número (el nº 11) que no existe en el grupo para ver el mensaje de error asociado sobre el LCD.

Descarga del proyecto:

Control PIC por voz.

El proyecto contenido en el artículo ha sido diseñado con la versión v4.084 de CCS PIC C COMPILER

Artículo relacionado >> Configuración del módulo EasyVR

Comunicación PC-PIC por USB con Visual Basic

2013-02-20T21:12:00.000+01:00

Este proyecto es una versión más elaborada del artículo Comunicación PC-PIC por USB, al que remito para más detalle en la configuración de fuses, descripción de funciones USB, etc. En este caso se emplea una aplicación desarrollada bajo visual basic para poder interactuar con el PIC desde el PC. Esta aplicación permite la lectura del canal analógico del Puerto A de un PIC 18F4550, además de la lectura o escritura de los puertos B y D. Todo controlado desde el PC a través de una conexión USB.

La aplicación VB indica la orden al PIC mediante un código de 4 caracteres. El primero de esos caracteres le indica al PIC la actuación que debe realizar, ya sea la lectura de la entrada analógica, lectura del puerto D o puerto B, escrituras en los puertos,etc.

if (usb_cdc_kbhit()){ //Si hay recepción de datos los lee

recepcion_datos();

switch(opcion[0]){ //Gestión según información recibida

case '0': escritura_puertoD();

break;

case '1': canal_analogico();

break;

case '2': lectura_puertoD();

break;

case '3': lectura_puertoB();

break;

case '4': escritura_puertoB();

break;

default:

break;

}

recepcion_datos() {

char c; //Caracteres individuales de la cadena

i=0; //Reinicio del puntero para 1º caracter

for (i=0;i<4;i++){ //Recepción máxima de 4 caracteres

//Hasta que buffer se quede vacío

if (usb_cdc_kbhit()) c=usb_cdc_getc();

opcion[i]=c; //Guarda el caracter recibido

}

El resto de caracteres del código será la información a mostrar en el puerto del PIC en el caso de la escritura en los puertos.

i=3; //ultimo caracter recibido...

decodificacion(i); //lo transforma en los 4 bits bajos Puerto B

PuertoB_bajo = numero; //guarda valor

i=2; //penultimo caracter recibido...

decodificacion(i); //lo transforma en los 4 bits altos Puerto B

PuertoB_alto = numero; //guarda el valor

//Salida de los dos caracteres leidos como un byte

PORTB=(PuertoB_alto<<4)|(PuertoB_bajo);

Por su lado, el PIC envía la información solicitada al PC mediante cadenas de caracteres acotadas por un primer carácter que indica de que información se trata y un carácter final (#) para separarla de las posteriores cadenas. La aplicación Visual Basic se encarga de identificarlos. Los caracteres contenidos entre ambos será la información "útil".

lectura_puertoD() {

TRISD=0xff; //Puerto D como entrada

PuertoD= PORTD;

//Envío por USB a la aplicación visual basic

printf(usb_cdc_putc, "\fD%x#", PuertoD);

}

[+/-] Ver / Ocultar programa completo

Bajo proteus se ha desarrollado un esquema para poder comprobar los puertos como entradas y salidas mediante interruptores y leds.

Aquí podemos ver el resultado:

En el archivo de descarga se incluye el archivo "usb_desc_cdc.h" ya modificado junto al resto de librerías C USB utilizadas.

Descargar Comunicación PC-PIC por USB con VB

El proyecto contenido en el artículo ha sido diseñado y probado con éxito utilizando las siguientes versiones de software:
- Windows xp y windows 7
- Proteus V7.7 SP2
- CCS PIC C COMPILER v4.084

PINES CONECTOR USB

Comunicación PC-PIC por USB

2013-02-20T19:44:00.000+01:00

Vamos a mostrar el procedimiento para conectar un PIC de gama alta, el 18F4550, al PC por el puerto USB. Se va a tratar de una clase de dispositivo USB CDC (Communication Device Class) emulando un dispositivo RS232 mostrado como un puerto COM en windows. El ejemplo consiste en una comunicación básica que muestra en el PC el valor de tensión leído del conversor A/D. Dicha lectura la activaremos o desactivaremos desde el PC pulsando la barra espaciadora.

En el PIC 18F4550 la configuración de fuses va a tener su importancia puesto que de ellos va a depender, entre otros, las frecuencias de reloj que van a ser utilizadas.

#fuses HSPLL //Uso de un crystal oscilador >4 MHz usando el PLL

#fuses NOWDT //No habilitación de reset por watchdog

#fuses NOLVP //Inhabilitación de programación a bajo voltaje

#fuses USBDIV //Clock del módulo USB se tomará del PLL/2 (48MHz)

#fuses PLL5 //La frecuencia se dividirá por 5 en el PLL

#fuses CPUDIV1 //El clock para el procesador serán los 96 MHz del

PLL divididos para 2 (48MHz)

#fuses VREGEN //Habilita regulador 3,3 voltios para el módulo USB

Vamos a ver el porqué de esta configuración, sobre todo en lo que respecta a la frecuencia de reloj. El objetivo es obtener 48 MHz en el módulo del USB por mediación del PLL. Esta frecuencia no tiene porqué coincidir con la del cristal empleado. Fijándonos en el diagrama de bloques interno representado del PIC18F4550 (se puede encontrar también en el datasheet del PIC18F4550 de Microchip) deberemos conseguir obligatoriamente 4 MHz a la salida del MUX controlado por PLLDIV. Como empleamos un cristal de 20MHZ deberemos dividir por 5 esta frecuencia para obtener los 4 MHz. Esto lo conseguimos mediante el fuse PLL5.

Siguiendo el diagrama vemos que los 4 MHz obtenidos se transforman en 96MHz que a continuación son divididos por 2 por lo que se quedan en 48 MHz.

Con la configuración del fuse USBDIV1 estamos indicando que estos 48MHz obtenidos del PLL son los que vamos a utilizar para el módulo USB. Aclarar que podríamos emplear directamente la frecuencia de un cristal de 48MHz con NOUSBDIV.

Configurado el clock del módulo USB, debemos ahora hacerlo con el clock del resto de módulos del procesador. Igual que para el USB obtenemos el clock del módulo PLL. Si nos fijamos en el diagrama partimos de los 96 MHz conseguidos con los 4 MHz procedentes del PLL. Esta frecuencia la vamos a dividir por un valor configurado por CPUDIV. Podemos trabajar a frecuencias diferentes a la del módulo USB pero en este caso vamos a emplear la misma. Para ello, para obtener 48MHz debemos dividir por 2 por lo que configuraremos CPUDIV1.

Si somos observadores vemos en el diagrama otro CPUDIV. ¿Por qué la frecuencia de reloj para el procesador no nos viene por ahí? La respuesta es que al configurar el fuse HSPLL estamos indicando que hacemos uso de un cristal con frecuencia superior a 4 MHz (HS) y además que lo hacemos por mediación del PLL (HSPLL), por lo que ese CPUDIV queda deshabilitado.

Con respecto a los drivers que vamos a emplear van a ser, por un lado, lógicamente, el correspondiente al PIC 18F4550 y el correspondiente a la librería de uso de una clase de dispositivo CDC USB.

#include <18F4550.h> //PIC a emplear

#include <usb_cdc.h> // Librería de control USB

Las funciones utilizadas para control USB:

usb_cdc_init(); //Inicialización del modo CDC

usb_init(); //Inicialización del control del USB

usb_task(); //Detección de la conexión de dispositivo USB

usb_enumerated(); //Devuelve TRUE si dispositivo ha sido

enumerado por el PC
usb_cdc_kbhit(); //Devuelve TRUE si hay recepción de datos
usb_cdc_putc(); //Envío de caracteres al buffer de trasmisión
usb_cdc_getc(); //Lectura del buffer de recepción

Ya tenemos el programa para el PIC. Pero ahora necesitamos que el PC reconozca el dispositivo USB al conectarlo. Para ello deberemos modificar en el archivo "usb_desc_cdc.h", que se encuentra en la carpeta "drivers" en el directorio de instalación del PIC C COMPILER, estas dos lineas:

0x61,0x04, //vendor id(0x04D8 is Microchip,or is it 0x0461 ??)==8,9

0x33,0x00, //product id ==10,11

Se deben sustituir respectivamente por estas dos:

0xD8,0x04, //vendor id(0x04D8 is Microchip, or is it 0x0461??)==8,9
0x0A,0x00, //product id ==10,11

Indican el identificador de fabricante (Microchip) y al identificador de producto (familia PIC18), y permiten la localización del driver de windows cuando se conecta el dispositivo USB.

[+/-] Ver / Ocultar programa completo

Si queremos simularlo todo en Proteus nos queda una cosa más. Debemos cargar el driver para la simulación virtual. Para ello, con proteus instalado accedemos a <Menu Inicio><Todos los programas><Proteus 7 Profesional><Virtual USB><Install USB drivers>

Ya podemos probarlo todo. Cuando conectemos el dispositivo USB, bien sea real o virtualmente en proteus, buscará el driver de windows y sino lo encuentra pedirá instalarlo. Se deberá indicar la ubicación del archivo "mchpcdc.inf" bien sea por el asistente de "Nuevo hardware encontrado" o bien manualmente con click derecho en el administrador de dispositivos de windows sobre el dispositivo CCS RS232 DEMO que aparecerá con un signo de interrogación o admiración amarillo, y posteriormente marcando "actualizar controlador" e indicando la ubicación del driver. Este archivo se puede descargar junto con el proyecto completo en el siguiente enlace de descarga. También se incluyen el archivo "usb_desc_cdc.h" ya modificado así como el resto de librerías C que intervienen:

Descargar Comunicación PC-PIC por USB

Con el driver ya instalado y el dispositivo USB reconocido, abrimos el hyperterminal y seleccionaremos el puerto COM que corresponda al dispositivo.

En esta animación se puede ver el resultado simulado en proteus:

Y en esta otra funcionando en un montaje real:

El proyecto contenido en el artículo ha sido diseñado y probado con éxito utilizando las siguientes versiones de software:
- Windows xp y windows 7
- Proteus V7.7 SP2
- CCS PIC C COMPILER v4.084

Última revisión del artículo: Octubre 2013

Sensor SRF08 con PIC

2012-12-24T13:12:00.000+01:00

El SRF08 es una versión evolucionada del sensor por ultrasonidos SRF04. Entre esas mejoras destaca, sin lugar a dudas, que el cálculo de la distancia al objeto la realiza el propio sensor, con lo cual se evita la necesidad de implementar dicho código en el PIC de control. Además la comunicación con éste se realiza por el bus I2C con lo que permitiría la conexión de varios dispositivos SRF08 (hasta 16) con el PIC ocupando tan solo dos lineas. Además dispone de un sensor para la medida de la luminosidad ambiental.

En este proyecto vamos a mostrar como controlar el componente con un PIC 16F876A. En un primer momento, al iniciar la aplicación mostraremos la versión de firmware del componente sobre un display LCD mediante la lectura del correspondiente registro. Posteriormente y a intervalos regulares, mediremos la distancia a un objeto frontal así como la luminosidad ambiental y la mostraremos sobre el mismo display LCD.

Para realizar una operación deberemos escribir el correspondiente comando sobre el registro nº 0 del SRF08. Para realizar el cálculo de la distancia a un objeto frontal en modo normal existen 3 posibles comandos según la unidad de medida en el que se desee el resultado. En pulgadas, centímetros y micro segundos y sus correspondientes comandos 0x50, 0x51 y 0x52. Aquí obtendremos el resultado en centímetros por lo que se empleará el comando 0x51 (81 en decimal).

SRF08_ID = 0xe0; //Dirección I2C del SRF08
registro = 0x00; //Registro de comandos
comando = 81; //Comando calculo en cm

i2c_start(); //Comienzo de la comunicación I2C ...
i2c_write(SRF08_ID); //...con la dirección del SD21...
i2c_write(registro); //apuntando al registro de comandos...
i2c_write(comando); //...comando
i2c_stop();
delay_ms (80); //Tiempo de adquisición de distancia

Una vez ejecutado el comando ya se pueden leer los resultados en los correspondientes registros:

- En el 0x01 el valor de la luminosidad en un valor desde 0x00 a 0xff.
- En el 0x02 el byte alto del primer eco recibido
- En el 0x03 el byte bajo del primer eco recibido

El SRF08 dispone de 32 registros más para almacenar los valores de otros ecos recibidos por objetos más distantes en una misma medición hasta un total de 17 ecos. Por ello es necesario un retardo de al menos 64ms antes de su lectura para asegurar la recepción de todos ellos.

SRF08_ID = 0xe0; //Dirección I2C del SRF08

registro=0x01; //Primer registro a leer

n_registros=0x03; //Total de registros a leer

indice = 0;

contador = 0;

i2c_start(); //Comienzo de la comunicación I2C...

i2c_write(SRF08_ID); //...con la dirección I2c del SRF08...

i2c_write(registro); //...apuntando al registro

i2c_start(); // Reinicio

i2c_write(SRF08_ID+1); // Cambio a función de lectura

//lectura de los n registros

For(contador=n_registros-1;contador>=1;contador--) {

I2C_Buffer[indice]=i2c_read(); //Envíar ACK y almacenar

en el buffer

indice++; //Siguiente posición del

buffer

}

I2C_Buffer[indice]=i2c_read(0); //Envíar NACK y almacena

en el buffer

i2c_stop(); //Secuencia de stop

En este caso solo leemos 3 registros; el registro de la luminosidad y los dos registros del primer eco recibido correspondiente al objeto más cercano.

[+/-] Ver / Ocultar programa completo en C

////////////////////////////////////////////////////////////////////////////////
// //
// Control sensor SRF08 con PIC 16F876A //
// //
// http://robotypic.blogspot.com //
// (c) RobotyPic 2012 //
// //
////////////////////////////////////////////////////////////////////////////////

#include <16F876a.h> //Archivo config.procesador
#use delay(clock=4000000) //Frecuencia de trabajo
#fuses NOPROTECT,NOCPD,NOWDT,XT,NOBROWNOUT,NOLVP
#use i2c (master,scl=PIN_C3,sda=PIN_C4,slow,force_hw) //Configuración I2C

#use fast_io (C)

#define use_portb_lcd TRUE
#include <LCD.c>

#define distancia_cm 81; //Comando lectura distancia en centímetros

/************************* Dispositivos I2C ***********************************/

int SRF08_ID = 0xe0; //Dirección I2C de acceso al SRF08

/*********************** Variables globales ***********************************/

int I2C_Buffer [35]; //Buffer de recepción del SRF08 hasta 36 registros
int registro; //Número del registro del SRF08
int luminosidad; //Valor luminosidad medida
int16 distancia; //Información distancia obtenida del SRF08
int version; //Información de versión firmware del SRF08
int comando; //Comando a ejecutar
int n_registros; //Número de registros a leer
float porcen_luz; //Valor luminosidad en %

/******************************************************************************/
/****************** FUNCIÓN LECTURA REGISTROS DEL SRF08 ***********************/

void srf08_lectura (byte SRF08_ID, int registro, int n_registros){

int indice=0;
int contador;

i2c_start(); // Comienzo de la comunicación I2C...
i2c_write(SRF08_ID); // ...con la dirección I2c del SRF08...
i2c_write(registro); // ...apuntando al registro
i2c_start(); // Reinicio
i2c_write(SRF08_ID+1); // Cambio a función de lectura

//lectura de los n registros
For(contador=n_registros-1;contador>=1;contador--) {
I2C_Buffer[indice]=i2c_read(); //Envíar ACK y almacenar en el buffer
indice++; //Siguiente posición del buffer
}
I2C_Buffer[indice]=i2c_read(0); //Envía NACK y almacena en el buffer
i2c_stop(); //Secuencia de stop
}

/******************************************************************************/
/************************ FUNCIÓN EJECUTAR COMANDO ****************************/

void srf08_distancia (byte SRF08_ID, int registro, int comando){

i2c_start(); //Comienzo de la comunicación I2C ...
i2c_write(SRF08_ID); //...con la dirección del SRF08...
i2c_write(registro); //...apuntando al registro de comandos...
i2c_write(comando); //...comando
i2c_stop();
delay_ms (80); //Tiempo de adquisición de distancia
}

/******************************************************************************/
/************************ FUNCIÓN PRINCIPAL ***********************************/

void main() {

port_b_pullups(TRUE);
lcd_init(); //Inicialización del display

//Lectura de la versión firmware del SRF08
registro = 0x00; //Registro de versión
srf08_lectura (SRF08_ID, registro, 0x1); //Lectura del registro
version = I2C_Buffer[0]; //En version firmware del SRF08
//Se muestra en pantalla versión
printf(lcd_putc, "\fVersion SRF08 %d", version);
printf(lcd_putc, "\n RobotyPic (c) ");

delay_ms (4000); //Mantiene información de versión 4 seg. en display

while(1){

//Calculo distancia en centímetros
registro = 0x00; //Registro de comandos
comando = distancia_cm; //Comando calculo en cm
srf08_distancia (SRF08_ID, registro, comando); //Ejecución comando

//Lectura última luminosidad y distancia calculada
registro=0x01; //Primer registro a leer
n_registros=0x03; //nº regsitros a leer = 3
srf08_lectura (SRF08_ID, registro, n_registros);//Lectura de los registros
//Convierte registros distancia parta alta y baja en un entero de 16 bit
distancia=make16(I2C_Buffer[1],I2C_Buffer[2]);
porcen_luz=(luminosidad/2.55); //Luminosidad en %
luminosidad=I2C_Buffer[0]; //Registro luminosidad

//mostrar por pantalla resultados
printf(lcd_putc, "\fDistancia %lu cm", distancia);
printf(lcd_putc, "\nLuminosidad %3.0f%%", porcen_luz);

delay_ms(2000); //Tiempo hasta siguiente cálculo
}
}

En esta animación se muestra el resultado del programa realizado:

Y en este enlace la descarga de los archivos del proyecto:

Descarga archivos SRF08 con PIC

Puedes comprar este sensor aquí.

El proyecto contenido en el artículo ha sido diseñado con la versión v4.084 de CCS PIC C COMPILER

Controladora de servos SD21 con PIC

2012-12-08T15:37:00.001+01:00

El módulo SD21 permite el control de 21 servos de forma totalmente independiente. En este proyecto vamos a comunicar mediante bus I2C la controladora de servos con el PIC 16F876A. Aunque el número de servos puede ser 21 y el programa mostrado está definido para el control de todos ellos, aquí se van a emplear tan solo 3 como muestra del funcionamiento.

Como ejemplo demostrativo moveremos el servo 1 en diferentes posiciones a la velocidad máxima. Posteriormente moveremos el servo 2 en otras tantas posiciones pero a una velocidad más reducida. Y finalmente los servos 1 al 3 simultáneamente.

El módulo dispone de 2 entradas de tensión de alimentación. Por un lado, entrada de entre 6 y 7,2v para alimentación de los servos. Por otro lado, alimentación de 5v para el resto de la electrónica. Pero permite la obtención de los 5v a partir de la tensión de alimentación de los servos mediante el puenteo de dos pines. Estos mismos 5v los vamos a emplear para alimentar el PIC y todo el resto de electrónica externa al módulo.

En el SD21 hay 2 registros de lectura. Estos son los registros 64 y 65. El registro 64 proporciona la versión del firmware del SD21:

registro = 64; //Registro SD21 de valor versión

i2c_start(); // Comienzo de la comunicación I2C...

i2c_write(SD21_ID); //...con la dirección I2c del SD21...

i2c_write(registro); //...apuntando al registro de versión

i2c_start(); // Reinicio

i2c_write(SD21_ID+1); // Cambio a función de lectura

lectura = i2c_read(); // En lectura información leída

i2c_stop (); // Finalización de la transmisión

version = lectura; //En version la versión de firmware

El registro 65 proporciona el valor de la tensión de alimentación. Para obtener el valor real habrá que multiplicar su contenido por 0,039:

registro = 65; //Registro SD21 de valor de tensión

i2c_start(); // Comienzo de la comunicación I2C...

i2c_write(SD21_ID); //...con la dirección I2c del SD21...

i2c_write(registro); //...apuntando al registro de voltaje

i2c_start(); // Reinicio

i2c_write(SD21_ID+1); // Cambio a función de lectura

lectura = i2c_read(); // En lectura información leída

i2c_stop (); // Finalización de la transmisión

voltaje= lectura*0.039; //En voltaje valor de tensión

El resto de registros, 3 por cada servo, controlan la velocidad y posición de cada uno de ellos:

#define servo1 0

num_servo = servo1; //Acceso al registro 0 del SD21
velocidad = 0; //Velocidad máxima
posicion = 2400; //A la posición +90º

i2c_start();            //Comienzo de la comunicación I2C ...

i2c_write(SD21_ID);     //...con la dirección del SD21...

i2c_write(num_servo);   //...apuntando al registro de nº de servo 

i2c_write(velocidad);   //velocidad

i2c_write(posicion);    //Parte baja de Posición    

i2c_write(posicion>>8); //Parte alta de posición

i2c_stop ();            //Finalización de la transmisión

La orientación del servo a -90º (ó 0º en una referencia 0-180) se obtiene cargando los registros de posición con el valor 600, 1500 para la posición 0º (90º en una referencia 0-180) y 2400 para +90º (180º en una referencia 0-180). El resto de posiciones son igualmente proporcionales y bastaría aumentar en 10 el valor de una posición concreta por cada grado de más que se desee.

[+/-] Ver / Ocultar programa completo en C

En este vídeo se puede comprobar el funcionamiento del programa desarrollado:

Y en este enlace se pueden descargar los archivos del proyecto:
Descargar Controladora SD21 con PIC

El proyecto contenido en el artículo ha sido diseñado con la versión v4.084 de CCS PIC C COMPILER

Control de velocidad de un motor DC con PIC

2012-11-24T20:55:00.000+01:00

Se trata de controlar la velocidad de un motor DC con una señal de impulsos. Variando el tiempo en estado alto de la señal con respecto al tiempo en estado bajo conseguiremos reducir la tensión media que le llega al motor y en consecuencia variaremos su velocidad.

Para hacer ese control con el PIC, en este proyecto emplearemos el modo PWM (Pulse Width Modulation). Leeremos una tensión con el conversor AD del PIC proporcionada por un potenciómetro como control manual de la velocidad. Este valor determinará el tiempo de los pulsos en estado alto de la señal que controlará la velocidad.

En el modo PWM el PIC compara el valor del registro CCP (en este caso el CCP2) con el valor del timer1. En el registro CCP habremos cargado previamente un valor responsable de la velocidad del motor. Cuando ambos coinciden, se produce la interrupción con la que gestionaremos el cambio de estado de la señal hasta una nueva comparación con la cuenta del timer 1.

lectura_AD=read_adc(); //Lectura canal analógico

#int_ccp2

void ccp2_int(){

//Conmutación estado salida CCP2

if(++cambio==1){

//Modo comparación,conmutación salida a 0

setup_ccp2(CCP_COMPARE_CLR_ON_MATCH);

//carga del ccp2 con valor semiperiodo alto

ccp_2=lectura_AD;

}

else{

//Modo comparación, conmutación salida a 1

setup_ccp2(CCP_COMPARE_SET_ON_MATCH);

//Carga del ccp2 con valor del semiperiodo bajo

ccp_2=255-lectura_AD;

}

//Reinicio del temporizador para nueva comparación

set_timer1(0);

}

[+/-] Ver / Ocultar programa completo en C

En esta animación se puede ver la simulación bajo proteus.

Los archivos del proyecto se pueden descargar en el siguiente enlace:

Descargar archivos Control Velocidad Motor

El proyecto contenido en el artículo ha sido diseñado y probado con éxito utilizando las siguientes versiones de software:
- Windows xp y windows 7
- Proteus V7.7 SP2
- CCS PIC C COMPILER v4.084

-->

Transmisión variable tipo "float" por RS232

2012-08-19T13:19:00.000+02:00

En esta ocasión se trata de transmitir una variable tipo float a través del bus RS232 entre dos PICs. Concretamente el proyecto consiste en la lectura de un valor analógico de tensión con signo y decimales a través del conversor AD del PIC emisor. El PIC receptor recibe este valor y lo muestra en la pantalla LCD.

Pulsa en la imagen para ampliarla

El procedimiento va a ser:

1º se obtiene la lectura y se guarda en una variable tipo float.

2º se transforma el valor numérico de la variable float en un valor tipo string o cadena de caracteres

3º se transmite por RS232 carácter a carácter toda la cadena de caracteres

4º se recibe carácter a carácter toda la cadena

5º finalizada la recepción de toda la cadena se convierte a su valor numérico tipo float.

6º se muestra este valor por el LCD

Almacenado el dato de la lectura en la variable “valor” de tipo float, se transforma a formato string en la variable “string” mediante el siguiente procedimiento :

sprintf(string,"%01.2f",valor);

Ahora ya se puede enviar carácter a carácter por RS232:

for (i=0;i<=5;++i){

putc(cadena[i]);

delay_ms(150);

}

i establece el número de orden del carácter. En total serán 5; uno para el signo, otro para el valor entero, uno más para el punto decimal y dos para la parte decimal.

Cuando el valor float es negativo, el signo negativo aparece por defecto. Pero cuando es positivo, el signo está omitido. Para que en este caso el string mantenga el mismo formato de 5 caracteres, el signo habrá que añadirlo, o mejor dicho, al signo ‘+’ añadirle el “valor numérico”:

if (valor>0) {

strcpy(cadena,"+"); //En "cadena" caracter +

strcat (cadena,string); //Al signo + se añade el valor numérico

}

La recepción en el otro PIC se produce por medio de la interrupción #int_RDA.

Deberá recibir la misma cantidad de caracteres enviados por el PIC emisor, es decir, 5 caracteres organizados en el array cadena[ ] por el valor i.

cadena[i]=getc(); //Recepción del string

++i; //Preparación para recibir el siguiente carácter

Recibidos todos los caracteres indicados por la variable i, se puede ya convertir la cadena de caracteres recibida a su valor numérico tipo float original y guardarla en la variable “valor”. La certificación del valor recibido se establece por su representación en el LCD.

if (i==6) { //Todos los caracteres recibidos

i=0; //Preparación para recibir el siguiente string

valor = atof(cadena); //Paso del string a su valor float

printf(lcd_putc,"\fVoltage recibido"); //Muestra en display mensaje

printf(lcd_putc,"\n%01.2fV",valor); //Muestra en display valor float

}

[+/-] Ver / Ocultar programa PIC emisor completo en C

[+/-] Ver / Ocultar programa PIC receptor completo en C

////////////////////////////////////////////////////////////////////////////////

// //

// TRANSMISIÓN FLOAT RS232 ENTRE DOS PIC //

// //

// PIC RECEPTOR //

// //

// (c) RobotyPic 2012 //

// //

////////////////////////////////////////////////////////////////////////////////

#include <16F876a.h>

#fuses XT, NOWDT

#use delay(clock=4000000)

#use rs232(baud=9600, xmit=pin_c6, rcv=pin_c7)

#define use_portb_lcd TRUE

#include <lcd.c>

#include <stdlib.h>

char cadena[6]; //Guardará el string recibido

int i; //Número de caracteres del string

float32 valor; //Dato recibido en formato float

/******************************************************************************/

/************* FUNCIÓN INTERRUPCIÓN POR RECEPCIÓN DE DATOS *******************/

#int_RDA //Interrupción por recepción de datos

void RDA_isr(){

cadena[i]=getc(); //Recepción del string

++i; //Preparación para recibir el siguiente caracter

if (i==6) { //Todos los caracteres recibidos

i=0; //Preparación para recibir el siguiente string

valor = atof(cadena); //Paso del string a su valor float

printf(lcd_putc,"\fVoltage recibido"); //Muestra en display mensaje

printf(lcd_putc,"\n %01.2fV",valor); //Muestra en display valor float

}

/******************************************************************************/

/************************ FUNCIÓN PRINCIPAL *********************************/

void main () {

port_b_pullups(TRUE);

lcd_init(); //Inicialización del display

enable_interrupts(INT_RDA); //Habilitación interrupción por recepción RS232

enable_interrupts(GLOBAL);

printf(lcd_putc, "\fEsperando...");

i=0;

while(1){}

}

En esta simulación bajo proteus se puede ver el funcionamiento:

Y en el siguiente enlace, la descarga de los archivos del proyecto:

Descargar archivos Transmisión float por RS232

El proyecto contenido en el artículo ha sido diseñado y probado con éxito utilizando las siguientes versiones de software:
- Windows xp y windows 7
- Proteus V7.7 SP2
- CCS PIC C COMPILER v4.084

Comunicación I2C entre 3 PIC

2012-03-24T16:43:00.003+01:00

El ejemplo didáctico consiste en lo siguiente. El PIC maestro carga en los PIC esclavos datos aleatorios en 10 posiciones de memoria. Primero con el PIC esclavo 1, dirección I2C en el bus 0xA0. Posteriormente con el PIC esclavo 2, con dirección I2C 0xB0. Cuando ha cargado los datos en ambos PIC, hace una lectura del dato que ha guardado en la posición 5 de ambos PIC y la muestra por el LCD.

Pulsa en la imagen para ampliarla

PIC Maestro

Lo primero de todo será configurar la comunicación I2C en la cabecera del programa. En dicha configuración vamos a establecer que se trata del PIC maestro (master), que vamos a usar velocidad rápida (fast), y que los pines del PIC van a ser C4 para la línea sda del bus y C3 para scl, propios del módulo SSP que este PIC posee.

#use i2c(Master, fast, sda=PIN_C4,scl=PIN_C3)

Si el PIC no posee módulo SSP o queremos emplear otros pines diferentes, se puede realizar la comunicación mediante software forzando esta característica e indicando los pines que van a ser utilizados.

#use i2c(Master, fast, sda=PIN_B2,scl=PIN_B3, force_sw)

A partir de este momento, para enviar algo por el bus I2C ejecutamos la función Envio_I2C(), en la que deberemos especificar previamente la dirección en el bus I2C del esclavo con el que se quiere comunicar, la posición del buffer de memoria donde se va a guardar en el esclavo el dato enviado y la información del propio dato.

direccion=0xA0; //Dirección del esclavo en el bus I2C

posicion=0x05; //Posición donde se guardará el dato
dato=0xfb; //Dato a transmitir

Envio_I2C(direccion, posicion, dato); //Función para envio I2C

Dentro ya de la función, el envío de cada byte de datos se realizará con las siguientes sentencias:

i2c_start(); //Comienzo comunicación

i2c_write(direccion); //Dirección del esclavo en el bus I2C

i2c_write(posicion); //Posición donde se guardará el dato

i2c_write(dato); //Dato a transmitir

i2c_stop(); //Fin comunicación

Para la lectura de los esclavos el proceso es similar, pero esta vez ejecutando la función Lectura_I2C(). También previamente deberemos especificar la dirección del esclavo en el bus I2C, la posición en el buffer de memoria del PIC esclavo de donde queremos obtener el byte que contiene y la variable donde lo vamos a guardar (&dato).

direccion=0xA0; //Dirección del esclavo en el bus I2C

posicion=0x05; //Posición donde se guardará el dato

Lectura_I2C(direccion, posicion, &dato); //Función para envío I2C

Dentro ya de la función ejecutaremos las sentencias para el envío de cada byte de datos:

i2c_start(); //Comienzo de la comunicación

i2c_write(direccion); //Dirección del esclavo en el bus I2C

i2c_write(posicion); //Posición de donde se leerá el dato

en el esclavo

i2c_start(); //Reinicio

i2c_write(direccion+1); //Dirección del esclavo en modo lectura

dato=i2c_read(0); //Lectura del dato

i2c_stop(); //Fin comunicación

PIC esclavo

Igual que en el PIC master, en cada PIC esclavo se debe configurar la comunicación I2C. En este caso vamos a establecer que se trata de un PIC esclavo (slave), que vamos a usar velocidad rápida (fast), que los pines del PIC van a ser C4 para la línea sda y C3 para scl, y cual va a ser su dirección en el bus (address).

#use i2c(slave, fast, sda=PIN_C4, scl=PIN_C3, address=0xA0)

A diferencia del PIC maestro que es quien decide en que momento iniciar la comunicación, en los esclavos, la comunicación se establece cuando, mediante la interrupción #INT_SSP se detecta actividad en el bus I2C.

En el caso del PIC esclavo, si que vamos a necesitar del módulo SSP, por tanto no se puede forzar una comunicación por software como en el PIC maestro y los pines han de ser necesariamente los propios del bus I2C del PIC.

#INT_SSP

void ssp_interupt (){

int incoming; //Variable donde se recibe el byte que manda el maestro

fstate = i2c_isr_state(); //Lectura del estado del bus I2c la interrupción

/* Solicitud de lectura del esclavo por el master */

if(fstate == 0x80) {

//Manda al maestro la información contenida en la posición de memoria que le ha solicitado

i2c_write (buffer[posicion]);

SolicitudMaster=1; //Fin de solicitud del master

}

/* Sino está solicitando lectura es que está enviando algo */

else { //Sino es que hay dato en el bus I2C...

incoming = i2c_read(); //... lo lee

if (fState == 1) { //Información recibida corresponde a la posicion

posicion = incoming; //Se guarda posición

}

else if (fState == 2) { //Información recibida corresponde al dato

buffer[posicion] = incoming; //Se guarda dato

EnvioMaster=1; //Fin del envío del master

}

[+/-] Ver / Ocultar programa en C PIC Maestro

////////////////////////////////////////////////////////////////////////////////

// //

// COMUNICACIÓN I2C TRES PIC v2 //

// //

// PIC Master //

// //

// RobotyPic 2015 (c) //

// //

// CCS PIC C Compiler v4.104 //

// //

////////////////////////////////////////////////////////////////////////////////

// //

// FUNCIONAMIENTO DEL EJEMPLO: //

// PIC Master envía por el bus I2C a PIC esclavo1 10 bytes que guardará en las//

// posiciones del buffer de memoria indicadas por el Master (de la posición 1 //

// a la 10). //

// Posteriormente envía otros 10 bytes de datos al PIC esclavo2 que guardará //

// igualmente en las 10 primeras posiciones de memoria. //

// Finalizados los envíos, el PIC maestro leerá los byte que previamente había //

// enviado a los PIC esclavos y que estos habían guardado en la posición 5 //

// Los bytes enviados son generados aleatoriamente. //

// //

////////////////////////////////////////////////////////////////////////////////

#include <16F876a.h>

#use delay(clock=4000000) //Frecuencia de reloj

/* Configuración de fuses

XT Cristal oscilador <= 4MHz

NOWDT Sin uso del watchdog

NOLVP Inhabilitación modo LVP

#fuses XT, NOWDT, NOLVP

/* Configuración I2C modo Master por hardware e identificación de los pines */

#use i2c(Master,fast,sda=PIN_C4,scl=PIN_C3)

/* Configuración de los puertos */

#use fast_io(a)

#use fast_io(B)

#use fast_io(C)

#define use_portb_lcd TRUE //Configuración puerto b control lcd

/* Carga de librerías */

#include <stdlib.h> //Libreria necesaria para función rand()

#include <lcd.c> //Libreria para control del lcd

/******************************************************************************/

/************** FUNCIÓN GENERACIÓN DE NÚMEROS ALEATORIOS **********************/

/** Genera números aleatorios como datos a guardar en los PIC esclavos **/

void aleatorio (byte &n_aleatorio){

srand(get_rtcc()); //Función para la generación de un número aleatorio

n_aleatorio=rand() % (256); //Limitación a un número aleatorio entre 0 y 255

}

/******************************************************************************/

/******************* FUNCIÓN ESCRITURA EN PICS ESCLAVOS ***********************/

/** Guarda un dato (número aleatorio) en la posición de memoria indicada y en el

PIC correspondiente a la dirección I2C proporcionada **/

void Envio_I2C(direccion, posicion, dato){

i2c_start(); // Comienzo comunicación

i2c_write(direccion); // Dirección del esclavo en el bus I2C

i2c_write(posicion); // Posición donde se guardara el dato transmitido

i2c_write(dato); // Dato a transmitir

i2c_stop(); // Fin comunicación

delay_ms(50);

}

/******************************************************************************/

/******************** FUNCIÓN LECTURA DE PICS ESCLAVOS ************************/

/** Lee el dato guardado en la posición de memoria indicada del PIC

correspondiente a la dirección I2C proporcionada **/

void Lectura_I2C (byte direccion, byte posicion, byte &dato) {

i2c_start(); // Comienzo de la comunicación

i2c_write(direccion); // Dirección del esclavo en el bus I2C

i2c_write(posicion); // Posición de donde se leerá el dato en el esclavo

i2c_start(); // Reinicio

i2c_write(direccion+1); // Dirección del esclavo en modo lectura

dato=i2c_read(0); // Lectura del dato

i2c_stop(); // Fin comunicación

delay_ms(50); // Espera finalización del envio

}

/******************************************************************************/

/*************************** FUNCIÓN PRINCIPAL ********************************/

void main(){

/* Definición de variables */

byte dato=0; //Contendrá la información a enviar o recibir

byte direccion=0; //Contendrá la dirección del esclavo en el bus I2C

byte posicion=0; //Contendrá la posición en el buffer de memoria del esclavo donde se almacenará o de donde se recuperará el dato

byte n_aleatorio=0;

/* Configuraciones */

setup_timer_0(RTCC_INTERNAL|RTCC_DIV_2); //Config. timer0 necesario para números aleatorios

enable_interrupts(global);

/* Inicialización de componentes hardware */

lcd_init(); //Inicialización del lcd

port_b_pullups(TRUE); //Habilitación resistencias pull ups puerto b

printf(lcd_putc, "\f Pulsar para I2C"); //Mensaje lcd de inicio

while(true){

if (input(pin_A0)==1) { //Cuando se pulsa comienza trasmisión

printf(lcd_putc, "\f Enviando"); //Mensaje en lcd

/** Envío a PIC esclavo dirección 0xA0 bus I2C posiciones 1 a 10 **/

for (posicion=1; posicion<=10; posicion++){

direccion=0xA0; //Al PIC con I2C A0 en el bus

aleatorio (n_aleatorio); //Generación de un número aleatorio

dato=n_aleatorio; //Número aleatorio como dato

lcd_gotoxy(1,2); //Posición en el lcd

//Muestra en el lcd las variables de la transmisión

printf(lcd_putc, "%x Pos%d Dato=%x ", direccion, posicion, dato);

Envio_I2C(direccion, posicion, dato); //Envío I2C

delay_ms(500); //Envío cada medio segundo

}

/** Envío a PIC esclavo dirección 0xB0 bus I2C posiciones 1 a 10 **/

for (posicion=1; posicion<=10; posicion++){

direccion=0xB0; //Al PIC con I2C B0 en el bus

aleatorio (n_aleatorio); //Generación de un número aleatorio

dato=n_aleatorio; //Número aleatorio como dato

lcd_gotoxy(1,2); //Posición en el lcd

//Muestra en el lcd las variables de la transmisión

printf(lcd_putc, "%x Pos%d Dato=%x ", direccion, posicion, dato);

Envio_I2C(direccion, posicion, dato); //Envío I2C

delay_ms(500); //Envío cada medio segundo

}

printf(lcd_putc, "\f Enviado"); //Mensaje en lcd

delay_ms(1000); //Espera de 1 segundo

/* Lectura del dato contenido en la posición de memoria 5 del pic esclavo cuya dirección en el bus I2C es 0xA0 */

direccion=0xA0; //Dirección en el bus I2c

posicion=0x05; //Posición de memoria a leer

Lectura_I2C(direccion, posicion, dato); //Lectura por I2C

//Muestra en el lcd las variables de la transmisión

printf(lcd_putc, "\fI2C=%x Pos.%d =%x" direccion, posicion, dato);

delay_ms (1000); //Espera de 1 segundo

/* Lectura del dato contenido en la posición de memoria 5 del pic esclavo cuya dirección en el bus I2C es 0xB0 */

direccion=0xB0; //Dirección en el bus I2c

posicion=0x05; //Posición de memoria a leer

Lectura_I2C(direccion, posicion, dato); //Lectura por I2C

//Muestra en el lcd las variables de la transmisión

printf(lcd_putc, "\nI2C=%x Pos.%d =%x" direccion, posicion, dato);

delay_ms(10); //Espera de 10 milisegundos

}

[+/-] Ver / Ocultar programa en C PIC Esclavo 1

[+/-] Ver / Ocultar programa en C PIC Esclavo 2

En esta animación se ve la demostración de funcionamiento bajo proteus.

Descarga de los archivos del proyecto.

Descargar archivos I2C tres PICs

El proyecto contenido en el artículo ha sido diseñado y probado con éxito utilizando las siguientes versiones de software:
- Windows xp y windows 7 (32 y 64 bits)
- Proteus V7.7 SP2
- CCS PIC C COMPILER v4.104

Última revisión del artículo junio de 2015

Control de un brazo Robot de 4 ejes con PIC

2011-11-04T20:13:00.003+01:00

Se trata del control de un brazo de 4 ejes para aplicar a un robot. El principio de funcionamiento es similar al empleado en el artículo Control de 8 servos con PIC.

Lo lógico es que la fuente de energía de los robots sean baterías o similares. Cuando intentamos hacer funcionar varios ejes del brazo a la vez, puede pasar que se produzcan bajadas de tensión momentaneas que ocasione el reset del PIC e impidan el movimiento del brazo. Para evitarlo hay que indicar en la configuración del programa:

#fuses NOBROWNOUT //No reset por baja tensión

Mediante interrupción por desborde del Timer 0 generaremos las señales de control de los servos. Y mediante el valor numérico contenido en una variable la posición de giro. Estas variables las hemos denominado 'pinza' , 'muneca' , 'brazo' y 'hombro', e identifican a cada uno de los ejes. Con otra variable, 'velocidad' especificaremos la rapidez de los movimientos.

pulsa en la imagen para ampliarla

Para conseguir controlar la velocidad de los movimientos se ha establecido este procedimiento:

//Modificará posición del servo mientras flag=1

while (flag){
flag=0;

//Si el eje brazo no está en su posición...
if (pwm_brazo != brazo){

//...retrocede una posición si la nueva es menor

if (pwm_brazo > brazo) --pwm_brazo;

//...o avanza una posición si la nueva es mayor
else if (pwm_brazo < brazo) ++pwm_brazo;

//Con retardo de movimiento de posición indicado

delay_ms(velocidad);

//Y se comprueba otra vez si coincide posición actual

//con posición deseada

flag=1;

}

Y la forma de indicar las posiciones del servo mediante dos procedimientos. Por un lado indicando numéricamente las nuevas posiciones de los servos que han de cambiar:

velocidad=5; //Velocidad del movimiento

muneca= 16;                    //Nueva posición muñeca
brazo=20;                      //Nueva posición brazo
hombro=13;                     //Nueva posición hombro

//Acceso a la función del cambio de posiciones

movimiento_brazo_num (muneca, pinza, brazo, hombro, velocidad);

O tener unas posiciones preestablecidas definidas por una opción que se envía para obtener la nueva posición:

brazo_pos=2; //Brazo levantado

//Acceso a la función del cambio de posiciones

movimiento_brazo (brazo_pos,velocidad);

Donde brazo_pos indicará la posición genericamente preestablecida:

switch (brazo_pos){
//Brazo recogido
case0:muneca=8;pinza=8;brazo=5;hombro=21;break;

//Brazo recogido

case1:muneca=pwm_muneca;pinza=pwm_pinza;brazo=5;hombro=21;break;

//Brazo levantado

case2:muneca=pwm_muneca;pinza=pwm_pinza;brazo=16;hombro=16;break;

//Brazo abajo extendido

case9:muneca=pwm_muneca;pinza=pwm_pinza;brazo=16;hombro=11;break;

}

La generación de las señales pulsatorias para el control de los servos se realiza mediante la interrupción por rebose del timer 0. Con cada rebose del timer 0 se accede a la función de interrupción donde se incrementa la variable "Ancho_pulso" y comparandola con cada una de las variables que contienen la posición de los servos se decide cuando la señal de control correspondiente a cada servo debe pasar a cero. Cuando la variable "Ancho_pulso" incrementandose pasa de 0xff a 0x00, comienza un nuevo ciclo y por tanto un nuevo pulso para todos los servos. De esta forma se consigue un pulso cíclico para los servos de entre unos 0,9 ms a 2,1 ms cuando establecemos valores de la variable del servo de entre unos 7 y 21, correspondientes a las posiciones extremas. ¡Ojo! Todos estos valores corresponden al uso de un cristal de cuarzo de 4 MHz y un preescaler de 32 del timer 0.

[+/-] Ver / Ocultar programa completo en C

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//                              BRAZO ROBOT                                   //
//                                                                            //
//                          (c) RobotyPic 2011                               //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////

#include <16F876A.h>

#fuses NOWDT
#fuses XT //Oscilador por cristal entre 4Mhz y 10Mhz

#fuses NOBROWNOUT //No reset por baja tensión

#use delay(clock=4000000) //Frecuencia del cristal oscilador 4MHz

#byte trisa=0x85
#byte porta=0x05

#bit Bit_PWM_muneca = PORTA.0     //Bit 0 puerto A Salida modulación muñeca
#bit Bit_PWM_pinza = PORTA.1     //Bit 1 puerto A Salida modulación pinza
#bit Bit_PWM_brazo = PORTA.2     //Bit 2 puerto A Salida modulación codo
#bit Bit_PWM_hombro = PORTA.3     //Bit 3 puerto A Salida modulación hombro

/********************** Prototipos de las funciones ***************************/

void main (void);                   //función principal
void generacion_pwm (void);         //genera señales moduladas control de servos
void movimiento_brazo (void);       //Mueve brazo con retardo de movimientos

/********************** Variables para movimiento brazo ***********************/

int8 PWM_muneca=0,PWM_pinza=0,PWM_brazo=0,PWM_hombro=0; //Guardará los valores de las señales PWM
int8 Ancho_pulso=0;
short int flag;
int8 muneca=0, pinza=0, brazo=0, hombro=0;
int8 brazo_pos;
int8 velocidad=3; //Lentitud de los movimientos

/******************************************************************************/
/********* FUNCIÓN GENERACIÓN MODULACIONES PWM PARA SERVOS BRAZO **************/

#int_Timer0

void generacion_pwm() {

   Ancho_pulso++;                //Incremento cada rebose del timer0
   if (Ancho_pulso==0) {
      Bit_PWM_muneca =1;
      Bit_PWM_pinza =1;
      Bit_PWM_brazo =1;
      Bit_PWM_hombro =1;
   }

   if (Ancho_pulso==PWM_pinza)
      Bit_PWM_pinza=0;
   if (Ancho_pulso==PWM_brazo)
      Bit_PWM_brazo=0;
   if (Ancho_pulso==PWM_hombro)
      Bit_PWM_hombro=0;
   if (Ancho_pulso==PWM_muneca)
      Bit_PWM_muneca=0;

   set_timer0(255);
   }

/****************************************************************************/
/*********** FUNCIÓN MOVIMIENTO BRAZO POR ESTADOS PREESTABLECIDOS ***********/

void movimiento_brazo (brazo_pos, velocidad){

switch (brazo_pos){
//Brazo recogido
case 0: muneca=8; pinza=8; brazo=5; hombro=21; break;

   //Brazo recogido
   case 1: muneca=pwm_muneca; pinza=pwm_pinza; brazo=5; hombro=21; break;
   //Brazo levantado
   case 2: muneca=pwm_muneca; pinza=pwm_pinza; brazo=16; hombro=16; break;
   //Brazo levantado extendido
   case 3: muneca=pwm_muneca; pinza=pwm_pinza; brazo=20; hombro=11; break;
   //Brazo semiextendido
   case 4: muneca=pwm_muneca; pinza=pwm_pinza; brazo=5; hombro=16; break;
   //Girar muñeca
   case 5: muneca=16;pinza=pwm_pinza;brazo=pwm_brazo; hombro=pwm_hombro;break;
   //Regirar muñeca
   case 6: muneca=8; pinza=pwm_pinza;brazo=pwm_brazo; hombro=pwm_hombro;break;
   //Abrir pinza
   case 7: muneca=pwm_muneca;pinza=19;brazo=pwm_brazo; hombro=pwm_hombro;break;
   //Cerrar pinza
   case 8: muneca=pwm_muneca;pinza=8;brazo=pwm_brazo; hombro=pwm_hombro;break;
   //Brazo abajo extendido
   case 9: muneca=pwm_muneca; pinza=pwm_pinza; brazo=16; hombro=11; break;
}
flag=1;                      //Permiso para revisar posiciones del brazo

while (flag){
flag=0;                     //Cuando todos servos en posición se sale del while

if (pwm_muneca != muneca) {         //Si muñeca no está en su posición...
     if (pwm_muneca > muneca) --pwm_muneca;//...retrocede una posición...
     else if (pwm_muneca < muneca) ++pwm_muneca; //...o avanza una posición
delay_ms(velocidad);                   //Retardo mivimiento de posición
flag=1;                                //Una posición avanzada
}

if (pwm_pinza != pinza) {           //Si pinza no está en su posición...
     if (pwm_pinza > pinza) --pwm_pinza; //...retrocede una posición...
     else if (pwm_pinza < pinza) ++pwm_pinza;     //...o avanza una posición
     flag=1;                                //Una posición avanzada
}

if (pwm_hombro != hombro) {          //Si hombro no está en su posición...
     if (pwm_hombro > hombro) --pwm_hombro; //...retrocede una posición...
     else if (pwm_hombro < hombro) ++pwm_hombro; //...o avanza una posición
     delay_ms(velocidad);                   //Retardo mivimiento de posición
     flag=1;                                //Una posición avanzada
}

if (pwm_brazo != brazo) {             //Si brazo no está en su posición...
    if (pwm_brazo > brazo) --pwm_brazo;   //...retrocede una posición...
     else if (pwm_brazo < brazo) ++pwm_brazo;     //...o avanza una posición
     delay_ms(velocidad);                   //Retardo mivimiento de posición
     flag=1;                                //Una posición avanzada
}

}
delay_ms(50);
}

/****************************************************************************/
/************* FUNCIÓN MOVIMIENTO BRAZO POR VALORES NUMÉRICOS ***************/

void movimiento_brazo_num (muneca, pinza, brazo, hombro, velocidad){

flag=1;                     //Permiso para revisar posiciones del brazo
while (flag){
flag=0;                  //Cuando todos servos en posición se sale del while
if (pwm_muneca != muneca) {          //Si muñeca no está en su posición...
    if (pwm_muneca > muneca) --pwm_muneca; //...retrocede una posición...
    else if (pwm_muneca < muneca) ++pwm_muneca;//...o avanza una posición
    delay_ms(velocidad);                //Retardo mivimiento de posición
    flag=1;                                    //Una posición avanzada
}
  if (pwm_pinza != pinza) {       //Si pinza no está en su posición...
    if (pwm_pinza > pinza) --pwm_pinza;     //...retrocede una posición...
    else if (pwm_pinza < pinza) ++pwm_pinza; //...o avanza una posición
    flag=1;                                  //Una posición avanzada
}
  if (pwm_hombro != hombro) {       //Si hombro no está en su posición...
    if (pwm_hombro > hombro) --pwm_hombro; //...retrocede una posición...
    else if (pwm_hombro < hombro) ++pwm_hombro; //...o avanza una posición
    delay_ms(velocidad);                 //Retardo mivimiento de posición
    flag=1;                                 //Una posición avanzada
}
  if (pwm_brazo != brazo) {         //Si brazo no está en su posición...
    if (pwm_brazo > brazo) --pwm_brazo;    //...retrocede una posición...
    else if (pwm_brazo < brazo) ++pwm_brazo;     //...o avanza una posición
    delay_ms(velocidad);                   //Retardo mivimiento de posición
    flag=1;                                //Una posición avanzada
}

}
delay_ms(50);
}

/******************************************************************************/
/*************************** FUNCIÓN PRINCIPAL ********************************/

void main(){

//INICIALIZACIÓN trisa=0x00; //Puerto A todo salidas

   //Posición inicial del brazo
   pwm_muneca=8;         //muñeca recta
   pwm_pinza=8;          //pinza cerrada
   pwm_brazo=5;          //codo recogido
   pwm_hombro=21;        //hombro recogido

   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_32);    //Configuración generación PWM
   enable_interrupts(INT_TIMER0); //Inhabilitación interrupción generación pwm
   enable_interrupts (GLOBAL);

delay_ms(100); //Estabilización en el arranque del sistema
while (1){

//Movimiento del brazo con controles predefinidos
       velocidad=3;
brazo_pos=1;   //Brazo recogido
       movimiento_brazo (brazo_pos,velocidad);

       brazo_pos=2;                           //Brazo levantado
       movimiento_brazo (brazo_pos,velocidad);

       brazo_pos=3;                           //Brazo levantado extendido
       movimiento_brazo (brazo_pos,velocidad);

       brazo_pos=7;                           //Abrir pinza
       movimiento_brazo (brazo_pos,velocidad);

       brazo_pos=5;                           //Girar muñeca
     movimiento_brazo (brazo_pos,velocidad);

       brazo_pos=6;                           //Regirar muñeca
       movimiento_brazo (brazo_pos,velocidad);

       brazo_pos=5;                           //Girar muñeca
       movimiento_brazo (brazo_pos,velocidad);

       brazo_pos=6;                           //Regirar muñeca
       movimiento_brazo (brazo_pos,velocidad);

       delay_ms(300);                //descanso en los movimientos

       brazo_pos=8;                           //Cerrar pinza
       movimiento_brazo (brazo_pos,velocidad);

       brazo_pos=2;                           //Brazo levantado
       movimiento_brazo (brazo_pos,velocidad);

       brazo_pos=9;                           //Brazo recogido
       movimiento_brazo (brazo_pos,velocidad);

delay_ms(300); //descanso en los movimientos

//Movimiento del brazo mediante controles numéricos
       velocidad=6;                           //Movimiento más lento
       muneca= 20;                            //Girar muñeca
      movimiento_brazo_num (muneca, pinza, brazo, hombro, velocidad);

       pinza=19;                              //Abrir pinza
     movimiento_brazo_num (muneca, pinza, brazo, hombro, velocidad);

       delay_ms(50);

       pinza=8;                               //Cerrar pinza
       movimiento_brazo_num (muneca, pinza, brazo, hombro, velocidad);

       delay_ms(300);                         //descanso en los movimientos

       velocidad=10;                          //Movimiento más rápido
       brazo=20;                              //Extender brazo
       movimiento_brazo_num (muneca, pinza, brazo, hombro, velocidad);

       velocidad=15;                          //Movimiento más lento
       muneca= 8;                             //Girar muñeca
      movimiento_brazo_num (muneca, pinza, brazo, hombro, velocidad);

       delay_ms(100);                         //descanso en los movimientos

       velocidad=5;                           //Movimiento más lento
       muneca= 16;                            //Girar muñeca
       brazo=20;                              //Mover brazo
       hombro=13;                             //Mover hombro
       movimiento_brazo_num (muneca, pinza, brazo, hombro, velocidad);

       delay_ms(300);

       velocidad=3;
       muneca= 8;                             //Girar muñeca
       pinza=8;                               //Cerrar pinza
       brazo=5;                               //Mover brazo
       hombro=21;                             //Mover hombro
       movimiento_brazo_num (muneca, pinza, brazo, hombro, velocidad);

   }
}

Todos los archivos se pueden descargar en el siguiente enlace:

Descarga de archivos Brazo Robot

El proyecto contenido en el artículo ha sido diseñado con la versión v4.084 de CCS PIC C COMPILER

CÓDIGO DE COLORES Y NOMENCLATURA PARA CONDENSADORES

CÓDIGO DE COLORES PARA RESISTENCIAS

Diseño de la plataforma móvil para el Robot

2011-10-16T18:58:00.002+02:00

Esta es una pequeña muestra de como fabricar una plataforma para el robot.

Lo primero, disponer de las dos plataformas para los dos niveles. En el primer nivel se colocarán todos los elementos de la trasmisión.

Descarga de los croquis de las plataformas:

Descarga de archivos Croquis Robot

Por otro lado preparamos el sistema de transmisión. Para ello se emplearán 4 varillas huecas o tubos de aluminio de 150mm de longitud y diámetro interior de 4mm. Otras 4 varillas roscadas de M4 ligeramente mas largas, de unos 170mm.

Se pasan las varillas roscadas por el interior de los tubos de aluminio. En los extremos por donde sobresalen las varillas roscadas se sujetan los servos de giro continuo mediante tuercas. De esta forma los dos servos quedan unidos a la distancia marcada por los tubos de aluminio, a modo de separadores.

Vamos a sujetar ahora el conjunto de la transmisión al chasis. Para ello, de 4 sujetacables para sirgas aprovecharemos las "U" con las tuercas. Las hacemos pasar por los separadores entre servos del sistema de trasmisión...

...y lo sujetamos con las tuercas al chasis.

Se atornilla la rueda giratoria trasera.

El siguiente paso, acoplar la plataforma superior. Para ello se roscan las varillas de M4 a la plataforma superior, se colocan los separadores pasándolos por las varillas roscadas y se sujetan con las tuercas al chasis.

Y queda la plataforma ensamblada a falta de colocarle las ruedas.

Dependiendo de las ruedas de las que se trate, bastará con insertarlas al eje de los servos y mantenerlas con los tornillos propios del kit de los servos.

Queda finalmente la plataforma montada.

Medida de distancias con SRF05

2011-06-28T23:53:00.006+02:00

A diferencia del artículo referente a la medida de distancias con el SRF04 o SRF05 en modo de funcionamiento 1, en esta ocasión se va a emplear el sensor de ultrasonidos SRF05 en el modo de funcionamiento 2, es decir, empleando el mismo pin como entrada del pulso de test y como salida para el pulso eco que nos dará la información de la distancia en función de su duración en tiempo.

Para conectar el sensor de ultrasonidos en este modo de funcionamiento, el pin de “modo” (sin conectar en SRF04 o SRF05 modo 1) debe llevarse a 0v. De esta forma, el pin empleado para dar el pulso de test será el que nos ofrezca igualmente el pulso ECO.

El proceso consiste en un ciclo que se repite cada vez que se toma una nueva medida.

Traducido al código de programación del PIC, primero damos el pulso trigger o de disparo (mínimo 10 uS) con el pin RC1 (CCP2) como salida y deshabilitada la interrupción...

disable_interrupts(INT_CCP2); //Deshabilitación interrupción

modo comparación

trisc=0x00; //Puerto C todos los pines todo salidas

BIT_TEST_ON; //Comienzo del pulso de disparo

delay_us(10); //Tiempo del pulso de disparo

BIT_TEST_OFF; //Fin del pulso de disparo

...e inmediatamente después se vuelve a configurar dicho pin como entrada y a habilitar la interrupción para detección de flanco...

trisc=0b00000010; //Pin RC1 como entrada para lectura eco

PIR2=0; //Reset del flag de la interrupción

enable_interrupts(INT_CCP2); //Habilitación interrupción para medida de pulso eco

.. y se espera la lectura del pulso eco...

while(NuevoEco==0) {}

Como se ve, es imprescindible resetear el flag de interrupción mediante su puesta a cero (PIR2=0). Sino se hace, nos detectará interrupción por flanco de subida desde el mismo momento de habilitar la interrupción.

Cuando, esperando el flanco de subida del eco, se activa la interrupción, deberemos guardar el valor que en ese momento se carga en el registro CCP2, y memorizar que el próximo flanco será de bajada.

if(TipoFlanco==0){ //Si es flanco de subida...

Contador_FS=CCP_2; //Guarda el valor del registro CCP2

setup_ccp2(CCP_CAPTURE_FE); //Modo captura en flanco de bajada

TipoFlanco=1; //Próximo flanco debe ser de bajada

}

Ahora, el programa continua esperando en la misma instrucción (While) en la que aguardaba a recibir el comienzo del pulso eco, hasta activarse de nuevo la interrupción, pero esta vez por la recepción del flanco de bajada. En ese mismo momento, volveremos a tomar el valor del registro CCP2. Además, memorizaremos que el pulso eco en curso ha finalizado y que por tanto, el próximo flanco será de subida por tratarse de un nuevo pulso eco.

Contador_FB=CCP_2; //Guarda el valor del registro CCP2

setup_ccp2(CCP_CAPTURE_RE); //Modo captura en flanco de subida

TipoFlanco=0; //Próximo flanco debe ser de subida

NuevoEco=1; //Pulso eco actual finalizado.

Al indicar que el pulso eco ha finalizado, salimos del bucle while y se continúa con la ejecución del programa para calcular, a partir de los valores leídos del registro CCP, el valor de la distancia al objeto. Primero obteniendo los incrementos totales producidos en el contador del registro CCP2 (Timer 1) desde el flanco de subida hasta el de bajada.

Contador_FT=(Contador_FB-Contador_FS); //Valor entre flanco de subida y bajada.

Ahora, si multiplicamos este numero de incrementos por el tiempo (en microsegundos) que tarda en producirse cada uno de ellos, obtendremos el tiempo total del pulso eco. En este caso, al emplearse un oscilador para el PIC de 4 MHz, el tiempo de cada incremento es de 1uS, por lo que se multiplicará por 1.0

T_PulsoEco=Contador_FT*1.0; //Valor pulso leido en us de 100u a 25ms

Para saber el tiempo de cada incremento del contador en función del oscilador empleado, partimos de esta expresión:

T = Tcm * Preescaler

Tcm es el ciclo máquina y que corresponde con 4 ciclos del oscilador (4/Frec.Reloj)

Preescaler es la escala empleada para el Timer1. En este caso Preescaler=1

T = (4/4.000.000) * 1

De donde obtenemos que el tiempo T es de 1uS para una frecuencia de reloj de 4MHz.

Para obtener la distancia en centímetros en función del tiempo del eco, lo dividimos por 58.3

Distancia = T_PulsoEco/58.3; //Distancia del obstáculo en cm

Esta constante es siempre fija y nos da el resultado en cm. La proporciona el fabricante del sensor en la hoja de características pero se podría obtener considerando la velocidad del sonido en el aire (340m/s) y que éste recorre el doble del espacio medido, puesto que dicho trayecto es de ida y vuelta.

Finalizado el cálculo, volvemos a dejar el pin RC2 como salida y deshabilitamos temporalmente la interrupción para que no nos detecte el propio pulso de disparo. Y avisamos de que queda listo para una nueva media.

NuevoEco=0; //Listo para recibir nuevo pulso eco

disable_interrupts(INT_CCP2);

trisc=0b00000000; //Pin RC1 como salida para nuevo disparo

[+/-] Ver / Ocultar programa completo en C

En la animación se mestra el funcionamiento empleando el simulador del SRF05 para proteus.

Todos los archivos del proyecto en este enlace de descarga:

Descargar Medida de distancias con SRF05

El proyecto contenido en el artículo ha sido diseñado con la versión v4.084 de CCS PIC C COMPILER

Si necesitas comprar el sensor SRF05, puedes hacerlo online pulsando aquí.

Última revisión del artículo: Agosto 2013

Generación de números aleatorios con PIC.

2011-05-19T00:08:00.010+02:00

Para obtener números aleatorios vamos a emplear la función rand(). El rango de números aleatorios que nos va a ofrecer va a ser muy elevado, por lo que deberemos acotarlo entre dos valores deseados.

En este ejemplo, queremos obtener números aleatorios entre 100 y 200. Para ello emplearemos la función rand() con la siguiente expresión matemática:

rand() % ((nº mas alto - nº mas bajo +1) + nº más bajo)

donde "%" indica que tomaremos como resultado el resto de dividir rand() por la expresión indicada.

Así pues, sustituyendo los limites desados la instrucción quedaría:

n_aleatorio = rand()%(101)+100;//Numero aleatorio entre 100 y 200

Ya tendríamos la generación de números aleatorios. Pero ahora se presenta otro problema. Obtendremos una secuencia de números aleatorios, pero cuando volvamos a activar la generación de números, obtendremos la misma secuencia aleatoria.

El problema viene porque rand() parte de un número inicial sobre el que realiza una serie de cálculos para obtener el siguiente número aleatorio. Como este número inicial y los cálculos son siempre los mismos, cada vez que iniciemos la generación se repetirá la secuencia. Por tanto hay que buscar la forma de que ese número inicial no sea siempre el mismo.

Para ello existe otra función srand(), que nos permitirá elegir ese número inicial. Si empleamos por ejemplo srand(3), el número inicial sobre el que rand() iniciará los cálculos será el 3. Con srand(1), será el 1, y así.

Ya hemos conseguido elegir ese número inicial. Pero seguimos teniendo el mismo problema puesto que aunque elijamos nosotros el número, éste será siempre el mismo. Para ello, deberemos sustituirlo por una expresión que no nos aporte siempre el mismo valor. Una forma de hacerlo es tomando el valor en un momento concreto del contador RTCC del pic. Que coincidamos con nuestra pulsación dos veces en el mismo valor del RTCC será realmente complicado.

srand(get_rtcc());

Pulsa en la imagen para ampliarla

Así pues, para generar los números aleatorios, actuaremos sobre el pulsador que mediante la interrupción por señal externa en RB0 del pic tomaremos el valor que posea en ese momento el contador RTCC y lo emplearemos como valor inicial para la generación de números aleatorios.

Con cada pulsación desactivaremos y activaremos alternativamente la generación de los números aleatorios.

[+/-] Ver / Ocultar prorama completo en C

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//                    NÚMEROS ALEATORIOS CON PIC 16F876A                      //
//                                                                            //
//   Mediante interrupción externa por RB0, obtención de números aleatorios   //
//                                                                            //
//                           (c) RobotyPic 2011                               //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////

#include <16F876a.h> //Archivo para control del PIC 16f876a
#include <stdlib.h> //Archivo necesario para función rand()

#fuses XT, NOWDT
#use delay(clock=4000000)
#use RS232(BAUD=9600,BITS=8,PARITY=N,XMIT=PIN_C6,RCV=PIN_C7)

int n_aleatorio; //Dato aleatorio
short int activacion=0; //Puesta en marcha generación números aleatorios

/******************************************************************************/
/*************** FUNCIÓN POR INTERRUPCIÓN EXTERNA EN RB0 *******************/

#INT_EXT
int_externa() {
srand(get_rtcc());
activacion=activacion+1;
}

/******************************************************************************/
/************************** FUNCIÓN PRINCIPAL *******************************/

void main (){

   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_2); //Configuración timer0
   enable_interrupts(int_ext);               //Habilitación interrupción externa
   ext_int_edge (H_TO_L);                    //...por flanco de bajada
   enable_interrupts(GLOBAL);

   while(1){
      if (activacion==1){        //Pulsaciones imparespone en marcha generación

      //rand() % (nº mas alto - nº mas bajo +1) + nº más bajo
      n_aleatorio=rand() % (101)+100; //Numero aleatorio entre 100 y 200

      //Se muestra en pantalla información enviada
      printf("\fEl número aleatorio es:      %u", n_aleatorio);
      delay_ms(2000);
      }
   }

}

En esta simulación bajo proteus se puede comprobar el funcionamiento.

Todos los archivos se pueden descargar en este enlace:

Descargar archivos Generación de números aleatorios

El proyecto contenido en el artículo ha sido diseñado y probado con éxito utilizando las siguientes versiones de software:
- Windows xp y windows 7
- Proteus V7.7 SP2
- CCS PIC C COMPILER v4.084

_________________________________________________________________________________

TUTORIAL BÁSICO PIC C COMPILER

Los Fuses en el PIC 16F876A

#FUSES

LP //Adapta el circuito oscilador interno para trabajar con un oscilador de baja potencia < 200KHz

XT //Adapta el ircuito osciladotr interno para trabajar con un cristal resonador de frecuencia 4MHz o inferior

HS //Adapta el circuito oscilador interno para trabajar con un cristal resonador superior a 4MHz

RC //Adapta el circuito oscilador interno para trabajar con un circuito resonador RC. (Opción por defecto)

WDT //Habiliatación del reset por rebose de watchdog (Opción por defecto)

NOWDT //No habilitación del reset por watchdog

BROWNOUT //Reset en bajadas de tensión de alimentación por debajo de 4V. (Opción por defecto)

NOBROWNOUT //Desactivado reset por bajadas de tensión

PUT //“Power up timer”. Mantiene reseteado al PIC un tiempo en el momento de conexión de la tensión de alimentación. Permite así que empiece a ejecutar el programa con la tensión de alimentación ya estabilizada.

NOPUT //No habilita “Power Up Timer”. (Opción por defecto)

PROTECT //Protección de lectura de código de programa. Impide leer el código con dispositivos externos.

NOPROTECT //No habilita la protección de código. (Opción por defecto)

DEBUG //Monitorización hardware interno por dispositivos externos. Supone la renuncia a los pines RC6 y RC7 como pines I/O

NODEBUG //Inhabilitación modo DEBUG. (Opción por defecto)

LVP //Opción de programación del PIC a bajo voltaje. Supone la renuncia de uso del pin RB4 como pin I/O. (Opción por defecto)

NOLVP //Inhabilitación modo LVP

CPD //Protección de lectura del código contenido en la EEPROM con dispositivos externos.

NOCPD //Modo CPD inhabilitado. (Opción por defecto)

WRT_5% //Protección a la escritura de los 255 primeros bytes de la memoria de programa

WRT_25% //Protección a la escritura del primer cuarto de memoria de programa

WRT_50% //Proteccción a la escritura de la mitad inferior de memoria de programa.

NOWRT //Protección desactivada a la escritura de la memoria de programa. (Opción por defecto)

Control de un sintetizador de voz SP03 con PIC

2011-04-23T15:52:00.023+02:00

El sintetizador de voz SP03 “text to speech” reproduce oralmente cualquier cadena de caracteres ASCII. Para ello dispone de 3 posibilidades de comunicación; mediante comunicación RS232, mediante puerto paralelo y por bus I2C. En este proyecto emplearemos la comunicación I2C para el envío de mensajes con el PIC y la RS232 conectado al PC para la configuración y grabación de los mensajes predefinidos.

El modulo SP03 reproduce en el momento de su conexión siempre el mensaje que tenga alojado en la primera posición de los mensajes predefinidos. Sino se quiere que esto ocurra hay que dejar vacía esta posición.

Por tanto, lo primero que haremos es conectarnos vía RS232 desde el PC para dejar todas las posiciones vacias excepto la nº10 en la que alojaremos el mensaje “Me llamo robotypic” configurado en velocidad, tono y volumen y que mas tarde será uno de los mensajes que reproduciremos con el PIC.

Pulsa en la imagen para ampliarla.

El software de configuración se puede descargar aquí.

http://www.msebilbao.com/notas/software/Software%20sintetizador%20SP03.zip

Descargado, ejecutamos el archivo sp03.exe y nos abrirá la siguiente ventana:

Se elije el puerto de comunicación al que estamos conectados al PC. Se deja en blanco la primera de las posiciones y escribimos en el resto de posiciones deseadas los mensajes que queramos. En nuestro caso solo emplearemos la posición 10. Se ajustan los valores de volumen, tono y velocidad para el texto y se prueba en el correspondiente botón “Test”.

Con todos los ajustes y textos deseados se pulsa “Program”. Ahora el sp03 ya se queda cargado y configurado para los textos predefinidos.

Toca controlar el sp03 mediante el PIC. En este proyecto se va a mostrar 3 formas de reproducir los mensajes:

- Mediante la carga en el buffer del sp03 de todos los caracteres del mensaje a reproducir uno a uno. Sera el primer mensaje que reproduciremos; “Hola”.

- Mediante la carga en el buffer del sp03 de la cadena de texto contenida en una variable. Serán los dos siguientes mensajes; “como estas?” y “soy tu amigo”

- Y mediante la reproducción de los mensajes predefinidos accediendo a la posición en el sp03 donde se encuentran. El último de los mensajes; “me llamo robotypic”.

De los tres procedimientos, el primero es el menos adecuado, sobre todo cuando se quieren reproducir muchos mensajes diferentes, dado que nos dimensiona el codigo del programa del pic en exceso y nos obliga a conocer los valores ASCII de todos los caracteres empleados, pero como muestra didáctica del principio de funcionamiento del sp03 es bastante válido.

Pulsa en la imagen para ampliarla

Por tanto, lo primero que se debe hacer es cargar en el buffer del SP03 el mensaje a reproducir:

i2c_start(); //Comienzo de la comunicación I2C ...

i2c_write(SP03_ID); //...con la dirección del LCD03...

i2c_write(0x00); //...apuntando a la posición 0 del registro del SP03

i2c_write(0x00); //Comando nulo

i2c_write(0x00); //Volumen máximo

i2c_write(0x05); //velocidad

i2c_write(0x03); //Tono

i2c_write(0x48); //texto "h"

i2c_write(0x6F); //texto "o"

i2c_write(0x6C); //texto "l"

i2c_write(0x61); //texto "a"

i2c_write(0x00); //Comando nulo

i2c_stop (); //Finalización de la transmisión

Y una vez cargado reproducirlo con el comando 0x40:

i2c_start(); // Comienzo de la comunicación I2C...

i2c_write(SP03_ID); // ...con la dirección I2c del Sp03 ...

i2c_write(0x00); //...apuntando a la posición 0 del registro del sp03

i2c_write(0x40); //reproduce el último mensaje cargado en el sp03

i2c_stop(); // Finalización de la transmisión

A continuación, para cargar el mensaje en el buffer mediante el segundo procedimiento, primero le asignaremos a la variable “texto” la cadena de caracteres a reproducir:

strcpy (texto, "como estas?"); //En "texto" texto a reproducir

Luego identificamos el número de caracteres que posee la cadena de texto:

n=strlen(texto); //Obtiene número de caracteres del texto a reproducir

Y lo cargamos en el buffer del SP03:

i2c_start(); //Comienzo de la comunicación I2C ...

i2c_write(SP03_ID); //...con la dirección del LCD03...

i2c_write(0x00); //...apuntando a la posición 0 del registro del SP03

i2c_write(0x00); //Comando nulo

i2c_write(0x00); //Volumen máximo

i2c_write(0x05); //velocidad

i2c_write(0x03); //Tono

for ( i=0; i<n; i++) {

i2c_write(texto[i]); //caracter posición i de la cedena de texto

}

i2c_write(0x00); //Comando nulo

i2c_stop (); //Finalización de la transmisión

De esta forma, con una única subrutina, cargamos el buffer con cualquier mensaje deseado.

Y para reproducirlo, igualmente con el comando 0x40.

Finalmente el último mensaje mediante el acceso a la posición en la que se encuentra guardado. En este caso no hay que cargar el buffer del SP03 sino reproducirlo directamente:

posicion=10;

i2c_start(); // Comienzo de la comunicación I2C...

i2c_write(SP03_ID); // ...con la dirección I2c del Sp03 ...

i2c_write(0x00); //...apuntando a la posición 0 del registro del sp03

i2c_write(posicion); //Reproduce el mensaje de la posición x del sp0

i2c_stop(); // Finalización de la transmisión

En éste último procedimiento, la limitación viene dada por el número de mensajes máximo que se pueden alojar en el SP03, en concreto 30.

[+/-] Ver / Ocultar programa completo en C

En el programa completo, se puede ver que entre sucesivas reproducciones de mensaje, se han colocado unos retardos. Con ellos, además del espaciado en el tiempo entre mensajes, se evita que se cargue en el buffer del SP03 un nuevo mensaje antes de reproducir completamente el anterior. Con este último objetivo se puede utilizar el siguiente bucle de instrucciones:

int registro;

do{ //Bucle de ejecución mientras habla

i2c_start(); //Comienzo de la comunicación I2C ...

i2c_write(SP03_ID); // ...con la dirección I2c del Sp03 ...

i2c_write(0x00); //...apuntando posición 0 del registro del sp03

i2c_start(); //Reinicio de la comunicación I2C ...

i2c_write(SP03_ID+1); //... como lectura

registro=I2c_read(); //Guarda el data leido

i2c_stop(); // Finalización de la transmisión

}while(registro != 0);

La ejecución del programa se detendrá en dicho bucle hasta que termine de reproducir el texto por completo mediante la consulta del valor del registro del comando que ha originado la orden de reproducción.

En el siguiente enlace, la descarga de todos los archivos del proyecto:

Descargar archivos Control sintetizador voz SP03

En la siguiente reproducción se puede escuchar el resultado de lo explicado. Hay que decir que este tipo de sintetizadores de voz están diseñados para el idima inglés por lo que se le nota un marcado acento en ese idioma.

El proyecto contenido en el artículo ha sido diseñado con la versión v4.084 de CCS PIC C COMPILER

Control de un LCD03 por bus I2C

2011-04-02T17:29:00.045+02:00

El LCD03 es un display que permite la comunicación tanto por bus I2C como por RS232. En este caso se va a emplear la conexión I2C con el PIC 16F876A. Para ello hay que sacar el puente trasero que viene conectado por defecto para una conexión RS232.

Dentro de este bus I2C, el acceso al display se establecerá con la dirección 0xC6. Por esta dirección se enviará el texto a mostrar así como los comandos para su control.

Decimal	Comando	Descripción

1	Inicio de Cursor	Fija el cursor en la posición de inicio (esquina superior izquierda)
2	Fijar cursor (1-80)	Fija el cursor en una posición especificada tras el byte siguiente, donde 1 es de la esquina superior izquierda y 80 es la esquina inferior derecha
3	Fijar cursor (línea, columna)	Fija el cursor utilizando dos bytes, donde el primer byte es la línea y el segundo byte es la columna
4	Ocultar cursor	Oculta la posición del cursor en el display
5	Mostrar cursor bajo	Cambia el tipo de cursor a un cursor bajo de subrayado
6	Mostrar cursor parpadeante	Cambia el tipo de cursor a un cursor parpadeante
8	Borrar carácter anterior	Borra el carácter anterior a la posición del cursor
9	Tabulador horizontal (según configuración del tabulador)	Mueve la posición actual del cursor a la posición definida en la configuración del comando 18 (por defecto el espacio del tabulador es 4)
10	Salto de línea (LF) inteligente	Mueve el cursor a la línea inferior en la posición de la misma columna
11	Tabulador vertical	Mueve el cursor a la línea superior en la posición de la misma columna
12	Borrar pantalla	Borra toda la pantalla y coloca el cursor en la posición de inicio
13	Retorno de carro	Mueve el cursor al principio de la siguiente línea
17	Borrar columna	Borra el contenido de la columna actual y mueve el cursor a la siguiente columna
18	Configuración tabulador	Define el tamaño del tabulador, el byte siguiente puede tener un tamaño de 1 a 10
19	Apaga la iluminación	Apaga la iluminación de la pantalla.
20	Enciende la iluminación	Enciende la iluminación de la pantalla.
27	Generador de caracteres personalizados	Permite la creación de 8 caracteres personalizados.
32-255	Caracteres ASCII	Escribe caracteres ASCII en el display

Para escribir un comando con el PIC sobre el display y ejecutar su acción correspondiente se escribe sobre el registro 0 del LCD03 el correspondiente comando:

i2c_start(); //Comienzo de la comunicación I2C ...

i2c_write(LCD03_ID); //...con la dirección del LCD03...

i2c_write(0); //...apuntando a la posición 0 del registro del LCD03

i2c_write(comando); //acción a ejecutar según el valor de “comando”

i2c_stop (); //Finalización de la transmisión

Donde “LCD03_ID” contiene la dirección del bus para el LCD (0xC6) y “comando” el valor decimal que especifica la actuación a realizar sobre el display según la tabla anterior.

Si en lugar de ejecutar un comando lo que se desea es escribir un texto, un posible procedimiento es el especificado a continuación.

Primero se guarda en una variable tipo buffer (texto) la cadena de caracteres a escribir en el LCD:

strcpy (texto, "Mensaje a mostar"); //En “texto” se guarda el mensaje

Si se quiere mostrar centrado en alguna de las lineas del display, antes identificaremos cuantos caracteres posee el mensaje guardado:

n=strlen(texto); //En “n” el número de caracteres del mensaje

Y establecemos, teniendo en cuenta que se trata de un display de 4x20 caracteres, con las variables columna y linea en que punto del display comenzará a mostrarse el mensaje:

columna=((20-n)/2)+1; //Posición texto centrado...

linea=1; //... en la 1ª linea

Y se posiciona cursor en el LCD:

i2c_start(); //Comienzo de la comunicación I2C ...

i2c_write(LCD03_ID); //...con la dirección del LCD03...

i2c_write(0); //...apuntando a la posición 0 del registro del LCD03

i2c_write(3); //comando posicionar cursor...

i2c_write(linea); //...en la linea...

i2c_write(columna); //... y en la columna indicadas

i2c_stop (); //Finalización de la transmisión

Finalmente, posicionado ya el cursor, se escribe secuencialmente toda la cadena de texto:

for ( i=0; i<n; i++) {

i2c_start(); //Comienzo de la comunicación I2C ...

i2c_write(LCD03_ID); //...con la dirección del LCD03...

i2c_write(0); //...apuntando a la posición 0 del registro del LCD03

i2c_write(texto[i]); //...escribe caracter posición i de texto[]

i2c_stop (); //Finalización de la transmisión

delay_ms(10);

}

[+/-] Ver / Ocultar programa completo en C

En este video se puede verificar su funcionamiento según el procedimiento explicado.

Todos los archivos del proyecto se pueden descargar de este enlace:

Descargar archivos Control LCD03 por I2C

El proyecto contenido en el artículo ha sido diseñado con la versión v4.084 de CCS PIC C COMPILER