void rs232_read_line(char buffer[64])
{
unsigned int index = 0;
char c;
// Initialiser le tampon
for (index = 0; index < 64;index++)
buffer[index] = '\0';
index = 0;
// Lire le texte
do {
// Lire un caractère
while (!DataRdyUSART());
c = ReadUSART();
buffer[index] = c;
index++;
// Afficher les caractères entrés
while (BusyUSART());
WriteUSART(c);
} while (c != '\r' && index < 64);
// Eviter de réécrire par dessus le texte saisi
while (BusyUSART());
WriteUSART('\n');
// Remove '\r'
buffer[index-1] = '\0';
}
void SEND_TX_STOP()
{
WriteUSART(EndTransmission);
while (BusyUSART());
WriteUSART(CR);
while (BusyUSART());
}
void PrintInt(unsigned int c) {
WriteUSART(((c / 10000) % 10) + '0');
while(BusyUSART());
WriteUSART(((c / 1000) % 10) + '0');
while(BusyUSART());
WriteUSART(((c / 100) % 10) + '0');
while(BusyUSART());
WriteUSART(((c / 10) % 10) + '0');
while(BusyUSART());
WriteUSART((c % 10) + '0');
while(BusyUSART());
}
void timer0_int_handler() {
// Encoder count for motor 0.
timer0Counter++;
// Reset the timer
WriteTimer0(0xCF);
DEBUG_ON(TMR0_DBG);
DEBUG_OFF(TMR0_DBG);
if (ticks_flag) {
// Reverse counter to prevent it from going a set distance.
ticks0Counter++;
// Going thru right hand turn
if (ticks0Counter >= maxTickZero && postRight == 1) {
postRight = 2;
WriteUSART(0x00);
// Turn right 90
motorBuffer[0] = 0x01;
motorBuffer[1] = 0x03;
motorBuffer[2] = 0x04;
motorBuffer[3] = 0x01;
motorBuffer[4] = 0x0C;
motorBuffer[5] = 0x09;
ToMainHigh_sendmsg(MOTORLEN, MSGT_I2C_DATA, (void *) motorBuffer);
} else if (ticks0Counter >= maxTickZero && postRight == 2) {
// Move forward after right turn
postRight = 0;
motorBuffer[0] = 0x01;
motorBuffer[1] = 0x03;
motorBuffer[2] = 0x01;
motorBuffer[3] = 0x01;
motorBuffer[4] = 0x00;
motorBuffer[5] = 0x00;
ToMainHigh_sendmsg(MOTORLEN, MSGT_I2C_DATA, (void *) motorBuffer);
} else if (ticks0Counter >= maxTickZero && postAlignFlag) {
postAlignFlag = 0;
motorBuffer[0] = 0x01;
motorBuffer[1] = 0x03;
motorBuffer[2] = 0x01;
motorBuffer[3] = 0x01;
motorBuffer[4] = 0x00;
motorBuffer[5] = 0x00;
ToMainHigh_sendmsg(MOTORLEN, MSGT_I2C_DATA, (void *) motorBuffer);
} else if (ticks0Counter >= maxTickZero) {
//Stops wheels after set number of ticks
WriteUSART(0x00);
}
}
}
void usartLoopback() {
unsigned char data;
while(!DataRdyUSART());
data = ReadUSART();
while(BusyUSART());
WriteUSART(data);
}
// Master Mode
void master(void){
while(1){
WriteUSART(27);
putrsUSART (ClrScr);
putrsUSART (Menu1);
while(!DataRdyUSART()); //wait for data
key = ReadUSART(); //read data
putcUSART(key);
switch (key) {
case '1':
{
WriteUSART(27);
putrsUSART (ClrScr);
putrsUSART (Menu1_1);
while(!DataRdyUSART()); //wait for data
key = ReadUSART(); //read data
break;
}
case '2':
{
trackmode();
break;
}
case '3':
{
WriteUSART(27);
putrsUSART (ClrScr);
putrsUSART (Menu1_3);
manmode();
break;
}
case '4':
{
blink();
}
default:
{
putrsUSART (BadKey);
break;
}
}
}
}
//Slave Mode
void slave(void){
while(1){
WriteUSART(27);
putrsUSART (ClrScr);
putrsUSART (Menu1_4);
manmode();
}
return;
}
void HeartBeat(void)
{
ACT_LED_01 = 0;
Delay1KTCYx(100);
ACT_LED_01 = 1;
Delay1KTCYx(100);
WriteUSART('#'); // :
while (BusyUSART());
}
static void uartRxHandler (void)
{
unsigned char c;
/* Get the character received from the USART */
c = ReadUSART();
/* Put the character received from the USART */
WriteUSART(c);
/* Clear the interrupt flag */
PIR1bits.RCIF = 0;
}
void imprimir() {
while(BusyUSART());
WriteUSART(35);
while(BusyUSART());
WriteUSART(88);
while(BusyUSART());
itoa(buf, acc_x, 10);
putsUSART(&buf);
//putintUSART(&acc_x);
while(BusyUSART());
WriteUSART(43);
while(BusyUSART());
WriteUSART(89);
while(BusyUSART());
//putintUSART(&acc_y);
itoa(buf, acc_y, 10);
putsUSART(&buf);
while(BusyUSART());
WriteUSART(43);
while(BusyUSART());
WriteUSART(90);
while(BusyUSART());
//putintUSART(&acc_z);
itoa(buf, acc_z, 10);
putsUSART(&buf);
while(BusyUSART());
WriteUSART(43);
while(BusyUSART());
WriteUSART(33);
//itoa(buf, temperature, 10);
// putsUSART(&buf);
// putsUSART(&mid);
//putsUSART(&start);
//itoa(buf, acc_x, 10);
//putintUSART(&acc_x);
//putsUSART(&mid);
//itoa(buf, acc_y, 10);
//putsUSART(&buf);
//putsUSART(&mid);
//itoa(buf, acc_z, 10);
//putsUSART(&buf);
//putsUSART(&mid);
//putsUSART(&end);
//putsUSART(&enter);
}
void SEND_TX_RESPONSE()
{
SEND_TX_START();
//WriteUSART(0x27); // '
//while (BusyUSART());
//WriteUSART('@'); // UNIQUE RESPONSE SYMBOL
WriteUSART(COMMAND_DATA[1]);
WriteUSART(COMMAND_DATA[2]);
//while (BusyUSART());
//WriteUSART(0x27); // '
while (BusyUSART());
WriteUSART(0x3A); // :
//while (BusyUSART());
//WriteUSART(0x27); // '
while (BusyUSART());
SEND_TX_DATA();
while (BusyUSART());
//WriteUSART(0x27); // '
//while (BusyUSART());
SEND_TX_STOP();
}
void Read_string(unsigned char *buffer, unsigned char len) /* Reads a string data from UART of having specific length*/
{
char i;
unsigned char data;
Write(0x0D);
Write('\n');
for(i=0;i<len;i++)
{
while(!DataRdyUSART()); /* Wait for data to be received */
data = getcUSART(); /* Get a character from the USART */
*buffer = data; /* save data in a string */
WriteUSART(data);
while(BusyUSART());
buffer++; /* Increment the string pointer */
}
}
void firstSendUSART()
{
uint8_t ggg = 0x02;
TxBuffer[0x00] = 1;
TxBuffer[0x01] = 0x10;
while(ggg < 0x10)
{
ggg++;
TxBuffer[ggg] = ggg;
}
TxBuffer[0x11] = 0xFF;
WriteUSART(0x12);
ggg = 0x00;
while(ggg < 0x20)
{
TxBuffer[ggg] = 0;
ggg++;
}
}
void uart_send_int_handler() {
//LATBbits.LATB7 = 0;
// Make sure we still have data to send
if(uc_ptr->sendSize > 0) {
#ifdef __USE18F46J50
Write1USART(uc_ptr->sendBuffer[uc_ptr->sendCurrent]);
#else
WriteUSART(uc_ptr->sendBuffer[uc_ptr->sendCurrent]);
#endif
// Flag interrupt for next byte
PIE1bits.TXIE = 1;
// Increment/decrement size and index
uc_ptr->sendCurrent++;
uc_ptr->sendSize--;
}
}
void Read_str_(unsigned char *buffer) /* Reads a string data from UART of having specific length*/
{
char i;
unsigned char data;
for(i=0;data!=0x0D;i++)
{
while(!DataRdyUSART()); /* Wait for data to be received */
data = ReadUSART();
if(data!=0x0D) /* Get a character from the USART */
*buffer = data; /* save data in a string */
WriteUSART(data);
while(BusyUSART());
buffer++; /* Increment the string pointer */
}
while(i!=16)
{
*buffer = ' ';
buffer++;
i++;
}
}
void main(void) {
char msg[1];
int value;
initSquareWear();
latC7 = 0;
openUSART();
putrsUSART("Type a single digit number:\r\n");
while(1) {
getsUSART(msg, 1);
if(msg[0]>='0' && msg[0]<='9') {
value = msg[0]-'0';
if (value<10) {
putrsUSART("On for ");
WriteUSART(msg[0]);
putrsUSART(" seconds.\r\n");
latC7 = 1;
delaySeconds(value);
latC7 = 0;
}
}
}
}
void uart_recv_int_handler() {
#ifdef __USE18F26J50
if (DataRdy1USART()) {
uc_ptr->buffer[uc_ptr->buflen] = Read1USART();
#else
#ifdef __USE18F46J50
if (DataRdy1USART()) {
uc_ptr->buffer[uc_ptr->buflen] = Read1USART();
#else
if (DataRdyUSART()) {
buffer_temp[buf_len] = ReadUSART();
#endif
#endif
uc_ptr->buflen++;
buf_len++;
parseUART();
// check if a message should be sent
}
#ifdef __USE18F26J50
if (USART1_Status.OVERRUN_ERROR == 1) {
#else
#ifdef __USE18F46J50
if (USART1_Status.OVERRUN_ERROR == 1) {
#else
if (USART_Status.OVERRUN_ERROR == 1) {
#endif
#endif
// we've overrun the USART and must reset
// send an error message for this
RCSTAbits.CREN = 0;
RCSTAbits.CREN = 1;
ToMainHigh_sendmsg(0, MSGT_OVERRUN, (void *) 0);
}
}
void init_uart_recv(uart_comm *uc) {
uc_ptr = uc;
uc_ptr->buflen = 0;
buf_len = 0;
command_length = 0;
command_count = 0;
State = GET_MSGID;
}
void parseUART()
{
unsigned char x = uc_ptr->buflen;
// uart_write(1, &x);
switch(State)
{
case(GET_MSGID):
{
command_length = buffer_temp[buf_len -1] & 0xF;
command_length = command_length;
if(command_length != 0)
{
State = GET_COMMAND;
}
else
{
State = CHECKSUM;
}
break;
}
case(GET_COMMAND):
{
if(command_count+1 < command_length)
{
command_count++;
}
else
{
State = CHECKSUM;
}
break;
}
case(CHECKSUM):
{
ToMainLow_sendmsg(buf_len ,MSGT_PARSE, &buffer_temp[0]);
uc_ptr->buflen = 0;
buf_len = 0;
State = GET_MSGID;
command_count = 0;
command_length = 0;
break;
}
}
}
void uart_write(unsigned char length, unsigned char *msg){
unsigned char i = 0;
for(i = 0; i < length; i++){
#ifdef __USE18F26J50
while(Busy1USART());
Write1USART(msg[i]);
#else
#ifdef __USE18F46J50
while(Busy1USART());
Write1USART(msg[i]);
#else
while(BusyUSART());
WriteUSART(msg[i]);
#endif
#endif
}
}
void SEND_TX_START(void)
{
WriteUSART(StartTransmission);
while (BusyUSART());
}
void Write(char data)
{
WriteUSART(data); /* Write a byte through USART module */
while(BusyUSART()); /* Wait until the write complete */
}
/******************************************************************************************
* COMMAND FUNCTIONS *
******************************************************************************************/
void ProcessCommand(void)
{
if (HEART_B == '1')
ACT_LED_01 = 0; //Turn it ON (inverted open drain)
if (COMMAND_DATA[0] == 'R')// READ COMMAND --------------------------------------------
{
if (COMMAND_DATA[1] == '*')// READ ALL REGISTERS
{
Read_Analog_Inputs(); // READ ANALOG PERIPHERIALS****
Read_Digital_Inputs(); // READ DIGITAL INPUT PERIPHERIALS**
Read_Digital_Outputs(); // READ DIGITAL OUTPUT PERIPHERIALS**
SEND_TX_START(); // START TRANSMISSION
SEND_ANALOG_DATA();
WriteUSART(0x2C);
while (BusyUSART()); // Send a ,
SEND_DIGITAL_INPUT_DATA();
WriteUSART(0x2C);
while (BusyUSART()); // Send a ,
SEND_DIGITAL_OUTPUT_DATA();
SEND_TX_STOP(); // End all transmissions
}
if (COMMAND_DATA[1] == 'C')// READ REGISTER LIST
{
if (COMMAND_DATA[2] == '0')// READ INFO REGISTER 0 MODEL
{
for (unsigned char n=0; n <= 7; n++ ) //Reset Buffer
TRANSMITT_DATA[n] = EEPROM_READ(n); // COPY BUFFER TO COMMAND DATA for further processing
SEND_TX_RESPONSE();
}
else if (COMMAND_DATA[2] == '1')// READ INFO REGISTER 1 FIRMWARE
{
unsigned char d=0x08;
for (unsigned char n=0; n <= 7; n++ ) //Reset Buffer
TRANSMITT_DATA[n] = EEPROM_READ(d),d++; // COPY BUFFER TO COMMAND DATA for further processing
SEND_TX_RESPONSE();
}
else if (COMMAND_DATA[2] == '2')// READ INFO REGISTER 2 ADDRESS
{
TRANSMITT_DATA[0] = EEPROM_READ(0x10); // AdDDRES 1
TRANSMITT_DATA[1] = EEPROM_READ(0x11); // AdDDRES 1
SEND_TX_RESPONSE();
}
else if (COMMAND_DATA[2] == '3')// READ INFO REGISTER 3 DEVICE SERIAL NUMBER
{
TRANSMITT_DATA[0] = SERIAL[0];
TRANSMITT_DATA[1] = SERIAL[1];
TRANSMITT_DATA[2] = SERIAL[2];
TRANSMITT_DATA[3] = SERIAL[3];
TRANSMITT_DATA[4] = SERIAL[4];
TRANSMITT_DATA[5] = SERIAL[5];
TRANSMITT_DATA[6] = SERIAL[6];
TRANSMITT_DATA[7] = SERIAL[7];
SEND_TX_RESPONSE(); // Send list character
}
else if (COMMAND_DATA[2] == '4')// READ INFO REGISTER 4 LIST DEVICE
{
TRANSMITT_DATA[0] = '@', SEND_TX_RESPONSE(); // Send list character
}
}
else if (COMMAND_DATA[1] == 'A')// READ ANALOG INPUTS ADC
{
Read_Analog_Inputs(); // READ ANALOG PERIPHERIALS****
if (COMMAND_DATA[2] == '*') // READ ALL ANALOG DATA AND SEND IT
SEND_TX_START() , SEND_ANALOG_DATA(), SEND_TX_STOP();
else if (COMMAND_DATA[2] == '0')// READ ANALOG REGISTER 1
itoa( TRANSMITT_DATA, ADCValue[0],10), SEND_TX_RESPONSE(); //convert to string VAL 1 TO 1024
else if (COMMAND_DATA[2] == '1')// READ ANALOG REGISTER 2
itoa( TRANSMITT_DATA, ADCValue[1],10), SEND_TX_RESPONSE(); //convert to string VAL 1 TO 1024
else if (COMMAND_DATA[2] == '2')// READ ANALOG REGISTER 3
itoa( TRANSMITT_DATA, ADCValue[2],10), SEND_TX_RESPONSE(); //convert to string VAL 1 TO 1024
else if (COMMAND_DATA[2] == '3')// READ ANALOG REGISTER 4
itoa( TRANSMITT_DATA, ADCValue[3],10), SEND_TX_RESPONSE(); //convert to string VAL 1 TO 1024
else if (COMMAND_DATA[2] == '4')// READ ANALOG REGISTER 5
itoa( TRANSMITT_DATA, ADCValue[4],10), SEND_TX_RESPONSE(); //convert to string VAL 1 TO 1024
}
else if (COMMAND_DATA[1] == 'I')// READ DIGITAL INPUTS
{
Read_Digital_Inputs(); // READ DIGITAL PERIPHERIALS**
if (COMMAND_DATA[2] == '*') // READ ALL DIGITAL INPUTS AND SEND IT
SEND_TX_START() , SEND_DIGITAL_INPUT_DATA(), SEND_TX_STOP();
else if (COMMAND_DATA[2] == '0')// READ DIGITAL INPUT REGISTER 1
TRANSMITT_DATA[0] = INPUTValue[0], SEND_TX_RESPONSE();
else if (COMMAND_DATA[2] == '1')// READ DIGITAL INPUT REGISTER 2
TRANSMITT_DATA[0] = INPUTValue[1], SEND_TX_RESPONSE();
else if (COMMAND_DATA[2] == '2')// READ DIGITAL INPUT REGISTER 3
TRANSMITT_DATA[0] = INPUTValue[2], SEND_TX_RESPONSE();
}
else if (COMMAND_DATA[1] == 'O')// READ DIGITAL OUTPUTS
{
Read_Digital_Outputs(); // READ DIGITAL PERIPHERIALS**
if (COMMAND_DATA[2] == '*') // READ ALL DIGITAL INPUTS AND SEND IT
SEND_TX_START() , SEND_DIGITAL_OUTPUT_DATA(), SEND_TX_STOP();
else if (COMMAND_DATA[2] == '0')// READ DIGITAL OUTPUTS REGISTER 1
{
if (OUT_00)
TRANSMITT_DATA[0] = '1';
else
TRANSMITT_DATA[0] = '0';
SEND_TX_RESPONSE();
}
else if (COMMAND_DATA[2] == '1')// READ DIGITAL OUTPUTS REGISTER 2
{
if (OUT_01)
TRANSMITT_DATA[0] = '1';
else
TRANSMITT_DATA[0] = '0';
SEND_TX_RESPONSE();
}
}
}
else if (COMMAND_DATA[0] == 'W')// WRITE COMMAND ----------------------------------------
{
if (COMMAND_DATA[1] == 'O')// WRITE DIGITAL OUTPUT
{
if (COMMAND_DATA[2] == '0')// WRITE OUTPUT REGISTER 1
{
if (COMMAND_DATA[3] == '1')
OUT_00 = 1;
else
OUT_00 = 0;
TRANSMITT_DATA[0] = '1', SEND_TX_RESPONSE();
}
else if (COMMAND_DATA[2] == '1')// WRITE OUTPUT REGISTER 2
{
if (COMMAND_DATA[3] == '1')
OUT_01 = 1;
else
OUT_01 = 0;
TRANSMITT_DATA[0] = '1', SEND_TX_RESPONSE();
}
}
if (COMMAND_DATA[1] == 'C')// WRITE CONFIGURATION
{
if (COMMAND_DATA[2] == '2')// WRITE CONFIGURATION REGISTER 2
{
EEPROM_WRITE(0x10, COMMAND_DATA[3]);
Delay10TCYx(30);
EEPROM_WRITE(0x11, COMMAND_DATA[4]);
Delay10TCYx(30);
Add_HI = COMMAND_DATA[3];
Add_LO = COMMAND_DATA[4];
TRANSMITT_DATA[0] = '1', SEND_TX_RESPONSE();
}
}
}
ACT_LED_01 = 1; //Turn it OFF (inverted open drain)
return;
}
void interrupt Interrupcao(void){
char buffer[4];
/* a string buffer ira guardar um numero decimal (0 a 32) traduzido pela
* funcao itoa, onde ira transformar o numero inteiro em string com apontador
* o tamanho poderia ser 3, mas o inteiro vai ate 3 posicoes + null
*
* the buffer string variable will hold a decimal number (0 to 32) that was
* converted by the itoa function, changing a integer number into a string
* pointer
* its size could be only 3, but the interger goes up to 3 positions + null end
*/
// LED_VERMELHO = ~LED_VERMELHO;
// muda o status do LED_VERMELHO quando a MCU entrar em interrupcao
// changes the LED_VERMELHO when the MCU interrupts
// BUZZ=1; Delay100TCYx(10); BUZZ=0;
// toca o buzzer para cada interrupcao
// plays the buzzer for each interrupt
if (RCIF) // se existe interrupcao aguardando...
// teoricamente este RCIF nao precisaria de verificacao
// pois se a rotina de Interrupcao ja foi chamada, entao
// nem seria necessario verifica-la
// mas os LED1 e LED_VERMELHO servem justamente para comprovar
// que o RCIF sempre ira existir, quando mudam juntos (leds)
// Theoretically this RCIF "if" check should never be necessary
// but just to confirm the RCIF, the two leds (LED1 and
// LED_VERMELHO) will always change together.
{
RCIE = 0; // desabilita interrupts de RX para tratar a entrada
// disables RX interrupts to treat input
LED1 = ~LED1;
// muda o status do primeiro LED
// inverts the LED1 status
chRX = ReadUSART();
// le caractere da Serial / read a character from Serial
if ( chRX>31 && chRX<127 && !BOTAO)
// filtra apenas os caracteres texto comuns
// just filter the common readable text characters
{
// Se o Echo Serial esta ativo, entao imprima o caractere na Serial
// If Serial Echo is on, then send the character to Serial Port
if (SerialEcho)
{
while (BusyUSART()); // espera nao ocupado / waits non busy
WriteUSART(chRX); // envia caractere na Porta Serial
// sends the character in Serial Port
}
// Se o LcdDisplay esta ativo, entao imprima o caractere
// If Lcd Display is enabled, print the character in LCD
if (LcdDisplay)
{
while (BusyXLCD());
WriteDataXLCD(chRX);
contadorDisplay++; // contador de caracteres para tabular
// LCD character tabulation count
if (contadorDisplay==16) // se chegar ao final da primeira linha
// if reaches the end of first line
{
SetDDRamAddr(0x40); // comando para pular para segunda linha
// command for going to second line
if (SerialEcho)
{
while (BusyUSART());
putrsUSART("\r\n"); // imprime RETURN e NEWLINE (inicio)
// prints Carriage RETURN and Newline
}
}
if (contadorDisplay==32) // se chegar ao final da segunda linha
// if reaches the end of second line
{
SetDDRamAddr(0x00); // pula novamente para primeira linha
// go again to first line
contadorDisplay=0; // ja na primeira linha, limpa contador
// in first line, clear the char counter
if (SerialEcho)
{
while (BusyUSART());
putrsUSART("\r\n"); // imprime RETURN e NEWLINE (inicio)
// prints Carriage RETURN and Newline
}
}
}
}
else // filtra todos demais Controls e Caracteres Especiais
// this is the state of non-text characters being filtered
if (BOTAO) // se o BOTAO de debug estiver pressionado, nao filtra controle
//if pushBOTTON is pressed, do not filter control characters
{
while (BusyUSART());
WriteUSART(chRX);
}
else
switch (chRX)
{
case 0x05 : // Caractere ^E
SerialEcho=!SerialEcho;
while(BusyUSART());
putrsUSART("\r\n[ECHO ");
if (SerialEcho) putrsUSART("ON]"); else putrsUSART("OFF]");
break;
/*
* Control-E:
* Rotina para ligar e desligar o ECHO na porta serial
* Routine to turn on and off the ECHO in serial port
*/
case 0x10 : // Caractere ^P
LcdDisplay=!LcdDisplay;
while(BusyUSART());
putrsUSART("\r\n[LCD ");
if (LcdDisplay) putrsUSART("ON]"); else putrsUSART("OFF]");
break;
/*
* Contro-P:
* Rotina para ligar e desligar a amostragem de Caractere no LCD
* Routine to turn on and off the display of characters in LCD
*/
case 0x0C : // Caractere ^L (FormFeed)
putrsUSART("\r\n[LCD CLS]");
while(BusyXLCD());
WriteCmdXLCD(0x01); // Comando para limpar o LCD
contadorDisplay=0;
break;
/*
* Control-L: (LimpaTela / FormFeed)
* Rotina para Limpar a Tela
* Routine to CLear Screen (CLS)
*/
case 0x13 : // Caractere ^S
putrsUSART("\r\n[Status Lcd:");
if (LcdDisplay) putrsUSART("On"); else putrsUSART("Off");
putrsUSART(" Echo:");
if (SerialEcho) putrsUSART("On"); else putrsUSART("Off");
putrsUSART(" charLCD:");
itoa ( buffer, contadorDisplay, 10);
// itoa necessita da biblioteca <stdlib.h>
// itoa needs the include stdlib.h
putrsUSART( buffer );
putrsUSART("]\r\n");
/*
* Control-S:
* Mostra o Status do Echo, do LCD, e da quantidade de caracteres
* no LCD
* Shows the Status of Echo, LCD and characteres number in LCD
*/
break;
default:
;
}
// two Peripheral Interrupt Request (Flag) registers (PIR1 and PIR2)
// RCIF: EUSART Receive Interrupt Flag bit
//PIR1bits.RCIF = 0; // PIR1 no registro RCIF
RCIE = 1; // Re-Habilita a Interrupcao de Recepcao
// Re-Enable RX Interrupts
RCIF = 0; // PIR1 no registro RCIF
// limpa o registrador de interrupcao, e sai da interrupcao
// clear the interrupt register, and quits it
}
}
void PrintStatus(unsigned int *iServos, unsigned int *iOutput,
unsigned char *cIds, unsigned char cId, unsigned int iInput) {
static int c = 4;
unsigned char sMod[] = "Mod: ";
unsigned char sId[] = " Id: ";
unsigned char sInput[] = ", Input: ";
unsigned char sCurrent[] = " Current: ";
unsigned char sNew[] = " New: ";
unsigned char sSorted[] = " Sorted: ";
unsigned char sSeparator[] = ", ";
unsigned char sNewline[] = "\r\n";
//Overall Values
putsUSART((char *) sMod);
WriteUSART((c % 10) + '0'); //This just shows activity
putsUSART((char *) sId);
PrintInt(cId);
putsUSART((char *) sInput);
PrintInt(iInput);
putsUSART((char *) sNewline);
//Current values
putsUSART((char *) sCurrent);
for(int i = 0; i < MAX_SERVOS; i++) {
if(i) {
putsUSART((char *) sSeparator);
}
PrintInt(iServos[i]);
}
putsUSART((char *) sNewline);
//New values
putsUSART((char *) sNew);
for(int i = 0; i < MAX_SERVOS; i++) {
if(i) {
putsUSART((char *) sSeparator);
}
PrintInt(iOutput[i]);
}
putsUSART((char *) sNewline);
//Sort order
putsUSART((char *) sSorted);
for(int i = 0; i < MAX_SERVOS; i++) {
if(i) {
putsUSART((char *) sSeparator);
}
PrintInt(cIds[i]);
}
putsUSART((char *) sNewline);
putsUSART((char *) sNewline);
c++;
}
void main(void) {
char c;
signed char length;
unsigned char msgtype;
unsigned char last_reg_recvd;
uart_comm uc;
i2c_comm ic;
unsigned char msgbuffer[MSGLEN + 1];
unsigned char i;
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
#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
#ifdef __USE18F45J10
OSCCON = 0x82; // see datasheeet
OSCTUNEbits.PLLEN = 1; // Makes the clock exceed the PIC's rated speed if the PLL is on
#else
#ifdef __USE18F26J50
OSCCON = 0xE0; // see datasheeet
OSCTUNEbits.PLLEN = 1;
#else
#ifdef __USE18F46J50
OSCCON = 0xE0; //see datasheet
OSCTUNEbits.PLLEN = 1;
#else
Something is messed up.
The PIC selected is not supported or the preprocessor directives are wrong.
#endif
#endif
#endif
#endif
// initialize my uart recv handling code
init_uart_recv(&uc);
// initialize the i2c code
init_i2c(&ic);
// init the timer1 lthread
init_timer1_lthread(&t1thread_data);
// initialize message queues before enabling any interrupts
init_queues();
#ifndef __USE18F26J50
// set direction for PORTB to output
LATB = 0x0;
TRISB = 0x07;
PORTA = 0x0;
LATA = 0x0;
TRISA = 0x0F;
//
// PORTE = 0x0;
// LATE = 0x0;
// TRISE = 0x0F;
//
// PSPMODE = 0x0;
#endif
// how to set up PORTA for input (for the V4 board with the PIC2680)
/*
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_64);
#ifdef __USE18F26J50
// MTJ added second argument for OpenTimer1()
OpenTimer1(TIMER_INT_ON & T1_SOURCE_FOSC_4 & T1_PS_1_8 & T1_16BIT_RW & T1_OSC1EN_OFF & T1_SYNC_EXT_OFF,0x0);
#else
#ifdef __USE18F46J50
OpenTimer1(TIMER_INT_ON & T1_SOURCE_FOSC_4 & T1_PS_1_8 & T1_16BIT_RW & T1_OSC1EN_OFF & T1_SYNC_EXT_OFF,0x0);
#else
OpenTimer1(TIMER_INT_ON & T1_8BIT_RW & T1_PS_1_1 & T1_SOURCE_INT & T1_OSC1EN_OFF & T1_SYNC_EXT_OFF);
#endif
#endif
// Decide on the priority of the enabled peripheral interrupts
// 0 is low, 1 is high
// ADC interrupt
IPR1bits.ADIP = 0;
PIE1bits.ADIE = 1;
// Timer1 interrupt
IPR1bits.TMR1IP = 0;
// USART RX interrupt
IPR1bits.RCIP = 0;
// I2C interrupt
IPR1bits.SSPIP = 1;
// configure the hardware i2c device as a slave (0x9E -> 0x4F) or (0x9A -> 0x4D)
#if 1
// Note that the temperature sensor Address bits (A0, A1, A2) are also the
// least significant bits of LATB -- take care when changing them
// They *are* changed in the timer interrupt handlers if those timers are
// enabled. They are just there to make the lights blink and can be
// disabled.
i2c_configure_slave(0x9E);
#else
// If I want to test the temperature sensor from the ARM, I just make
// sure this PIC does not have the same address and configure the
// temperature sensor address bits and then just stay in an infinite loop
i2c_configure_slave(0x9A);
#ifdef __USE18F2680
LATBbits.LATB1 = 1;
LATBbits.LATB0 = 1;
LATBbits.LATB2 = 1;
#endif
for (;;);
#endif
// must specifically enable the I2C interrupts
PIE1bits.SSPIE = 1;
// configure the hardware USART device
#ifdef __USE18F26J50
Open1USART(USART_TX_INT_OFF & USART_RX_INT_ON & USART_ASYNCH_MODE & USART_EIGHT_BIT &
USART_CONT_RX & USART_BRGH_LOW, 0x19);
#else
#ifdef __USE18F46J50
Open1USART(USART_TX_INT_OFF & USART_RX_INT_ON & USART_ASYNCH_MODE & USART_EIGHT_BIT &
USART_CONT_RX & USART_BRGH_LOW, 0x19);
#else/*
OpenUSART(USART_TX_INT_OFF & USART_RX_INT_ON & USART_ASYNCH_MODE & USART_EIGHT_BIT &
USART_CONT_RX & USART_BRGH_LOW, 0x19);
TRISCbits.RC6 = 1; //TX pin set as output
TRISCbits.RC7 = 1; //RX pin set as input
WriteUSART(0x00);
WriteUSART(0x01);
WriteUSART(0x02);
WriteUSART(0x03);*/
#endif
#endif
OpenUSART(USART_TX_INT_OFF & USART_RX_INT_ON & USART_ASYNCH_MODE & USART_EIGHT_BIT &
USART_CONT_RX & USART_BRGH_LOW, 38);
TRISCbits.RC6 = 0; //TX pin set as output
TRISCbits.RC7 = 1; //RX pin set as input
//char data = 0x05;
//WriteUSART(data);
//while(BusyUSART());
//WriteUSART(data);
//WriteUSART(0x05);
//WriteUSART(0x05);
//putsUSART(0x00);
// while(BusyUSART());
// putsUSART(0x05);
// while(BusyUSART());
// putsUSART(0x05);
// while(BusyUSART());
// putsUSART(0x05);
// Peripheral interrupts can have their priority set to high or low
// enable high-priority interrupts and low-priority interrupts
enable_interrupts();
/* Junk to force an I2C interrupt in the simulator (if you wanted to)
PIR1bits.SSPIF = 1;
_asm
goto 0x08
_endasm;
*/
// printf() is available, but is not advisable. It goes to the UART pin
// on the PIC and then you must hook something up to that to view it.
// It is also slow and is blocking, so it will perturb your code's operation
// Here is how it looks: printf("Hello\r\n");
OpenADC(ADC_FOSC_16 & ADC_LEFT_JUST & ADC_2_TAD,
ADC_CH0 & ADC_INT_OFF & ADC_VREFPLUS_VDD & ADC_VREFMINUS_VSS,
0b1011);
SetChanADC(ADC_CH0);
// ADC_CALIB();
// loop forever
// This loop is responsible for "handing off" messages to the subroutines
// that should get them. Although the subroutines are not threads, but
// they can be equated with the tasks in your task diagram if you
// structure them properly.
while (1) {
// Call a routine that blocks until either on the incoming
// messages queues has a message (this may put the processor into
// an idle mode)
block_on_To_msgqueues();
// At this point, one or both of the queues has a message. It
// makes sense to check the high-priority messages first -- in fact,
// you may only want to check the low-priority messages when there
// is not a high priority message. That is a design decision and
// I haven't done it here.
length = ToMainHigh_recvmsg(MSGLEN, &msgtype, (void *) msgbuffer);
if (length < 0) {
// no message, check the error code to see if it is concern
if (length != MSGQUEUE_EMPTY) {
// This case be handled by your code.
}
} else {
switch (msgtype) {
case MSGT_TIMER0:
{
timer0_lthread(&t0thread_data, msgtype, length, msgbuffer);
break;
};
case MSGT_I2C_DATA:
case MSGT_I2C_DBG:
{
// Here is where you could handle debugging, if you wanted
// keep track of the first byte received for later use (if desired)
last_reg_recvd = msgbuffer[0];
break;
};
case MSGT_I2C_RQST:
{
// Generally, this is *NOT* how I recommend you handle an I2C slave request
// I recommend that you handle it completely inside the i2c interrupt handler
// by reading the data from a queue (i.e., you would not send a message, as is done
// now, from the i2c interrupt handler to main to ask for data).
//
// The last byte received is the "register" that is trying to be read
// The response is dependent on the register.
switch (last_reg_recvd) {
case 0xaa:
{
length = 2;
ConvertADC();
while( BusyADC()) {
//LATBbits.LATB0 = 1;
}
msgbuffer[0] = ADRESH;
msgbuffer[1] = 0xAA;
break;
}
case 0xa8:
{
length = 1;
msgbuffer[0] = 0x3A;
break;
}
case 0xa9:
{
length = 1;
msgbuffer[0] = 0xA3;
break;
}
};
start_i2c_slave_reply(length, msgbuffer);
break;
};
default:
{
break;
};
};
}
// Check the low priority queue
length = ToMainLow_recvmsg(MSGLEN, &msgtype, (void *) msgbuffer);
if (length < 0) {
// no message, check the error code to see if it is concern
if (length != MSGQUEUE_EMPTY) {
// Your code should handle this situation
}
} else {
switch (msgtype) {
case MSGT_TIMER1:
{
timer1_lthread(&t1thread_data, msgtype, length, msgbuffer);
break;
};
case MSGT_OVERRUN:
case MSGT_UART_DATA:
{
uart_lthread(&uthread_data, msgtype, length, msgbuffer);
break;
};
default:
{
// Your code should handle this error
break;
};
};
}
}
}
void uart_recv_wifly_debug_handler(){
#ifdef __USE18F46J50
if (DataRdy1USART()) {
unsigned char last = Read1USART();
#else
if (DataRdyUSART()) {
unsigned char last = ReadUSART();
#endif
static unsigned char cur = 0;
if (last == endmsg[cur]) {
cur++;
if(cur >= sizeof endmsg - 1) { //-1 for null terminated
wifly_setup = 1;
}
}
else{
cur = 0;
}
}
}
void uart_recv_int_handler() {
#ifdef __USE18F26J50
if (DataRdy1USART()) {
uc_ptr->buffer[uc_ptr->buflen] = Read1USART();
#else
#ifdef __USE18F46J50
if (DataRdy1USART()) {
unsigned char recv = Read1USART();
#else
if (DataRdyUSART()) {
unsigned char recv = ReadUSART();
#endif
#endif
int pos = uc_ptr->buflen++;
uc_ptr->buffer[pos] = recv;
//We recieved the last byte of data
//Check the 5th byte recieved for payload length
if(pos == PAYLOADLEN_POS){
payload_length = recv;
}
// Get checksum byte
if(pos == CHECKSUM_POS){
checksum_recv_value = recv;
}
// Count any other byte other than checksum
else{
checksum_calc_value += recv;
}
// check if a message should be sent
if (pos == payload_length+HEADER_MEMBERS-1){
pos++;
if(checksum_calc_value == checksum_recv_value){
FromUARTInt_sendmsg(pos, MSGT_UART_DATA, (void *) uc_ptr->buffer);
}
else{ //Invalid Checksum
FromUARTInt_sendmsg(pos, MSGT_UART_RECV_FAILED, (void *) uc_ptr->buffer);
}
//Clean up for next packet
uc_ptr->buflen = 0;
payload_length = 0;
checksum_recv_value = 0;
checksum_calc_value = 0;
#ifdef __USE18F46J50
//Read1USART(); // clears buffer and returns value to nothing
#else
//ReadUSART();
#endif
}
// portion of the bytes were received or there was a corrupt byte or there was
// an overflow transmitted to the buffer
else if (pos >= MAXUARTBUF)
{
FromUARTInt_sendmsg(pos, MSGT_OVERRUN, (void *) uc_ptr->buffer);
uc_ptr->buflen = 0;
payload_length = 0;
checksum_recv_value = 0;
checksum_calc_value = 0;
}
}
#ifdef __USE18F26J50
if (USART1_Status.OVERRUN_ERROR == 1) {
#else
#ifdef __USE18F46J50
if (USART1_Status.OVERRUN_ERROR == 1) {
#else
if (USART_Status.OVERRUN_ERROR == 1) {
#endif
#endif
// we've overrun the USART and must reset
// send an error message for this
RCSTAbits.CREN = 0;
RCSTAbits.CREN = 1;
FromUARTInt_sendmsg(0, MSGT_OVERRUN, (void *) 0);
}
#ifdef __USE18F46J50
if (USART1_Status.FRAME_ERROR) {
#else
if (USART_Status.FRAME_ERROR) {
#endif
init_uart_recv(uc_ptr);
}
}
void init_uart_recv(uart_comm *uc) {
uc_ptr = uc;
uc_ptr->status = UART_IDLE;
uc_ptr->buflen = 0;
payload_length = 0;
checksum_recv_value = 0;
checksum_calc_value = 0;
}
void uart_send_array(char* data, char length) {
#if !defined(SENSOR_PIC) && !defined(MOTOR_PIC)
if(!wifly_setup) return; //just return
#endif
if(uc_ptr->status != UART_IDLE){
if(in_main()){
debugNum(2);
if(FromMainHigh_sendmsg(length, MSGT_UART_TX_BUSY, data) == MSGQUEUE_FULL)
debugNum(4);
}
else{
FromUARTInt_sendmsg(length, MSGT_UART_TX_BUSY, data);
}
return;
}
uc_ptr->status = UART_TX;
//TODO: Create logic to prevent you from overriding the current buffer if
//it has not yet been sent.
uint8_t i;
for(i = 0; i<length; i++) {
uc_ptr->outBuff[i] = *(data + i);
}
uc_ptr->outLength = length;
uc_ptr->outIndex = 1;
#ifdef __USE18F46J50
Write1USART(uc_ptr->outBuff[0]);
#else
WriteUSART(uc_ptr->outBuff[0]);
#endif
PIR1bits.TXIF = 0;
PIE1bits.TXIE = 1;
}
//Used to send multiple char. Will get called when uart_send_array is called
//Brian says DONT DELETE! I will find you.
void uart_send_int_handler() {
if(uc_ptr->outLength > uc_ptr->outIndex){
uart_send(uc_ptr->outBuff[uc_ptr->outIndex++]);
}
else if(uc_ptr->outLength == uc_ptr->outIndex){
uc_ptr->outIndex++; //still need to increment
}
else //uc_ptr->outLength < uc_ptr->outIndex
{
// done sending message
PIE1bits.TXIE = 0;
PIR1bits.TXIF = 0;
uc_ptr->status = UART_IDLE;
}
}
void uart_send(char data){
//TODO possibly create logic to (without using a while) prevent writing if the buffer is not
//clear
#ifdef __USE18F46J50
Write1USART(data);
#else
WriteUSART(data);
#endif
}
// Track Mode
// Assume motor A and B are front left and right, motor C and D are back left and right
// Num pad controls A/C and B/D
void trackmode(void){
WriteUSART(27);
putrsUSART (ClrScr);
putrsUSART (Menu1_2);
while(1){
while(!DataRdyUSART()); //wait for data
key = ReadUSART(); //read data
switch (key) {
case 'W':
{
if(PWMA2+PWM_Step<=PWM_DC_Max)PWMA2=PWMA2+PWM_Step;
else PWMA2=PWM_DC_Max;
if(PWMB1+PWM_Step<=PWM_DC_Max)PWMB1=PWMB1+PWM_Step;
else PWMB1=PWM_DC_Max;
// PWMA2+=PWM_Step;
// PWMB1+=PWM_Step;
break;
}
case 'S':
{
if(PWMA2-PWM_Step>=PWM_DC_Min) PWMA2=PWMA2-PWM_Step;
else PWMA2=PWM_DC_Min;
if(PWMB1-PWM_Step>=PWM_DC_Min) PWMB1=PWMB1-PWM_Step;
else PWMB1=PWM_DC_Min;
// PWMA2-=PWM_Step;
// PWMB1-=PWM_Step;
break;
}
case 'A':
{
if(PWMA2-PWM_Step>=PWM_DC_Min) PWMA2=PWMA2-PWM_Step;
else PWMA2=PWM_DC_Min;
if(PWMB1+PWM_Step<=PWM_DC_Max) PWMB1=PWMB1+PWM_Step;
else PWMB1=PWM_DC_Max;
// PWMA2-=PWM_Step;
// PWMB1+=PWM_Step;
break;
}
case 'D':
{
if(PWMA2+PWM_Step<=PWM_DC_Max) PWMA2=PWMA2+PWM_Step;
else PWMA2=PWM_DC_Max;
if(PWMB1-PWM_Step>=PWM_DC_Min) PWMB1=PWMB1-PWM_Step;
else PWMB1=PWM_DC_Min;
// PWMA2+=PWM_Step;
// PWMB1-=PWM_Step;
break;
}
case 'N':
{
RC=0;
RD=0;
break;
}
case 'K':
{
RC=1;
RD=1;
break;
}
case 'O':
{
RC=1;
RD=0;
break;
}
case 'M':
{
RE=0;
RF=0;
break;
}
case 'L':
{
RE=1;
RF=1;
break;
}
case 'P':
{
RE=1;
RF=0;
break;
}
case ' ':
{
PWMA2=PWM_Stop;
PWMB1=PWM_Stop;
PWMC0=PWM_Stop;
PWMD3=PWM_Stop;
RC=0;
RD=0;
break;
}
case 27:
{
return;
break;
}
default:
{
putrsUSART (BadKey);
break;
}
}
//Set Channels C and D from Channels A and B, respectivley
PWMC0=PWMA2;
PWMD3=PWMB1;
//Upate the PWM signals
Update_PWMs();
}
return;
}
void bucket(void){
WriteUSART(27);
putrsUSART (ClrScr);
putrsUSART (Menu1_2);
while(1){
while(!DataRdyUSART()); //wait for data
key = ReadUSART(); //read data
switch (key) {
case 'P':
{
if(PWMA2+PWM_Step<=PWM_DC_Max)PWMA2=PWMA2+PWM_Step;
else PWMA2=PWM_DC_Max;
// PWMA2+=PWM_Step;
// PWMB1+=PWM_Step;
break;
}
case 'L':
{
if(PWMA2-PWM_Step>=PWM_DC_Min) PWMA2=PWMA2-PWM_Step;
else PWMA2=PWM_DC_Min;
// PWMA2-=PWM_Step;
// PWMB1-=PWM_Step;
break;
}
case 'O':
{
if(PWMD3-PWM_Step>=PWM_DC_Min) PWMD3=PWMD3-PWM_Step;
else PWMD3=PWM_DC_Min;
// PWMA2-=PWM_Step;
// PWMB1+=PWM_Step;
break;
}
case 'K':
{
if(PWMD3+PWM_Step<=PWM_DC_Max) PWMD3=PWMD3+PWM_Step;
else PWMD3=PWM_DC_Max;
// PWMA2+=PWM_Step;
// PWMB1-=PWM_Step;
break;
}
case ' ':
{
PWMA2=PWM_Stop;
PWMB1=PWM_Stop;
PWMC0=PWM_Stop;
PWMD3=PWM_Stop;
break;
}
case 27:
{
return;
break;
}
default:
{
putrsUSART (BadKey);
break;
}
}
//Upate the PWM signals
Update_PWMs();
}
return;
}
