Você está na página 1de 27

UART-HARDWARE

SESION14
EJERCICIO1.- COMUNICACIÓN SERIAL dsPIC30F4013
Este es un ejemplo de enviar texto desde un microcontrolador dsPIC30F4013 a una
PC a través de UART.
Este programa alterna un LED en RD0 una vez por segundo. Cada vez que se
enciende o apaga el LED, la palabra "Hola" se transmite a través del UART utilizando
la función printf.
Codigo del #include <xc.h>
programa #include <stdio.h>
#include <libpic30.h>
// Configuration settings
_FOSC(CSW_FSCM_OFF & FRC_PLL16); // Fosc=16x7.5MHz, Fcy=30MHz
_FWDT(WDT_OFF); // Watchdog timer off
_FBORPOR(MCLR_DIS); // Disable reset pin
int main()
{
TRISD = 0; // Set all port D pins as outputs

// Setup UART - most default options are fine


U1BRG = 48; // 38400 baud @ 30 MIPS
U1MODEbits.UARTEN = 1; // Enable UART
while(1)
{
printf("Hello\r\n"); // Send text via UART
_LATD0 = 1 - _LATD0; // Toggle LED on RD0
__delay32(30000000); // 1 second delay
}
return 0;
}
Cómo enviar y recibir datos de UART en dspic30f

UART es el protocolo de comunicación más comúnmente utilizado en


microcontroladores debido a su simplicidad, fácil implementación y requisitos
mínimos de hardware.
Esta información y la implementación del código de ejemplo lo guiarán por el
proceso de lograr una comunicación UART exitosa entre un microcontrolador
dspic y una PC.
Cosas necesarias para la comunicación UART

El primer paso debería ser reunir todas las cosas necesarias para la
comunicación UART. La siguiente lista resume estos requisitos de hardware y
software:

I. Software de comunicación UART para PC

Opción 1: Preferiría el Arduino IDE para este propósito. El Arduino IDE tiene
un monitor en serie que se puede usar para controlar los datos enviados desde el
microcontrolador. También tiene un excelente monitor gráfico para trazar los datos
recibidos. El mismo IDE también se puede usar para enviar datos en serie.

Opcion 2: La herramienta PicKit ™ también tiene un monitor en serie para


enviar y recibir datos, pero no tiene un trazador serial. Tampoco es compatible con
velocidades de baudios elevadas de hasta 115000 que el Arduino IDE puede
admitir.
II. Convertidor / transceptor de USB a serie

Opción 1: El convertidor PL2302 USB a TTL se puede usar muy cómodamente


como el transceptor entre el puerto serie USB de la PC y las patillas uart TX / RX
del microcontrolador. Es muy barato y está disponible en Internet y en las tiendas
electrónicas locales (al menos en mi área).

Opcion 2: La herramienta de programación de los microcontroladores Pic, el


PicKit ™ también tiene un transceptor UART incorporado. La ventaja de usar esto
es que no necesitará comprar hardware adicional ya que PicKit hará el trabajo.
(Suponiendo que ya lo tiene puesto que está programando las imágenes). Lo malo
es que no puede colocar el PicKit dentro de sus proyectos finalizados, ya que
podría necesitarlo para usarlo más adelante.

En este caso, el convertidor USB a ttl es una mejor opción


Opción 3: Un circuito de conversión de UART a RS232 puede ser
fabricado con la ayuda de los CI MAX232 y el cable RS232. Los
circuitos integrados suelen ser baratos, pero te costará más tiempo
fabricar el circuito. Esta solía ser la solución heredada antes de la
llegada de los módulos de conversión usb a ttl.
III. microcontrolador dsPic y su programador Un dispositivo de pic y su
programador para cargar el código.

IV. Algunos cables de puente. Para realizar las conexiones necesarias


entre los pines TX / RX del microcontrolador y el convertidor USB a TTL

V. Cable de extensión USB (opcional). En caso de que necesite conectar


el conversor usb a ttl lejos de su PC cuando finalmente esté armando su
proyecto.
Módulo convertidor USB a ttl PL2302
Después de revisar la lista de cosas necesarias, puede continuar con los pasos 1 a
X a continuación

1) Instale el software requerido y los controladores Instale el monitor de


serie de su elección en su PC como dije antes.
Prefiero el Arduino IDE. Si usa el convertidor de USB a TTL: Tendrá que
descargar su controlador e instalarlos antes de que pueda hacer que el módulo
funcione.

Los controladores están disponibles en el sitio web de Prolific Systems y en


