Escolar Documentos
Profissional Documentos
Cultura Documentos
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
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:
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.
4. Abra Arduino IDE y seleccione el puerto serie correcto al que está conectado el
convertidor.
El PicKit tiene un conector de 6 pines con el pin número 1 marcado con una
flecha blanca en el dispositivo.
2 Vcc, Vdd
3 Gnd, Vss
4 TX
5 RX
while( 1 )
{
//To print a variable
sprintf(array,"%d",variable);
printf(array);
printf("\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.
#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;
data = U1RXREG;
if ( U1STAbits.OERR = 1 )
{
U1STAbits.OERR = 0;
}
IFS0bits.U1RXIF = 0;
}
int main()
{
// Set all port D pins as outputs
_TRISD0 = 0;
while(1)
{
__delay_ms(1000);
return 0;
}
Transmisión de datos en serie desde dsPIC30F4013 UART
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;
}