void initUSART(void) {
OpenUSART( USART_TX_INT_OFF &
USART_RX_INT_ON &
USART_ASYNCH_MODE &
USART_EIGHT_BIT &
USART_CONT_RX &
USART_BRGH_HIGH, 129);
IPR1bits.RCIP = 1;
}
void FraiseInit(void)
{
/*FrTXin=0;
FrTXout=0;
FrTXfree=255;*/
FrGotLineFromUsb=0;
LineFromUsbLen=0;
FraiseStatus.VAL=0;
FraiseState=fIDLE;
FraiseMessage=fmessNONE;
FrRXin=0;
FrRXout=0;
PollDelay=0;
//OpenUSART(USART_TX_INT_OFF & USART_RX_INT_OFF & USART_ASYNCH_MODE & USART_EIGHT_BIT & USART_CONT_RX & USART_BRGH_HIGH, 103); // 48 MHz/4/115200 = 104
BAUDCON = 0x08; // BRG16 = 1
OpenUSART(USART_TX_INT_OFF & USART_RX_INT_OFF & USART_ASYNCH_MODE & USART_NINE_BIT & USART_CONT_RX & USART_BRGH_HIGH & USART_ADDEN_OFF, 47); // 48 MHz/4/250000 = 48
USART_Status.TX_NINE=1;
// Initialize Timer2
// The prescaler will be at 16
T2CONbits.T2CKPS1 = 1;
T2CONbits.T2CKPS0 = 1;
// We want no TMR2 post scaler
T2CONbits.T2OUTPS3 = 0;
T2CONbits.T2OUTPS2 = 0;
T2CONbits.T2OUTPS1 = 0;
T2CONbits.T2OUTPS0 = 0;
// Set our reload value
//PR2 = kPR2_RELOAD;
PR2 = 255;
T2CONbits.TMR2ON = 1;
// Initalize switchs and leds
mInitAllLEDs();
mInitSwitch();
mInitSerDrv();
//Serial_Init_Receiver();
Serial_Init_Driver();
for(i=0;i<16;i++) {
Children[i]=0;
ChildrenOK[i]=0;
}
MaxPolledChild=4;
_PolledChild=1;_bit_PolledChild =2;
// Set interrupt priorities
PIE1bits.TMR2IE = 0;
IPR1bits.TMR2IP = 1;
IPR1bits.TXIP = 1;
IPR1bits.RCIP = 1;
INTCONbits.GIEH = 1;
}
/*******************************************************************************
* FUNCTION NAME: Initialize_Serial_Comms
* PURPOSE: Opens the serial port 1 for communicating with your PC at
* 115k baud, 8 bits, no parity, one stop bit, and no flow control.
* CALLED FROM: user_routines.c
* ARGUMENTS: none
* RETURNS: void
*******************************************************************************/
void Initialize_Serial_Comms (void)
{
OpenUSART(USART_TX_INT_OFF &
USART_RX_INT_OFF &
USART_ASYNCH_MODE &
USART_EIGHT_BIT &
USART_CONT_RX &
USART_BRGH_HIGH,
baud_115);
Delay1KTCYx( 50 ); /* Settling time */
}
void openSerialPort(void)
{
OpenUSART( USART_TX_INT_OFF &
USART_RX_INT_OFF &
USART_ASYNCH_MODE &
USART_EIGHT_BIT &
USART_CONT_RX &
USART_BRGH_HIGH,71); //71 = baud rate of 19200 on a 22.1 mHz clock
printf("Serial Port Online\n\r"); //print this out to inform that the serial port is up
return;
}
void Serial_Init(void)
{
RCSTAbits.SPEN=1;
TRISCbits.TRISC7 = 1;
TRISCbits.TRISC6 = 1;
OpenUSART( USART_TX_INT_OFF &
USART_RX_INT_OFF &
USART_ASYNCH_MODE &
USART_EIGHT_BIT &
USART_SINGLE_RX &
USART_BRGH_HIGH, 25);
BAUDCON = 0b01000000;
}
int main(int argc, char** argv) {
OSCCON = 0xF7; //0b11110111;
//TRISD = 0x00; //LED output
TRISC = 0x80; //RX: input, TX: output
TRISB = 0x10; //Columns and rows = inputs, except column 1 = output
LATB = 0x00;
CloseUSART();
OpenUSART(RS232_CONFIG, RS232_SPBRG);
baudUSART(RS232_BAUD);
INTCON = 0xA0; //GIE = 1, TMR0IE = 1, TMR0IF = 0
while (1) {
}
return (EXIT_SUCCESS);
}
// Configura USART
void inicializarSerial()
{
RCSTAbits.SPEN = 1;
TRISCbits.TRISC7 = 1;
TRISCbits.TRISC6 = 1;
TXSTAbits.TXEN = 1;
RCSTAbits.CREN = 1;
OpenUSART( USART_TX_INT_OFF &
USART_RX_INT_OFF &
USART_ASYNCH_MODE &
USART_EIGHT_BIT &
USART_CONT_RX &
USART_BRGH_HIGH,51);
}
void main (void) {
// Interrupt configs
RCONbits.IPEN = 0; // Deshabilitar prioridades
INTCONbits.PEIE = 1; // Habilitar interrupciones de perifericos
INTCONbits.GIE = 1; // Habilitar interrupciones globales
// Inicializa el USART y lo configura a 8N1, 9600 badios
OpenUSART(
USART_TX_INT_OFF & // TX sin interrupciones
USART_RX_INT_ON & // RX con interrupciones
USART_ASYNCH_MODE & // Modo asincronico
USART_EIGHT_BIT & // 8 bits de datos
USART_CONT_RX & // Recepci?n continua
USART_BRGH_HIGH, 129 // 9600 baudios a 20 mhz (calcular con PicBaudRate)
);
// Init LCD
lcd_init();
lcd_gotoxy(0,2);
lcd_putrs(" Temp: ");
// Safety?
__delay_ms(39);
while (1) {
if (dataFlag != 0) {
dataFlag = 0;
// Convierte el float a string
sprintf(strGrados, "%2.1f,", grados);
if (data == 0xFD) putcUSART(0xFD); // Control
else if (data == 0xFF) putsUSART(strGrados); // Env�a info
}
Medir_Temperatura();
__delay_ms(39);
grados = Leer_DS18B20();
lcd_gotoxy(10,2);
printf("%2.1f", grados);
}
}
void main(void) {
int a, b;
char buf[80];
/*
* El oscilador interno por defecto, es 1 Mhz. Con esta velocidad, y la configuración
* del modo de UART que voy a utilizar, no podré alcanzar los 9600 bps. Por lo menos
* debo tener una velocidad de 4 Mhz, lo cual lo puedo lograr a partir del oscilador
* interno si configuro los bits del registro de control del oscilador.
* Ver pag. 29 de la hoja de datos para mayor información
*/
OSCCONbits.IRCF = 0b101;
/* La función OpenUSART utiliza 2 argumentos: configuración del puerto, y velocidad */
/*
* La configuración elegida para el uso del puerto, se define como:
* - deshabilito interrupción para la transmición
* - deshabilito interrupción para la recepción
* - modo asíncrono
* - tranmisión de 8 bits
* - recepción continua de bytes
* - bit BRGH=1
*
* Ver pag. 1152 del documento del XC8 Peripheral Libraries
*/
unsigned char config = USART_TX_INT_OFF & USART_RX_INT_OFF & USART_ASYNCH_MODE & USART_EIGHT_BIT & USART_CONT_RX & USART_BRGH_HIGH;
/*
* En función de la configuración elegida, para alcanzar la velocidad de 9660 bps
* se debe configurar el segúndo argumento de la función OpenUSART con el valor=25
* Ver tabla 18.5, pag 251 de la datasheet del MCU, tabla correspondiente a los
* valores: SYNC=0, BRGH=1, BRG16=0, FOSC=4Mhz
*/
unsigned int spbrg = 25;
// Abre y configura el puerto serie.
OpenUSART(config, spbrg);
for(;;) {
printf("\r\nIngrese el valor de a: ");
if (gets(buf))
a=atoi(buf);
printf("\r\nIngrese el valor de b: ");
if (gets(buf))
b=atoi(buf);
printf("\r\nLa suma de a y b es %i", suma(a, b));
}
}
/**
* \brief The PIC18 init function.
*
* \todo Initialize the USART and timer/ccp.
*/
void pic18_init(void)
{
/*
* Setup the interrupts, all interrupts are by default low prio and
* global low priority interrupts should be disabled.
*/
IPR1 = IPR2 = INTCON = 0;
RCONbits.IPEN = 1;
INTCONbits.GIEH = 1;
/*
* Open the usart for 9600 baud and eight bit transmission,
* no interrupts. For more info about this call see the C18
* library manual.
*/
OpenUSART(
USART_TX_INT_OFF & USART_RX_INT_OFF &
USART_ASYNCH_MODE & USART_EIGHT_BIT &
USART_CONT_RX & USART_BRGH_HIGH,
127
);
/* Set the pins for the USART. */
TRISCbits.TRISC6 = 0;
TRISCbits.TRISC7 = 1;
/*
* Let's use CCP2 and Timer3, this is mainly due to CCP1
* being an enhanced CCP that we don't really need.
*/
OpenTimer3(
TIMER_INT_ON & T3_16BIT_RW &
T3_SOURCE_INT & T1_CCP1_T3_CCP2 &
T3_PS_1_8
);
/* Make sure the timer is OFF. */
T3CONbits.TMR3ON = 0;
TMR3L = TMR3H = 0;
/* Reset the CCP2 module. */
CCP2OFF();
}
void InitApp(void)
{
unsigned char config, baudconfig;
unsigned spbrg;
/* TODO Initialize User Ports/Peripherals/Project here */
/* Setup analog functionality and port direction */
SRAM_Setup_Pins();
/* Initialize peripherals */
CloseUSART();
config = USART_TX_INT_OFF & USART_RX_INT_ON & USART_BRGH_HIGH & USART_CONT_RX &
USART_EIGHT_BIT & USART_ASYNCH_MODE & USART_ADDEN_OFF;
/* SPBRG based on 8MHz clk */
//spbrg = 16; //115200
//spbrg = 34; // 57600
spbrg = 103; // 19200 known working w/ 8MHz clock
//spbrg = 207; // 9600
//spbrg = 832; // 2400
//spbrg = 1665; // 1200
/* SPBRG based on 48MHz clk */
//spbrg = 103; //115200 48MHz
OpenUSART(config, spbrg);
baudconfig = BAUD_IDLE_CLK_LOW & BAUD_16_BIT_RATE & BAUD_WAKEUP_OFF & BAUD_AUTO_OFF;
baudconfig &= ~0x20; // RX Not inverted
baudUSART(baudconfig);
PIR1bits.RCIF = 0; // Clear RX interrput flag
PIE1bits.RCIE = 1; // Enable UART receive interrupts
IPR1bits.RCIP = 0; // Set UART receive as low priority interrupt
PIR1bits.TXIF = 0; // Clear TX interrupt flag
PIE1bits.TXIE = 0; // Disable UART transmit interrupts
IPR1bits.TXIP = 0; // Set UART transmit as low priority interrupt
/* Configure the IPEN bit (1=on) in RCON to turn on/off int priorities */
RCONbits.IPEN = 1;
/* Enable interrupts */
PIR1 = 0; // Clear peripheral interrupts
INTCONbits.GIEH = 1; // Enable high priority interrupts
INTCONbits.GIEL = 1; // Enable low priority interrupts
}
// main application code
void main()
{
u8 counter=0;
char str[20];
// TRISBbits.TRISB7=0;
init_picstar();
init_buzzer();
init_bPous;
// Configure Hardware USART
OpenUSART( USART_TX_INT_OFF &
USART_RX_INT_OFF &
USART_ASYNCH_MODE &
USART_EIGHT_BIT &
USART_CONT_RX &
USART_BRGH_LOW,
BAUD19200); //check the uard_baud.h file for available baud rates.
bip();
// let's wait until we powered the PICKIT2
delay_ms(2000);
// print from ROM
putrsUSART( "\r\nHello World!\r\n" );
// main loop
while(1)
{
if(bPous==0)
{
// bip();
// print from variable string
sprintf(str,"counter= %u \r\n", counter++);
putsUSART(str);
delay_ms(1000);
}
} // end of main loop
}
void main( void ) {
// Pins C6 and C7 are used for UART TX and RX respectively
InitEcoCar();
TRISCbits.RC4 = 0;
// Open USART:
OpenUSART( USART_TX_INT_OFF &
USART_RX_INT_OFF &
USART_ASYNCH_MODE &
USART_EIGHT_BIT &
USART_CONT_RX &
USART_BRGH_HIGH, 207 ); // 9600 bps baud rate
RCSTAbits.SPEN = 1; // Enable USART on pins C6, C7
BAUDCONbits.BRG16 = 0; // 8-bit BR Generator
J1939_Initialization( TRUE );
while (J1939_Flags.WaitingForAddressClaimContention)
J1939_Poll(5);
// CANbus is now initialized and we can now loop while we check
// our message receive buffer for new CANbus messages (where all received messages are put).
while (1) {
//Receive Messages
J1939_Poll(10);
while (RXQueueCount > 0) {
J1939_DequeueMessage( &Msg );
if ( Msg.GroupExtension >= 0xA0 && Msg.GroupExtension <= 0xA7 )
LATCbits.LATC4 = 1;
// Currently, only broadcast messages are repeated
// if( Msg.PDUFormat == PDU_BROADCAST )
putSerialData(Msg.GroupExtension, Msg.Data[0], Msg.Data[1]);
if ( J1939_Flags.ReceivedMessagesDropped )
J1939_Flags.ReceivedMessagesDropped = 0;
LATCbits.LATC4 = 0;
}
}
}
void configuracao_EUSART (void)
{
//#define CloseUSART( ) RCSTA&=0b01001111,TXSTAbits.TXEN=0,PIE1&=0b11001111
CloseUSART(); // fecha qualquer USART que estaria supostamente aberta antes
// just closes any previous USART open port
OpenUSART( USART_TX_INT_OFF &
USART_RX_INT_OFF &
USART_ASYNCH_MODE &
USART_EIGHT_BIT &
USART_CONT_RX &
USART_BRGH_LOW,
12
);
// em 4 Mhz, com BRGH LOW (Bit Rate Generator LOW):
// 51 = 1200bps; 25 = 2400bps; 6 = 9600bps (Err);
// em 8 Mhz, com BRGH LOW (Bit Rate Generator LOW):
// 103 = 1200bps; 25 = 4800bps; 51 = 2400bps; 12 = 9600bps
}
void main(void) {
/*
* El oscilador interno por defecto, es 1 Mhz. Con esta velocidad, y la configuración
* del modo de UART que voy a utilizar, no podré alcanzar los 9600 bps. Por lo menos
* debo tener una velocidad de 4 Mhz, lo cual lo puedo lograr a partir del oscilador
* interno si configuro los bits del registro de control del oscilador.
* Ver pag. 29 de la hoja de datos para mayor información
*/
OSCCONbits.IRCF = 0b101;
/* La función OpenUSART utiliza 2 argumentos: configuración del puerto, y velocidad */
/*
* La configuración elegida para el uso del puerto, se define como:
* - deshabilito interrupción para la transmición
* - deshabilito interrupción para la recepción (no voy a utilizar la recepción)
* - modo asíncrono
* - tranmisión de 8 bits
* - recepción continua de bytes (igual lo voy a ignorar)
* - bit BRGH=1
*
* Ver pag. 1152 del documento del XC8 Peripheral Libraries
*/
unsigned char config = USART_TX_INT_OFF & USART_RX_INT_OFF & USART_ASYNCH_MODE & USART_EIGHT_BIT & USART_CONT_RX & USART_BRGH_HIGH;
/*
* En función de la configuración elegida, para alcanzar la velocidad de 9660 bps
* se debe configurar el segúndo argumento de la función OpenUSART con el valor=25
* Ver tabla 18.5, pag 251 de la datasheet del MCU, tabla correspondiente a los
* valores: SYNC=0, BRGH=1, BRG16=0, FOSC=4Mhz
*/
unsigned int spbrg = 25;
// Abre y configura el puerto serie.
OpenUSART(config, spbrg);
for(;;) {
while (BusyUSART()); // Espera a que el buffer esté libre para tranmistir
printf("Hola Mundo!!!\n");
Delay10KTCYx(20); // Espera entre una escritura y la siguiente
}
}
void main()
{
unsigned char c;
unsigned char column;
TRISA=0;
TRISC=0;
LATCbits.LATC4=1;
// PORTA=1;
// PORTB=0xFF;
// PORTC=0xFF;
OSCCON=0b01100000; //Internal 4MHZ Oscillator
ADCON1=0x7F;//Make all ports Digital
OpenUSART(USART_TX_INT_OFF &// Initialize USART, Transmit interrupt off
USART_RX_INT_ON &// Receive interrupt ON
USART_ASYNCH_MODE & // Use USART in asynchronous mode
USART_EIGHT_BIT &// Eight bit data
USART_CONT_RX &// Enable continous receiving
USART_BRGH_LOW,// Do not use baud rate multiplication
12);// For a baud rate of 9600 value of SPBRGH:SPBRG register pair
INTCONbits.PEIE=1;// Enable peripheral interrupts
INTCONbits.GIEH=1;// Enable all interrupts
// putrsUSART ("\nPlease type a S to Start");
OpenSPI(SPI_FOSC_4,MODE_01,SMPMID);
// SSPCON |= SPI_FOSC_64;
while(1) {
putrsUSART(0x1);
// WriteSPI(0x01);
//UARTIntPutChar(0xa);
// __delay_ms(500);
// __delay_ms(50);
}
}
void init_uart(void)
{
/*UART Variables*/
unsigned char UARTConfig = 0, baud = 0;
/*UART PINS*/
TRISCbits.RC6 = 0; //TX pin set as output
TRISCbits.RC7 = 1; //RX pin set as input
/*Ajout de l'interruption sur le port RX*/
RCIF = 0; //reset RX pin flag
RCIP = 0; //Not high priority
RCIE = 1; //Enable RX interrupt
PEIE = 1; //Enable pheripheral interrupt (serial port is a pheripheral)
ei(); //(INTCONbits.GIE = 1)
/*UART Configuration*/
UARTConfig = USART_TX_INT_OFF & USART_RX_INT_ON & USART_ASYNCH_MODE & USART_EIGHT_BIT & USART_BRGH_HIGH ;
baud=51; //Formula 16(X+1) = Fosc/Baud Rate
OpenUSART(UARTConfig,baud); //9600
}
void configureUSART(unsigned long baudrate, unsigned char osc_freq_MHz)
{
unsigned int spbrg;
TRISCbits.TRISC6 = 0; // set TX (RC6) as output
TRISCbits.TRISC7 = 1; // and RX (RC7) as input
// For a 16-bit sbprg value with USART_BRIGH_HIGH setting.
// Formula from datasheet is Baudrate = FOSC/ (4 * (spbrg + 1 ))
spbrg = (unsigned int)( ((float)osc_freq_MHz * 1.0e6) /(4.0*(float)baudrate) + 0.5 - 1.0);
OpenUSART( USART_TX_INT_OFF & USART_RX_INT_OFF & USART_ASYNCH_MODE & USART_EIGHT_BIT &
USART_CONT_RX & USART_BRGH_HIGH, spbrg );
// OpenUSART is part of the C18 usart.h library
BAUDCONbits.BRG16 = 1; // needed so we can use a 16-bit spbrg
// Note that this is not discussed in the c18 Compiler Libraries guide
Delay10KTCYx(1); // small 0.0125 s delay to allow communication speed to stabilize
// part of the C18 delays.h library
}
void InitApp(void){
/* TODO Initialize User Ports/Peripherals/Project here */
TRISA = 0x00000001; //RA0 Input
TRISB = 0b00000001; //RB0 Input
TRISC = 0x00;
TRISD = 0x00;
TRISE = 0x00;
/* Setup analog functionality and port direction */
ADCON1 = 0x0F; //For Digital
CMCON = 0x07;
/* Initialize peripherals */
PORTA = 0X00;
PORTB = 0X00; //RB0 Input
PORTC = 0X00;
PORTD = 0X00;
PORTE = 0X00;
/* Configure the IPEN bit (1=on) in RCON to turn on/off int priorities */
INTCON2bits.INTEDG0 = 0;
INTCON2bits.RBIP = 1;
/* Enable interrupts */
INTCONbits.INT0IF = 0;
INTCONbits.INT0IE = 1;
RCONbits.IPEN = 1;
INTCONbits.GIEH = 1;
INTCONbits.GIEL = 0;
/* ADC Config */
OpenADC(ADC_FOSC_16 & ADC_RIGHT_JUST & ADC_2_TAD,
ADC_CH0 & ADC_INT_OFF & ADC_VREFPLUS_VDD & ADC_VREFMINUS_VSS,
ADC_1ANA);
SetChanADC(ADC_CH0);
__delay_ms(1);
//Com PORT -> 19200bps 8Bit 1Stop / fosc = 48Mhz / BRGH = 155
TRISCbits.RC6 = 0;
TRISCbits.RC7 = 1;
OpenUSART(USART_TX_INT_OFF & USART_RX_INT_OFF &
USART_ASYNCH_MODE & USART_EIGHT_BIT & USART_BRGH_HIGH, 155);
}
void usart_init(void)
{
unsigned char config=0,spbrg=0;
//status light on
TRISA = 0; //set as output
PORTAbits.RA4 = 0; //turn on
CloseUSART(); //turn off usart if was previously on
// configure USART
config = USART_TX_INT_OFF &
USART_RX_INT_OFF &
USART_ASYNCH_MODE &
USART_EIGHT_BIT &
USART_CONT_RX &
USART_BRGH_HIGH;
// 9600 = 10 MHz / (4 * (spbrg + 1))
// spbrg = (10 MHz/9600*4) - 1
spbrg = (10000000/9600*4) - 1;
OpenUSART(config, spbrg);
}
void InitializeGPS(void)
{
// configure USART
OpenUSART( USART_TX_INT_OFF &
USART_RX_INT_OFF &
USART_ASYNCH_MODE &
USART_EIGHT_BIT &
USART_CONT_RX &
USART_BRGH_LOW,
64 );
while (BusyUSART());
putsUSART(gga_off);
while (BusyUSART());
putsUSART(gsa_off);
while (BusyUSART());
putsUSART(gsv_off);
while (BusyUSART());
putsUSART(rmc_off);
while (BusyUSART());
putsUSART(gll_off);
while (BusyUSART());
putsUSART(vtg_on);
}
// program main
void main(void)
{
//initialize UART module
OpenUSART(USART_TX_INT_OFF &
USART_RX_INT_ON &
USART_ASYNCH_MODE &
USART_EIGHT_BIT &
USART_BRGH_HIGH,
25);
INTCONbits.PEIE = 1;//Peripheral interrupt enable
INTCONbits.GIE = 1; // Golbal interrupt enable
port_init();//init ports connect to vans
while(1)
{
if(ProcessFlag)
{
ProcessCommand();//processing command receive from Zigbee device
ProcessFlag = 0;//clear the flag
}
}
}
void rs232_init(void)
{
if (rs232_initialized == 0)
{
/* baudRate = FOSC / (16 * (spbgr + 1))
* spbgr = (FOSC / (baudRate * 16)) - 1
*/
const long fosc = 25000000;
const long baudRate = 1200;
// long spbgr = (FOSC / (baudRate * 16)) - 1;
// equivalent pré-calculé :
const long spbgr = 1301;
OpenUSART( USART_TX_INT_OFF & USART_RX_INT_OFF &
USART_ASYNCH_MODE & USART_EIGHT_BIT &
USART_CONT_RX & USART_BRGH_HIGH, spbgr );
TXSTA = BIT5;
RCSTA = BIT4 | BIT7;
BAUDCON = BIT3;
rs232_initialized = 1;
}
}
void InitApp(void)
{
/* Setup analog functionality and port direction */
//LEDs
LED1_DIR = OUT;
LED2_DIR = OUT;
LED3_DIR = OUT;
//Control panel
CTRLPOT_DIR = IN;
CTRLBUTTON1_DIR = IN;
CTRLSWITCH1_DIR = IN;
CTRLLED1_DIR = OUT;
CTRLLED2_DIR = OUT;
CTRLLED3_DIR = OUT;
//UART
RX_DIR = IN;
TX_DIR = IN; //Module will dynamically change as needed
/* Initialize peripherals */
//ADC
OpenADC( ADC_FOSC_RC &
ADC_RIGHT_JUST &
ADC_4_TAD,
ADC_CH3 &
ADC_REF_VDD_VSS &
ADC_INT_OFF,
ADC_4ANA);
//Timer
OpenTimer0(TIMER_INT_ON & T0_16BIT &
T0_SOURCE_INT &
T0_PS_1_2);
WriteTimer0(0x0000);
OpenTimer1(TIMER_INT_ON &
T1_SOURCE_INT &
T1_16BIT_RW &
T1_PS_1_1 &
T1_OSC1EN_OFF &
T1_SYNC_EXT_OFF);
WriteTimer1(SERVO_MIN);
//UART
//BusPirate: m 3 6 ENTER ENTER ENTER 1 e 3 W (2)) P
OpenUSART( USART_TX_INT_OFF &
USART_RX_INT_OFF &
USART_BRGH_HIGH &
USART_NINE_BIT &
USART_ASYNCH_MODE &
USART_ADDEN_OFF, UART_BAUDRATE);
baudUSART(BAUD_IDLE_CLK_LOW &
BAUD_16_BIT_RATE &
BAUD_WAKEUP_OFF &
BAUD_AUTO_OFF);
/* Configure the IPEN bit (1=on) in RCON to turn on/off int priorities */
INTCONbits.TMR0IF = 1; //reset Interrupt Flag
PIR1bits.TMR1IF = 1;
RCONbits.IPEN = 1;
RCSTAbits.SPEN=1;
/* Enable interrupts */
ei();
}
void main(void) {
TRISA = 0x0;
TRISB = 0x0;
TRISC = 0x0;
PORTA = 0x0;
PORTB = 0x0;
PORTC = 0x0;
LATA = 0x0;
LATB = 0x0;
LATC = 0x0;
signed char length;
unsigned char msgtype;
uart_comm uc;
i2c_comm ic;
unsigned char msgbuffer[MSGLEN + 1];
uart_thread_struct uthread_data; // info for uart_lthread
timer0_thread_struct t0thread_data;
timer1_thread_struct t1thread_data; // info for timer1_lthread
encoder_struct encoder_data;
sensor_data sensors;
#ifdef __USE18F2680
OSCCON = 0xFC; // see datasheet
// We have enough room below the Max Freq to enable the PLL for this chip
OSCTUNEbits.PLLEN = 1; // 4x the clock speed in the previous line
#else
OSCCON = 0x82; // see datasheeet
OSCTUNEbits.PLLEN = 0; // Makes the clock exceed the PIC's rated speed if the PLL is on
#endif
#ifdef SENSORPIC
i2c2_comm ic2;
init_i2c2(&ic2);
#endif
// initialize everything
init_uart_comm(&uc);
init_i2c(&ic);
init_encoder(&encoder_data);
init_timer0_lthread(&t0thread_data);
init_timer1_lthread(&t1thread_data);
init_uart_lthread(&uthread_data);
init_queues();
#ifdef MASTERPIC
// Enable and set I2C interrupt to high
i2c_configure_master();
IPR1bits.SSPIP = 1;
PIE1bits.SSPIE = 1;
// initialize Timer0 to go off approximately every 10 ms
//OpenTimer0(TIMER_INT_ON & T0_8BIT & T0_SOURCE_INT & T0_PS_1_1);
CloseTimer0();
INTCONbits.TMR0IE = 0; //Enable Timer0 Interrupt
// Configure UART
OpenUSART(USART_TX_INT_OFF & USART_RX_INT_ON & USART_ASYNCH_MODE & USART_EIGHT_BIT &
USART_CONT_RX & USART_BRGH_LOW, 9); // 19.2kHz (197910/t - 1 = target)
IPR1bits.RCIP = 0;
IPR1bits.TXIP = 0;
uc.expected = 1;
PORTB = 0x0;
LATB = 0x0;
TRISB = 0x0;
#endif //MASTERPIC
#ifdef SENSORPIC
// Enable and set I2C interrupt to high
i2c_configure_slave(SENSORPICADDR);
IPR1bits.SSPIP = 1;
PIE1bits.SSPIE = 1;
i2c2_configure_master();
IPR3bits.SSP2IP = 1;
PIE3bits.SSP2IE = 1;
// Open ADC on channel 1
ADCON0= 0x01;
ADCON1=0x30;
ADCON2=0xa1;
TRISA=0x0F;
PIE1bits.ADIE = 1; //Enabling ADC interrupts
IPR1bits.ADIP = 0; //Setting A/D priority
// initialize Timer0 to go off approximately every 10 ms
OpenTimer0(TIMER_INT_ON & T0_8BIT & T0_SOURCE_INT & T0_PS_1_128);
INTCONbits.TMR0IE = 1; //Enable Timer0 Interrupt
INTCON2bits.TMR0IP = 0; //TMR0 set to Low Priority Interrupt
#endif //SENSORPIC
#ifdef MOTORPIC
i2c_configure_slave(MOTORPICADDR);
// Enable and set I2C interrupt to high
IPR1bits.SSPIP = 1;
PIE1bits.SSPIE = 1;
// Configure UART
OpenUSART(USART_TX_INT_OFF & USART_RX_INT_ON & USART_ASYNCH_MODE & USART_EIGHT_BIT &
USART_CONT_RX & USART_BRGH_LOW, 0x9);
IPR1bits.RCIP = 0;
IPR1bits.TXIP = 0;
INTCONbits.TMR0IE = 0; // Disable Timer0 Interrupt
PORTB = 0x0;
LATB = 0x0;
TRISB = 0x0;
// Set up RB5 as interrupt
TRISBbits.RB5 = 1;
INTCON2bits.RBIP = 0;
#endif //MOTORPIC
#ifdef MASTERPIC
//init_communication(MOTORPICADDR);
//init_communication(SENSORPICADDR);
#endif
// Peripheral interrupts can have their priority set to high or low
// enable high-priority interrupts and low-priority interrupts
enable_interrupts();
while (1) {
// Spins until a message appears
block_on_To_msgqueues();
// Continuously check high priority messages until it is empty
while((length = ToMainHigh_recvmsg(MSGLEN, &msgtype, (void *) msgbuffer)) >= 0) {
switch (msgtype) {
case MSGT_I2C_RQST: {
#ifdef SENSORPIC
char command = msgbuffer[0];
char length = 0;
char buffer[8];
switch(command) {
case SHORT_IR1_REQ: {
length = 2;
buffer[0] = command;
buffer[1] = 0x11;
} break;
case SHORT_IR2_REQ: {
length = 2;
buffer[0] = command;
buffer[1] = 0x22;
} break;
case MID_IR1_REQ: {
length = 2;
buffer[0] = command;
buffer[1] = 0x33;
} break;
case MID_IR2_REQ: {
length = 2;
buffer[0] = command;
buffer[1] = 0x44;
} break;
case COMPASS_REQ: {
length = 2;
buffer[0] = command;
buffer[1] = 0x55;
} break;
case ULTRASONIC_REQ: {
length = 2;
buffer[0] = command;
buffer[1] = 0x66;
} break;
default: {
length = 2;
buffer[0] = 0x0;
buffer[1] = 0x0;
} break;
}
if(length > 0) {
start_i2c_slave_reply(length,buffer);
}
#endif
#ifdef MOTORPIC
unsigned char buffer[8];
unsigned char length = 0;
char command = msgbuffer[0];
buffer[0] = command;
switch(command) {
case MOVE_FORWARD_CMD: {
length = 1;
motor_move_forward(10);
INTCONbits.RBIE = 1; // Temporary
} break;
case MOVE_BACKWARD_CMD: {
length = 1;
motor_move_backward(10);
} break;
case TURN_RIGHT_CMD: {
length = 1;
motor_turn_right(10);
} break;
case TURN_LEFT_CMD: {
length = 1;
motor_turn_left(10);
} break;
case STOP_CMD: {
length = 1;
motor_stop();
} break;
case DISTANCE_REQ: {
INTCONbits.RBIE = 0; // Temporary
buffer[1] = encoder_to_distance();
length = 2;
} break;
default: {
buffer[0] = 0x0;
length = 1;
} break;
}
if(length > 0) {
start_i2c_slave_reply(length,buffer);
}
#endif
} break;
case MSGT_I2C_DATA: {
} break;
case MSGT_I2C_MASTER_SEND_COMPLETE: {
#ifdef MASTERPIC
/* char command = msgbuffer[0];
switch(command) {
case MOVE_FORWARD_CMD:
case MOVE_BACKWARD_CMD:
case TURN_RIGHT_CMD:
case TURN_LEFT_CMD:
case STOP_CMD: {
i2c_master_recv(1,MOTORPICADDR);
} break;
case DISTANCE_REQ: {
i2c_master_recv(2,MOTORPICADDR);
} break;
case SHORT_IR1_REQ:
case SHORT_IR2_REQ:
case MID_IR1_REQ:
case MID_IR2_REQ:
case COMPASS_REQ:
case ULTRASONIC_REQ: {
i2c_master_recv(2,SENSORPICADDR);
} break;
default: {
} break;
}*/
#endif
#ifdef SENSORPIC
// Start receiving data from sensor
if(t0thread_data.currentState == readCompassState) {
i2c2_master_recv(6,COMPASSADDR);
}
else if(t0thread_data.currentState == readUltrasonicState) {
i2c2_master_recv(2,ULTRASONICADDR);
}
#endif
} break;
case MSGT_I2C_MASTER_SEND_FAILED: {
} break;
case MSGT_I2C_MASTER_RECV_COMPLETE: {
#ifdef MASTERPIC
char buffer[2];
char length = 0;
char command = msgbuffer[0];
switch(command) {
case MOVE_FORWARD_CMD:
case MOVE_BACKWARD_CMD:
case TURN_RIGHT_CMD:
case TURN_LEFT_CMD:
case STOP_CMD: {
buffer[0] = command;
length = 1;
} break;
case DISTANCE_REQ: {
buffer[0] = command;
buffer[1] = msgbuffer[1];
length = 2;
} break;
case SHORT_IR1_REQ:
case SHORT_IR2_REQ:
case MID_IR1_REQ:
case MID_IR2_REQ:
case COMPASS_REQ:
case ULTRASONIC_REQ: {
buffer[0] = command;
buffer[1] = msgbuffer[1];
length = 2;
} break;
default: {
length = 0;
} break;
}
if(length > 0) {
start_uart_send(length,buffer);
}
#endif
#ifdef SENSORPIC
// Received data from sensor
if(t0thread_data.currentState == readCompassState) {
sensors.compassData[0] = msgbuffer[0];
sensors.compassData[1] = msgbuffer[1];
sensors.compassData[2] = msgbuffer[2];
sensors.compassData[3] = msgbuffer[3];
sensors.compassData[4] = msgbuffer[4];
sensors.compassData[5] = msgbuffer[5];
}
else if(t0thread_data.currentState == readUltrasonicState) {
}
#endif
} break;
case MSGT_I2C_MASTER_RECV_FAILED: {
} break;
case MSGT_I2C_DBG: {
} break;
default: {
} break;
}
}
// Error check
if (length != MSGQUEUE_EMPTY) {
// Handle Error
}
// Check the low priority queue
if ((length = ToMainLow_recvmsg(MSGLEN, &msgtype, (void *) msgbuffer)) >= 0) {
switch (msgtype) {
case MSGT_TIMER0: {
timer0_lthread(&t0thread_data, msgtype, length, msgbuffer);
} break;
case MSGT_TIMER1:
timer1_lthread(&t1thread_data, msgtype, length, msgbuffer);
break;
case ADCSC1_ADCH:
ADC_lthread(&ADCthread_data, msgtype, length, msgbuffer,&t0thread_data);
break;
case MSGT_OVERRUN:
case MSGT_UART_DATA: {
uart_lthread(&uthread_data, msgtype, length, msgbuffer);
} break;
case MSGT_UART_SEND_COMPLETE: {
} break;
default:
break;
}
}
// Error check
else if (length != MSGQUEUE_EMPTY) {
// Handle error
}
}
}
void setupTerminal() {
OpenUSART(USART_TX_INT_OFF & USART_RX_INT_OFF & USART_ASYNCH_MODE &
USART_EIGHT_BIT & USART_CONT_RX, 129);
}
void main()
{
int test;
unsigned char del;
stCanFrame sample;
unsigned char mpptDevice = 0x01;
unsigned char deviceMC = 0x02;
unsigned char mpptCanConfig[4];
unsigned char mcCanConfig[4];
unsigned short filterID = mcBaseAddress | motorTempMes ;
OpenUSART( USART_TX_INT_OFF &
USART_RX_INT_OFF &
USART_ASYNCH_MODE &
USART_EIGHT_BIT &
USART_CONT_RX &
USART_BRGH_HIGH, 71);
printf("\n\r Serial Open \n");
OpenSPI( SPI_FOSC_16, //Master clock 16mhz
MODE_00,
SMPEND); //Output data a end of buff
selectNoDevice();
setmppt(mpptCanConfig);
test = mcp_init(mpptDevice, mpptCanConfig);
while ( test != 0)
{
printf("\rMPPT. Failer to init MCP 2515, reseting \n");
test = mcp_init(mpptDevice, mpptCanConfig);
}
mcp2515_normal(mpptDevice);
printf("\rMPPT. Pass init MCP 2515\n");
delay();
setmc(mcCanConfig);
test = mcp_init(deviceMC,mcCanConfig);
while(test !=0)
{
printf("\r MOTOR CONTROLLER. Failer to init MCP 2515, reseting \n");
test = mcp_init(deviceMC,mcCanConfig);
}
mcp2515_normal(deviceMC);
printf("\rMOTOR CONTROLLER. Pass init MCP 2515\n");
delay();
if (bit_is_set(0b10111111,6))
printf("\r Error -simple bit shift fails \n");
else
printf("\r simple bit operations work right \n");
//Ending set up
//starting main loop
//------------------
getMessagesThatLookLike(&(filterID), deviceMC);
while(1)
{
mpptData myMpptData[4];
mcData myMCData;
stCanFrame sample;
stCanFrame result;
unsigned char counter = 0, temp;
int pollCount = 10;
//MPPT
//---------------------
//build the message prompts the MPPT data
//The mppt address we want are.
// 0x711 , 0x713, 0x715, 0x717
sample.id = MPPTRequestID;
sample.length = 0;
sample.rtr =0;
while(counter < 4)
{
sample.id = MPPTRequestID + 1 + (counter * 2);
if(g_debug) printf("\r the id is %x\n",MPPTRequestID + 1 + (counter * 2));
mcp2515_send_message(&sample, 0x02,mpptDevice);
Delay10TCYx(0x30);
result.id = 0;
mcp2515_get_message(&result ,mpptDevice);
while(!(result.id == MPPTAnswerID + 1 + (counter * 2)) && pollCount ) //while we do not have the matching id, and the time has not expired keep waiting for the message
{
mcp2515_get_message(&result, mpptDevice);
Delay10TCYx(0x30);
pollCount--;
}
if(pollCount)
{
parsMppt((result.data),myMpptData[counter]);
if(g_messageDebug)
{
printf("\rMessage from the MPPT \n");
printCanMessage(result);
}
}
else
{
if(g_debug) printf("\r mppt TimeOUT \n");
}
counter++;
}
pollCount = 10;
//MOTOR Controller
//-------------------------------
Delay10TCYx(0x30);
result.id = 0;
mcp2515_get_message(&result ,deviceMC);
while( !(result.id == 0x040b) && pollCount)
{
mcp2515_get_message(&result ,deviceMC) ;
}
if (result.id = 0x040b)
{
int cool = convertToInt(result.data + 4 , 100 );
printf("\rThe temp is %i\n",cool);
printCanMessage(result);
parsMC((result.data), result.id, myMCData);
}
else
{
printf("\r MC TimeOUT \n");
}
}
}
void ConfigUSART(unsigned char config_1, unsigned char config_2)
{
OpenUSART(config_1, config_2);
}
// This program
// 1) Polls A/D conversions from 2 Proximity
void main (void){
unsigned int result;
uart_comm uc;
uart_thread_struct uthread_data; // info for uart_lthread
timer1_thread_struct t1thread_data; // info for timer1_lthread
timer0_thread_struct t0thread_data; // info for timer0_lthread
// set to run really, really fast...
OSCCON = 0x6C; // 4 MHz
OSCTUNEbits.PLLEN = 1; // 4x the clock speed in the previous line
// initialize my uart recv handling code
init_uart_recv(&uc);
// init the timer1 lthread
init_timer1_lthread(&t1thread_data);
TRISAbits.TRISA0 = 1; //AN0 equals input
TRISCbits.TRISC7 = 0;//1; //Rx equals input
TRISCbits.TRISC6 = 0; //TX equals output
TRISCbits.TRISC3 = 0; //cl equals output
TRISCbits.TRISC4 = 0; //DA equals output
//initialize all output pins to 0
LATCbits.LATC6 = 0;
LATCbits.LATC3 = 0;
LATCbits.LATC4 = 0;
//Set PortB(leds) for output
TRISB = 0;
PORTB = 0;
// set direction for PORTB to output
LATB = 0;
// initialize ADC
OpenADC( /*config*/ ADC_FOSC_RC & ADC_RIGHT_JUST & ADC_20_TAD,
/*config2*/ ADC_CH1 & ADC_REF_VDD_VSS & ADC_INT_OFF,
/*portconfig*/ ADC_4ANA );
// set up PORTA for input
/*
PORTA = 0x0; // clear the port
LATA = 0x0; // clear the output latch
//ADCON1 = 0x0F; // turn off the A2D function on these pins
// Only for 40-pin version of this chip CMCON = 0x07; // turn the comparator off
//TRISA = 0x0F; // set RA3-RA0 to inputs
*/
// initialize Timers
OpenTimer0( TIMER_INT_ON & T0_8BIT & T0_SOURCE_INT & T0_PS_1_128);
OpenTimer1( TIMER_INT_ON & T1_PS_1_1 & T1_16BIT_RW & T1_SOURCE_INT & T1_OSC1EN_OFF & T1_SYNC_EXT_OFF);
// Peripheral interrupts can have their priority set to high or low
// enable high-priority interrupts and low-priority interrupts
enable_interrupts();
// Decide on the priority of the enabled peripheral interrupts
// 0 is low, 1 is high
// Timer1 interrupt
IPR1bits.TMR1IP = 0;
// USART RX interrupt
IPR1bits.RCIP = 0;
// I2C interrupt
IPR1bits.SSPIP = 1;
// configure the hardware USART device
OpenUSART( USART_TX_INT_OFF & USART_RX_INT_ON & USART_ASYNCH_MODE & USART_EIGHT_BIT &
USART_CONT_RX & USART_BRGH_LOW, 0x19);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//My Stuff /////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// result = factoryReset();
// initialize();
// result = joinNetwork();
// result = openConnection();
// sendGoalBlack();
while(1)
{
LATBbits.LATB0 = 1;
Delay10KTCYx(0);
Delay10KTCYx(0);
LATBbits.LATB0 = 0;
Delay10KTCYx(0);
}
CloseADC();
}
void main()
{
int i;
TRISAbits.TRISA0 = 1; //Direciona o pino 0 da porta A como entrada
TRISAbits.TRISA3 = 1; //Direciona o pino 3 da porta A como entrada
TRISCbits.TRISC2 = 0; //Direciona o pino 2 da porta C como saída (Aquecimento)
TRISAbits.TRISA4 = 1; //Direciona o pino 4 da porta A como entrada (B2)
OpenUSART(USART_TX_INT_OFF //desabilita interrupção de transmissão
& USART_RX_INT_OFF //desabilita interrupção de recepção
& USART_ASYNCH_MODE //modo assíncrono
& USART_EIGHT_BIT //transmissão e recepção em 8 bits
& USART_BRGH_HIGH, //Baud Rate em alta velocidade
25); //SPBRG p/ 19200 bps
ADCON2 = 0b10100001; /*ADFM1 = 1 -> Resultado da conversão AD
... justificado à direita
-
****Velocidade de aquisição em 8TAD
ACQT2 = 1
ACQT1 = 0
ACQT0 = 0
****Fonte de clock em Fosc/8
ADCS2 = 0
ADCS1 = 0
ADCS0 = 1*/
ADCON1 = 0b00001011; /* -
-
VCFG1 = 0 -> Vref- = terra
VCFG0 = 1 -> Vref+ = VDD
*****Seleciona os canais AN0 e AN3 como analógicos
PCFG3 = 1
PCFG2 = 1
PCFG1 = 0
PCFG0 = 1*/
msg_inicial();
while(1)
{
while(!DataRdyUSART()); //Aguarda a chegada de um caractere no buffer de recepção
rec[i] = getcUSART(); //recebe o caractere e armazena no índice n_dado da
//matriz n_dado
putcUSART(rec[i]);
Delay10KTCYx(1); //Gera um delay de 5ms
i++;
if(rec[i-1]==0x0D)
{
trata_serial();
i=0;
msg_inicial();
}
}
}