otros sitios en Internet. Asegúrese de que los controladores que descarga son
compatibles con Windows 7, de lo contrario, no funcionará. Busque un tutorial
separado para la instalación del controlador si tiene problemas. Después de
instalar el controlador, debe probar el convertidor TTL para asegurarse de que
funciona correctamente. Se recomienda que no continúe antes de probar el
convertidor.
Para probar el convertidor:

1. Primero instale el controlador requerido y reinicie el sistema.

2. Conecte el módulo convertidor y la PC debe notar una nueva conexión del


dispositivo.

3. Corta las patillas TX y RX en el convertidor TTL con la ayuda de un puente.

4. Abra Arduino IDE y seleccione el puerto serie correcto al que está conectado el
convertidor.

5. Envíe cualquier dato a través del monitor serial.

6. Si vuelve a recibir los mismos datos enviados en el monitor serie, entonces el


módulo funciona correctamente.
Si usa PicKit:
Simplemente descargue el programa Pickit y conecte el dispositivo PicKit a su PC
2) Cablee las conexiones.

Para convertidor TTL


Corresponding PIN
Pin Name on the
name on the Micro-
Converter
controller
TX RX
RX TX
GND GND, Vss
5 V (optional) Vdd, Vcc
Cómo conectar el convertidor PL2303 USB a TTL con el microcontrolador dspic
Los nombres de los pines están impresos en la parte posterior del
convertidor.

Los números de pin exactos correspondientes a sus nombres de pin se


deben encontrar en la hoja de datos, ya que cambian de dispositivo a
dispositivo.

Se puede usar opcionalmente un suministro de 5 V o 3,3 V del convertidor


para alimentar el microcontrolador.

Es obligatorio hacer que la Tierra del controlador y el convertidor sean


comunes.
Para PicKit:

El PicKit tiene un conector de 6 pines con el pin número 1 marcado con una
flecha blanca en el dispositivo.

Corresponding Pin Name on the


Pin number on the 6-pin header
MCU

2 Vcc, Vdd
3 Gnd, Vss
4 TX
5 RX

Además, el esquema del cableado también se muestra en un recuadro dentro de la herramienta


UART de PicKit.
3) Enviar datos de dspic a través de UART

Después de conectar las conexiones y probar el módulo convertidor TTL para


asegurarse de que ha comenzado a funcionar, cargue el código para enviar
datos a través de UART.

 El texto se puede enviar usando la función printf () en la biblioteca stdio.h.

 Las variables pueden enviarse primero convirtiéndolas en una matriz y luego


usando printf () para imprimirlas.
#define FCY 30000000
#include <xc.h>
#include <stdio.h>
#include <delay.h>
#include <libpic30.h>
#include <math.h>
#include <p30F4011.h>

_FOSC(CSW_FSCM_OFF & FRC_PLL16); // Fosc=16x7.5MHz, i.e. 30 MIPS


_FWDT(WDT_OFF); // Watchdog timer off
_FBORPOR(MCLR_DIS);

void UART_Init ( void )


{
_TRISF3 = 0; //Look for the exact TX/RX pins of your pic device
_TRISF2 = 1; //TX pin must be set as output port and RX input

U1BRG = 7; // 115000 baud rate @ 30 MIPS


U1MODEbits.UARTEN = 1; // Enable UART
}
int main( void )
{
UART_Init();

while( 1 )
{
//To print a variable
sprintf(array,"%d",variable);
printf(array);
printf("\r\n");

//To print text


printf(“UNAC-FIEE\r\n");

__delay_ms(1000);
}
4) Recibir datos a través de UART en dspic

Para recibir datos de UART, deberá utilizar una interrupción de recepción UART que
se activará cada vez que se reciba un paquete de datos en los registros de
recepción UART (U1RXREG).
Esta información se transfiere a otra variable y el búfer de recepción se borra si está
lleno. Puede usar el siguiente código de ejemplo.

 Para asegurarse de que la interrupción realmente se está disparando, se ha


conectado un LED en el puerto D0 que parpadeará una vez cuando se active la
interrupción.

 Si el LED parpadea inmediatamente después de enviar algunos datos del monitor


serie, suponga que el código está funcionando correctamente.

 El valor de la variable "datos" también se puede verificar en el modo de


depuración.
Código de ejemplo para recibir datos de UART
#define FCY 30000000

#include <xc.h>
#include <stdio.h>
#include <libpic30.h>
#include <uart.h>
#include <delay.h>
#include <p30F4011.h>

// Configuration settings
_FOSC(CSW_FSCM_OFF & FRC_PLL16); // Fosc=16x7.5MHz, Fcy=30MHz
_FWDT(WDT_OFF); // Watchdog timer off
_FBORPOR(MCLR_DIS); // Disable reset pin

char data;

void Interrupt_Init( void )


{
IEC0bits.U1RXIE = 1;
}
void __attribute__((interrupt, auto_psv)) _U1RXInterrupt(void)
{
_LATD0 = 1;
__delay_ms(500);
_LATD0 = 0;

data = U1RXREG;

if ( U1STAbits.OERR = 1 )
{
U1STAbits.OERR = 0;
}
IFS0bits.U1RXIF = 0;
}
int main()
{
// Set all port D pins as outputs
_TRISD0 = 0;

// Setup UART - most default options are fine


UART_Init();
Interrupt_Init();

while(1)
{
__delay_ms(1000);

return 0;
}
Transmisión de datos en serie desde dsPIC30F4013 UART

El siguiente programa es un ejemplo de transmisión de datos en serie desde el UART


dsPIC30F4013.
Este programa lee repetidamente lecturas analógicas de 10 bits de AN0-AN7 y luego
imprime los resultados en la salida en serie.

La velocidad en baudios se establece en 38,400.

Estoy usando el oscilador RC interno para sincronizar el PIC, por lo que es probable
que Fcy (y, por lo tanto, la velocidad en baudios) esté un poco apagado.
Por el momento, la transmisión tendrá que hacer.
// // Este programa es un ejemplo de transmisión UART para dsPIC30F4011.
// // Para compilar esto, se debe especificar un tamaño de pila porque
// se usa printf. Establecí mi tamaño de almacenamiento dinámico a 1024 en MPLAB // como sigue:
// // Proyecto-> Opciones de compilación ...-> Proyecto-> MPLAB LINK30-> Tamaño de pila = 1024
// // Aparentemente, un tamaño de montón de 0 podría estar bien para printf, pero
// para scanf se puede requerir un número mayor (por ejemplo, 1024).

#include <libpic30.h>
#include <p30f4011.h>
#include <stdio.h> // Configuration settings
_FOSC(CSW_FSCM_OFF & FRC_PLL16); // Fosc=16x7.5MHz, Fcy=30MHz
_FWDT(WDT_OFF); // Watchdog timer off
_FBORPOR(MCLR_DIS); // Disable reset pin
// Function prototypes
void configure_pins();
unsigned int read_analog_channel(int n);
int main() { // Variables to store analog input voltages
int v0, v1, v2, v3, v4, v5, v6, v7; // Set up which pins are which
configure_pins();
while(1)
{ // Read AN0-AN7
v0 = read_analog_channel(0);
v1 = read_analog_channel(1);
v2 = read_analog_channel(2);
v3 = read_analog_channel(3);
v4 = read_analog_channel(4);
v5 = read_analog_channel(5);
v6 = read_analog_channel(6);
v7 = read_analog_channel(7); // Print the measured voltages on the serial o/p
printf("AN0=%04d, AN1=%04d, AN2=%04d, AN3=%04d, ", v0, v1, v2, v3);
printf("AN4=%04d, AN5=%04d, AN6=%04d, AN7=%04d\r\n", v4, v5, v6, v7);
}
return 0;
}
void configure_pins()
{ // Configure RD0 as a digital output
LATD = 0;
TRISD = 0b11111110; // Configure analog inputs
TRISB = 0x01FF; // Port B all inputs
ADPCFG = 0xFF00; // Lowest 8 PORTB pins are analog inputs
ADCON1 = 0; // Manually clear SAMP to end sampling, start conversion
ADCON2 = 0; // Voltage reference from AVDD and AVSS
ADCON3 = 0x0005; // Manual Sample, ADCS=5 -> Tad = 3*Tcy
ADCON1bits.ADON = 1; // Turn ADC ON
// Set up UART
// Default is 8 data bits, 1 stop bit, no parity bit
U1BRG = 48; // 38400 baud @ 30 MIPS
U1MODEbits.UARTEN = 1; // Enable UART
U1STAbits.UTXISEL = 1; // interrupt when TX buffer is empty
U1STAbits.UTXEN = 1; // Enable TX
}
// Esta función lee una muestra única de la especificada
// entrada analogica. Debe tomar menos de 2.5us si el chip
// se ejecuta a unos 30 MIPS.
unsigned int read_analog_channel(int channel)
{
ADCHS = channel; // Select the requested channel
ADCON1bits.SAMP = 1; // start sampling
__delay32(30); // 1us delay @ 30 MIPS
ADCON1bits.SAMP = 0; // start Converting
while (!ADCON1bits.DONE); // Should take 12 * Tad = 1.2us
return ADCBUF0;
}