void InitApp(void)
{
/* Initialize peripherals */
// Configure UART modules
UARTConfigure(UART_CMD_MODULE_ID, UART_ENABLE_PINS_TX_RX_ONLY);
UARTSetFifoMode(UART_CMD_MODULE_ID, UART_INTERRUPT_ON_TX_NOT_FULL | UART_INTERRUPT_ON_RX_NOT_EMPTY);
UARTSetLineControl(UART_CMD_MODULE_ID, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1);
UARTSetDataRate(UART_CMD_MODULE_ID, GetPeripheralClock(), DESIRED_CMD_BAUDRATE);
UARTEnable(UART_CMD_MODULE_ID, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));
UARTConfigure(UART_WIFI_MODULE_ID, UART_ENABLE_PINS_TX_RX_ONLY);
UARTSetFifoMode(UART_WIFI_MODULE_ID, UART_INTERRUPT_ON_TX_NOT_FULL | UART_INTERRUPT_ON_RX_NOT_EMPTY);
UARTSetLineControl(UART_WIFI_MODULE_ID, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1);
UARTSetDataRate(UART_WIFI_MODULE_ID, GetPeripheralClock(), DESIRED_WIFI_BAUDRATE);
UARTEnable(UART_WIFI_MODULE_ID, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));
// Configure UART Interrupts
INTEnable(INT_SOURCE_UART_RX(UART_CMD_MODULE_ID), INT_ENABLED);
INTSetVectorPriority(INT_VECTOR_UART(UART_CMD_MODULE_ID), INT_PRIORITY_LEVEL_2);
INTSetVectorSubPriority(INT_VECTOR_UART(UART_CMD_MODULE_ID), INT_SUB_PRIORITY_LEVEL_0);
INTEnable(INT_SOURCE_UART_RX(UART_WIFI_MODULE_ID), INT_ENABLED);
INTSetVectorPriority(INT_VECTOR_UART(UART_WIFI_MODULE_ID), INT_PRIORITY_LEVEL_1);
INTSetVectorSubPriority(INT_VECTOR_UART(UART_WIFI_MODULE_ID), INT_SUB_PRIORITY_LEVEL_0);
// Make the requests to Wifi service - they will be picked up when the service needs them
ConnectToAccessPoint(&routerConnection, &DefaultWifiService);
SendHttpRequest(&DnsDynamicHttpRequest, &DefaultWifiService);
}
// UART 2 interrupt handler
// it is set at priority level 2
void __ISR(_UART2_VECTOR, ipl2) IntUart2Handler(void)
{
// Is this an RX interrupt?
if(INTGetFlag(INT_SOURCE_UART_RX(UART2)))
{
// Clear the RX interrupt Flag
INTClearFlag(INT_SOURCE_UART_RX(UART2));
// Code to be executed on RX interrupt:
// Echo what we just received.
PutCharacter(UARTGetDataByte(UART2));
// Toggle LED to indicate UART activity
mPORTAToggleBits(BIT_7);
}
// We don't care about TX interrupt
if ( INTGetFlag(INT_SOURCE_UART_TX(UART2)) )
{
// Clear the TX interrupt Flag
INTClearFlag(INT_SOURCE_UART_TX(UART2));
// Code to be executed on TX interrupt:
}
}
// UART 2 interrupt handler
// it is set at priority level 2
void __ISR(_UART2_VECTOR, ipl2) IntUart2Handler(void)
{
// Is this an RX interrupt?
if(INTGetFlag(INT_SOURCE_UART_RX(UART2)))
{
unsigned char databyte;
// Clear the RX interrupt Flag
INTClearFlag(INT_SOURCE_UART_RX(UART2));
// Code to be executed on RX interrupt:
databyte = UARTGetDataByte(UART2);
databyte++;
// Echo what we just received.
PutCharacter(databyte);
}
// We don't care about TX interrupt
if ( INTGetFlag(INT_SOURCE_UART_TX(UART2)) )
{
// Clear the TX interrupt Flag
INTClearFlag(INT_SOURCE_UART_TX(UART2));
// Code to be executed on TX interrupt:
}
}
void __ISR(_UART2_VECTOR, ipl2) IntUart2Handler(void)
{
// Is this an RX interrupt?
if(INTGetFlag(INT_SOURCE_UART_RX(UART2)))
{
// Clear the RX interrupt Flag
INTClearFlag(INT_SOURCE_UART_RX(UART2));
// Code to be executed on RX interrupt:
COMMAND = UARTGetDataByte(UART2);
// Echo what we just received.
PutCharacter(COMMAND);
}
// We don't care about TX interrupt
if ( INTGetFlag(INT_SOURCE_UART_TX(UART2)) )
{
// Clear the TX interrupt Flag
INTClearFlag(INT_SOURCE_UART_TX(UART2));
// Code to be executed on TX interrupt:
//none
}
}
void serial_init(void)
{
// Initialisation du fifo de réception
InitFifo ( &descrFifoRX, FIFO_RX_SIZE, fifoRX, 0 );
// Initialisation du fifo d'émission
InitFifo ( &descrFifoTX, FIFO_TX_SIZE, fifoTX, 0 );
// Utilisation des fonctions séparées (XC32)
// =========================================
UARTConfigure(UART2, UART_ENABLE_HIGH_SPEED | UART_ENABLE_PINS_TX_RX_ONLY );
// UARTSetFifoMode(UART2, UART_INTERRUPT_ON_TX_BUFFER_EMPTY | UART_INTERRUPT_ON_RX_HALF_FULL );
// Remarque HALF_FULL ne fonctionne pas
// Pour INT RX au 3/4
UARTSetFifoMode(UART2, UART_INTERRUPT_ON_TX_BUFFER_EMPTY | UART_INTERRUPT_ON_RX_3_QUARTER_FULL );
// Pour INT RX dés que min 1 char
// UARTSetFifoMode(UART2, UART_INTERRUPT_ON_TX_BUFFER_EMPTY | UART_INTERRUPT_ON_RX_NOT_EMPTY );
UARTSetLineControl(UART2, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1);
UINT32 ActualBaudRate = UARTSetDataRate(UART2, PB_FREQ, 9600);
UARTEnable(UART2, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));
// Configuration Int UART2 avec les fonctions séparées
// ===================================================
// Configure UART RX Interrupt
INTEnable(INT_SOURCE_UART_RX(UART2), INT_ENABLED);
INTSetVectorPriority(INT_VECTOR_UART(UART2), INT_PRIORITY_LEVEL_5);
INTSetVectorSubPriority(INT_VECTOR_UART(UART2), INT_SUB_PRIORITY_LEVEL_0);
} // InitComm
//TODO: implement sanity checks.
hal_uart_port hal_uart_open(hal_uart_port port, hal_uart_baudrate baudrate,
hal_uart_parity parity,
hal_uart_stop_bits stop_bits,
hal_uart_on_data_received_callback data_received){
on_data_received[port] = data_received;
assert(port >= HAL_UART_PORT_1 && port <= HAL_UART_NUMBER_OF_PORTS );
/* Configure uart */
UART_MODULE uart = logic_uart2phy_uart(port);
SetRxTxPins(uart);
UARTConfigure(uart, UART_ENABLE_PINS_TX_RX_ONLY);
UARTSetFifoMode(uart, UART_INTERRUPT_ON_TX_DONE | UART_INTERRUPT_ON_RX_NOT_EMPTY);
UARTSetLineControl(uart, UART_DATA_SIZE_8_BITS | get_parity(parity) | get_stop_bits(stop_bits));
UARTSetDataRate(uart, PIC32_PERIPHERALBUS_FREQ, get_baudrate(baudrate));
UARTEnable(uart, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_TX | UART_RX));
INTClearFlag(INT_SOURCE_UART_RX(uart));
INTEnable(INT_SOURCE_UART_RX(uart),INT_ENABLED);
return port;
}
void __ISR(_UART1_VECTOR, IPL2SOFT) IntUart1Handler(void)
{
if(INTGetFlag(INT_SOURCE_UART_RX(UART1)))
{
INTClearFlag(INT_SOURCE_UART_RX(UART1));
if (uart_rx_count<sizeof(uart_rx_buff)-1)
uart_rx_count++;
else
uart_rx_count=0; // overflow
uart_rx_buff[uart_rx_count]=UARTGetDataByte(UART1);
}
if(INTGetFlag(INT_SOURCE_UART_TX(UART1)))
{
INTClearFlag(INT_SOURCE_UART_TX(UART1));
}
}
void handleUartInterrupt(UART_MODULE uart, Buffer* buffer) {
// Is this an RX interrupt?
if (INTGetFlag(INT_SOURCE_UART_RX(uart))) {
if (UARTReceivedDataIsAvailable(uart)) {
unsigned char c = UARTGetDataByte(uart);
// BUG2018, BUG2019 (255 / 254 value) when Motor Power is too strong
if (c != 'ÿ' && c != 'þ') {
bufferWriteChar(buffer, c);
}
// Clear the RX interrupt Flag
INTClearFlag(INT_SOURCE_UART_RX(uart));
}
}
// We don't care about TX interrupt
if ( INTGetFlag(INT_SOURCE_UART_TX(uart)) ) {
INTClearFlag(INT_SOURCE_UART_TX(uart));
}
}
// UART interrupt handler, set at priority level 2
void __ISR(_UART_2_VECTOR, ipl2) IntUart2Handler(void)
{
// Is this an RX interrupt?
if(INTGetFlag(INT_SOURCE_UART_RX(UART_CMD_MODULE_ID)))
{
char rchar = UARTGetDataByte(UART_CMD_MODULE_ID);
AddKeystroke(&CurrentCommandEngine, rchar);
// Clear the RX interrupt Flag
INTClearFlag(INT_SOURCE_UART_RX(UART_CMD_MODULE_ID));
}
// We don't care about TX interrupt
if ( INTGetFlag(INT_SOURCE_UART_TX(UART_CMD_MODULE_ID)) )
{
INTClearFlag(INT_SOURCE_UART_TX(UART_CMD_MODULE_ID));
}
}
void __ISR(_UART_4_VECTOR, ipl1) IntUart4Handler(void)
{
// Is this an RX interrupt?
if(INTGetFlag(INT_SOURCE_UART_RX(UART_WIFI_MODULE_ID)))
{
const char rchar = UARTGetDataByte(UART_WIFI_MODULE_ID);
PutcToWifiReceivedBuffer(rchar, &DefaultWifiService);
// Clear the RX interrupt Flag
INTClearFlag(INT_SOURCE_UART_RX(UART_WIFI_MODULE_ID));
}
// We don't care about TX interrupt
if ( INTGetFlag(INT_SOURCE_UART_TX(UART_WIFI_MODULE_ID)) )
{
INTClearFlag(INT_SOURCE_UART_TX(UART_WIFI_MODULE_ID));
}
}
void __ISR(_UART_2_VECTOR, ipl2) IntUart2Handler(void)
{
// Is this an RX interrupt?
if(INTGetFlag(INT_SOURCE_UART_RX(UART_MODULE_ID2)))
{
#ifdef DEBUG
PutCharacterXbee(UARTGetDataByte(UART_MODULE_ID2));
#endif
INTClearFlag(INT_SOURCE_UART_RX(UART_MODULE_ID2));
}
// We don't care about TX interrupt
if (INTGetFlag(INT_SOURCE_UART_TX(UART_MODULE_ID2)))
{
INTClearFlag(INT_SOURCE_UART_TX(UART_MODULE_ID2));
}
}
// *****************************************************************************
// Initialize the Console serial port (BAUDRATE)
// *****************************************************************************
void InitConsole(UINT32 baud)
{
UARTConfigure(UART_CONSOLE, UART_ENABLE_PINS_TX_RX_ONLY | UART_ENABLE_HIGH_SPEED);
UARTSetFifoMode(UART_CONSOLE, UART_INTERRUPT_ON_TX_NOT_FULL | UART_INTERRUPT_ON_RX_NOT_EMPTY);
UARTSetLineControl(UART_CONSOLE, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1);
UARTSetDataRate(UART_CONSOLE, GetPeripheralClock(), baud);
#ifdef DEBUG_ALLOW_USER_INPUT
INTEnable(INT_SOURCE_UART_RX(UART_CONSOLE), INT_ENABLED);
INTSetVectorPriority(INT_VECTOR_UART(UART_CONSOLE), INT_PRIORITY_LEVEL_2);
INTSetVectorSubPriority(INT_VECTOR_UART(UART_CONSOLE), INT_SUB_PRIORITY_LEVEL_0);
INTEnable(INT_SOURCE_UART_TX(UART_CONSOLE), INT_DISABLED);//Disable TX interrupt!
#endif
UARTEnable(UART_CONSOLE, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));
}
void InitBluetooth(void)
{
#if DESIRED_BAUDRATE == 9600
mPORTBSetPinsDigitalOut(BIT_9);
mPORTBSetBits(BIT_9);// BT high level, the reset polarity is active low
mPORTASetPinsDigitalOut(BIT_3);
mPORTASetBits(BIT_3);// Set Baud rate (high = force 9,600, low = 115 K or firmware setting)
mPORTASetPinsDigitalOut(BIT_2);
mPORTASetBits(BIT_2);// Set BT master (high = auto-master mode)
#elif DESIRED_BAUDRATE == 115200
mPORTBSetPinsDigitalOut(BIT_9);
mPORTBSetBits(BIT_9);// BT high level, the reset polarity is active low
mPORTASetPinsDigitalOut(BIT_3);
mPORTAClearBits(BIT_3);// Set Baud rate (high = force 9,600, low = 115 K or firmware setting)
mPORTASetPinsDigitalOut(BIT_2);
mPORTASetBits(BIT_2);// Set BT master (high = auto-master mode)
#elif DESIRED_BAUDRATE ==921600
//nothing
#endif
UARTConfigure(UART_MODULE_ID2, UART_ENABLE_PINS_TX_RX_ONLY|UART_ENABLE_PINS_CTS_RTS);
UARTConfigure(UART_MODULE_ID2, UART_ENABLE_HIGH_SPEED);
UARTSetFifoMode(UART_MODULE_ID2, UART_INTERRUPT_ON_TX_NOT_FULL | UART_INTERRUPT_ON_RX_NOT_EMPTY);
UARTSetLineControl(UART_MODULE_ID2, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1);
UARTSetDataRate(UART_MODULE_ID2, GetPeripheralClock(), DESIRED_BAUDRATE);
UARTEnable(UART_MODULE_ID2, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));
// Configure UART RX Interrupt
INTEnable(INT_SOURCE_UART_RX(UART_MODULE_ID2), INT_ENABLED);
INTSetVectorPriority(INT_VECTOR_UART(UART_MODULE_ID2), INT_PRIORITY_LEVEL_2);
INTSetVectorSubPriority(INT_VECTOR_UART(UART_MODULE_ID2), INT_SUB_PRIORITY_LEVEL_1);
// Enable multi-vector interrupts
//WriteStringXbee("*** UART Bluetooth demarre ***\r\n");
}
void initUART()
{
// PPS map UART1 pins
RPB3R=0x01; // PPS MAP TX to RPB3
U1RXR=0x04; // PPS MAP RX to RPB2
// Setup UART1
UARTConfigure(UART1, UART_ENABLE_PINS_TX_RX_ONLY);
UARTSetFifoMode(UART1, UART_INTERRUPT_ON_RX_NOT_EMPTY);
UARTSetLineControl(UART1, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1);
UARTSetDataRate(UART1, 48000000, 115200);
UARTEnable(UART1, UART_ENABLE_FLAGS(UART_ENABLE | UART_PERIPHERAL | UART_RX | UART_TX));
INTEnable(INT_SOURCE_UART_RX(UART1), INT_ENABLED);
INTSetVectorPriority(INT_VECTOR_UART(UART1), INT_PRIORITY_LEVEL_2);
INTSetVectorSubPriority(INT_VECTOR_UART(UART1), INT_SUB_PRIORITY_LEVEL_0);
}
void openSerial(unsigned char serialPortIndex, unsigned long baudRate) {
// important to activate the RX for UART5. Information found on the net
if (serialPortIndex == SERIAL_PORT_5) {
PORTSetPinsDigitalIn(IOPORT_B, BIT_8);
}
UART_MODULE uart = getUartModule(serialPortIndex);
UARTConfigure(uart, UART_ENABLE_PINS_TX_RX_ONLY);
UARTSetFifoMode(uart, UART_INTERRUPT_ON_TX_NOT_FULL | UART_INTERRUPT_ON_RX_NOT_EMPTY);
UARTSetLineControl(uart, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1);
UARTSetDataRate(uart, GetPeripheralClock(), baudRate);
UARTEnable(uart, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));
INTEnable(INT_SOURCE_UART_RX(uart), INT_ENABLED);
INTSetVectorPriority(INT_VECTOR_UART(uart), INT_PRIORITY_LEVEL_2);
INTSetVectorSubPriority(INT_VECTOR_UART(uart), INT_SUB_PRIORITY_LEVEL_0);
// TODO : Move this code to Global Setup !
// configure for multi-vectored mode
INTConfigureSystem(INT_SYSTEM_CONFIG_MULT_VECTOR);
// enable interrupts
INTEnableInterrupts();
}
int main(void)
{
unsigned int temp;
// Configure the device for maximum performance but do not change the PBDIV
// Given the options, this function will change the flash wait states, RAM
// wait state and enable prefetch cache but will not change the PBDIV.
// The PBDIV value is already set via the pragma FPBDIV option above..
SYSTEMConfig(GetSystemClock(), SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
/*PORT CONFIGURATION for UART*/
// Blinky LED for Uart activity
//mPORTAClearBits(BIT_7);
//mPORTASetPinsDigitalOut(BIT_7);
// PINS used for the buttons
PORTSetPinsDigitalIn(IOPORT_B, BIT_2 | BIT_3 | BIT_4);
#define CONFIG (CN_ON | CN_IDLE_CON)
#define INTERRUPT (CHANGE_INT_ON | CHANGE_INT_PRI_2)
mCNOpen(CONFIG, CN4_ENABLE | CN5_ENABLE | CN6_ENABLE,
CN4_PULLUP_ENABLE | CN5_PULLUP_ENABLE | CN6_PULLUP_ENABLE);
temp = mPORTBRead();
//Analog input
CloseADC10();
#define PARAM1 ADC_MODULE_ON | ADC_FORMAT_INTG32 | ADC_CLK_AUTO | ADC_AUTO_SAMPLING_ON
#define PARAM2 ADC_VREF_AVDD_AVSS | ADC_SCAN_ON | ADC_SAMPLES_PER_INT_2 | ADC_BUF_16 | ADC_ALT_INPUT_OFF
#define PARAM3 ADC_CONV_CLK_INTERNAL_RC | ADC_SAMPLE_TIME_5
#define PARAM4 ENABLE_AN0_ANA | ENABLE_AN1_ANA
#define PARAM5 SKIP_SCAN_AN2 | SKIP_SCAN_AN3 | SKIP_SCAN_AN4 | SKIP_SCAN_AN5 | SKIP_SCAN_AN6 | SKIP_SCAN_AN7 | SKIP_SCAN_AN8 | SKIP_SCAN_AN9 | SKIP_SCAN_AN10 | SKIP_SCAN_AN11 | SKIP_SCAN_AN12 | SKIP_SCAN_AN13 | SKIP_SCAN_AN14 | SKIP_SCAN_AN15
SetChanADC10( ADC_CH0_NEG_SAMPLEA_NVREF | ADC_CH0_POS_SAMPLEA_AN0);
OpenADC10( PARAM1, PARAM2, PARAM3, PARAM4, PARAM5 );
EnableADC10();
//PORT D for motors
mPORTDClearBits(BIT_0 | BIT_1 | BIT_2 | BIT_3 |
BIT_4 | BIT_5 | BIT_6 | BIT_7 |
BIT_8 | BIT_9 | BIT_10 | BIT_11 |
BIT_12 | BIT_13 | BIT_14 | BIT_15); // Turn off PORTD on startup.
mPORTDSetPinsDigitalOut(BIT_0 | BIT_1 | BIT_2 | BIT_3 |
BIT_4 | BIT_5 | BIT_6 | BIT_7 |
BIT_8 | BIT_9 | BIT_10 | BIT_11 |
BIT_12 | BIT_13 | BIT_14 | BIT_15); // Make PORTD output.
// Explorer-16 uses UART2 to connect to the PC.
// This initialization assumes 36MHz Fpb clock. If it changes,
// you will have to modify baud rate initializer.
UARTConfigure(UART2, UART_ENABLE_PINS_TX_RX_ONLY);
UARTSetFifoMode(UART2, UART_INTERRUPT_ON_TX_NOT_FULL | UART_INTERRUPT_ON_RX_NOT_EMPTY);
UARTSetLineControl(UART2, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1);
UARTSetDataRate(UART2, GetPeripheralClock(), DESIRED_BAUDRATE);
UARTEnable(UART2, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));
// Configure UART2 RX Interrupt
INTEnable(INT_SOURCE_UART_RX(UART2), INT_ENABLED);
INTSetVectorPriority(INT_VECTOR_UART(UART2), INT_PRIORITY_LEVEL_2);
INTSetVectorSubPriority(INT_VECTOR_UART(UART2), INT_SUB_PRIORITY_LEVEL_0);
// Congifure Change/Notice Interrupt Flag
ConfigIntCN(INTERRUPT);
// configure for multi-vectored mode
INTConfigureSystem(INT_SYSTEM_CONFIG_MULT_VECTOR);
// enable interrupts
INTEnableInterrupts();
WriteString("*** UART Interrupt-driven Example ***\r\n");
unsigned int channel1, channel2;
unsigned int motor1Time, motor2Time;
// Let interrupt handler do the work
while (1) {
while ( ! mAD1GetIntFlag() );
channel1 = ReadADC10(0);
channel2 = ReadADC10(1);
motor1Time = (channel1*(60000)/(1023) + 80000);
motor2Time = (channel2*(60000)/(1023) + 80000);
//maximo valor de motorTime = 140000
//use motor time for stepping delay
if (MotorsON) {
if (M1forward) {
adelante(1, motor1Time, 1);
} else {
atras(1, motor1Time, 1);
}
if (M2forward) {
adelante(1, motor2Time, 3);
} else {
atras(1, motor2Time, 3);
}
}
mAD1ClearIntFlag();
}
return 0;
}
/*******************************************************************************
Function:
void ConsoleUartIntHandler(void)
Remarks:
UART 1 interrupt handler is set at priority level 2 with software context saving
*/
void ConsoleUartIntHandler(void)
{
unsigned char byteReceived;
// Is this an RX interrupt?
if (INTGetFlag(INT_SOURCE_UART_RX(UART_CONSOLE)))
{
while (UARTReceivedDataIsAvailable(UART_CONSOLE) != 0)
{
byteReceived = UARTGetDataByte(UART_CONSOLE);
//Console Interrupt - In Self Test Mode
if(self_TESTMode == TRUE)
{
ConsoleMsgCallback_selfTest();
}
//Console Interrupt - RN1723 Command Mode
else if(RN_UartCmdMode == 1)
{
//Exit console mode if 'ESC'
if(byteReceived == ESC)
{
RN_UartCmdMode = FALSE;
RN_DATA_MODE();
memset(consoleMsg, '\0', sizeof(consoleMsg));
}
else
{
while(!UARTTransmitterIsReady(UART_WIFLY));
UARTSendDataByte(UART_WIFLY, byteReceived);
}
}
else
{
PIC32_ConsoleMode = TRUE;
putConsole(byteReceived);
if(byteReceived == CR)
{
PrintConsoleMenu();
}
else if(byteReceived == LF)
{
//Ignore Line Feed
}
else if(byteReceived == BACKSPACE)
{
consoleMsg[(strlen(consoleMsg)-1)] = '\0';
}
else if(byteReceived == ESC)
{
PIC32_ConsoleMode = FALSE;
memset(consoleMsg, '\0', sizeof(consoleMsg));
}
else
{
consoleMsg[strlen(consoleMsg)] = byteReceived;
}
}
}
// Clear the RX interrupt Flag
INTClearFlag(INT_SOURCE_UART_RX(UART_CONSOLE));
}
// We don't care about the TX interrupt
if (INTGetFlag(INT_SOURCE_UART_TX(UART_CONSOLE)) )
{
INTClearFlag(INT_SOURCE_UART_TX(UART_CONSOLE));
}
}
// UART3 interrupt handler, priority level 2
void __ISR(_UART_3_VECTOR, ipl2) IntUart3Handler(void) {
// Is this an RX interrupt?
if(INTGetFlag(INT_SOURCE_UART_RX(UART3))){
char data = UARTGetDataByte(UART3);
LED1 = !LED1;
if(data =='x') {
//Stop program, both magnets ON
start = 0;
EMAG1 = EMAG2 = 1;
}
if(data =='e') {
// Magnet 1 ON
EMAG1 = 1;
}
if(data =='f') {
// Magnet 1 OFF
EMAG1 = 0;
}
if(data =='g') {
// Magnet 2 ON
EMAG2 = 1;
}
if(data =='h') {
// Magnet 2 OFF
EMAG2 = 0;
}
if(data =='s') {
// start motion program
start = 1;
LED0=0;
}
if(data =='o') {
delay1 = delay1+1;
}
if(data =='p') {
delay1 = delay1-1;
}
if(data =='k') {
delay2 = delay2+1;
}
if(data =='l') {
delay2 = delay2-1;
}
if(data =='n') {
delay3 = delay3+1;
}
if(data =='m') {
delay3 = delay3-1;
}
// Clear the RX interrupt Flag
INTClearFlag(INT_SOURCE_UART_RX(UART3));
}
// We don't care about TX interrupt
if(INTGetFlag(INT_SOURCE_UART_TX(UART3))) {
INTClearFlag(INT_SOURCE_UART_TX(UART3));
}
}
int main(void)
{
//LOCALS
unsigned int temp;
unsigned int channel1, channel2;
M1_stepPeriod = M2_stepPeriod = M3_stepPeriod = M4_stepPeriod = 50; // in tens of u-seconds
unsigned char M1_state = 0, M2_state = 0, M3_state = 0, M4_state = 0;
SYSTEMConfig(GetSystemClock(), SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
/* TIMER1 - now configured to interrupt at 10 khz (every 100us) */
OpenTimer1(T1_ON | T1_SOURCE_INT | T1_PS_1_1, T1_TICK);
ConfigIntTimer1(T1_INT_ON | T1_INT_PRIOR_2);
/* TIMER2 - 100 khz interrupt for distance measure*/
OpenTimer2(T2_ON | T2_SOURCE_INT | T2_PS_1_1, T2_TICK);
ConfigIntTimer2(T2_INT_ON | T2_INT_PRIOR_3); //It is off until trigger
/* PORTA b2 and b3 for servo-PWM */
mPORTAClearBits(BIT_2 | BIT_3);
mPORTASetPinsDigitalOut(BIT_2 | BIT_3);
/* ULTRASONICS: some bits of PORTB for ultrasonic sensors */
PORTResetPins(IOPORT_B, BIT_8 | BIT_9| BIT_10 | BIT_11 );
PORTSetPinsDigitalOut(IOPORT_B, BIT_8 | BIT_9| BIT_10 | BIT_11); //trigger
/* Input Capture pins for echo signals */
//interrupt on every risging/falling edge starting with a rising edge
PORTSetPinsDigitalIn(IOPORT_D, BIT_8| BIT_9| BIT_10| BIT_11); //INC1, INC2, INC3, INC4 Pin
mIC1ClearIntFlag();
OpenCapture1( IC_EVERY_EDGE | IC_INT_1CAPTURE | IC_TIMER2_SRC | IC_ON );//front
ConfigIntCapture1(IC_INT_ON | IC_INT_PRIOR_4 | IC_INT_SUB_PRIOR_3);
OpenCapture2( IC_EVERY_EDGE | IC_INT_1CAPTURE | IC_TIMER2_SRC | IC_ON );//back
ConfigIntCapture2(IC_INT_ON | IC_INT_PRIOR_4 | IC_INT_SUB_PRIOR_3);
OpenCapture3( IC_EVERY_EDGE | IC_INT_1CAPTURE | IC_TIMER2_SRC | IC_ON );//left
ConfigIntCapture3(IC_INT_ON | IC_INT_PRIOR_4 | IC_INT_SUB_PRIOR_3);
OpenCapture4( IC_EVERY_EDGE | IC_INT_1CAPTURE | IC_TIMER2_SRC | IC_ON );//right
ConfigIntCapture4(IC_INT_ON | IC_INT_PRIOR_4 | IC_INT_SUB_PRIOR_3);
/* PINS used for the START (RD13) BUTTON */
PORTSetPinsDigitalIn(IOPORT_D, BIT_13);
#define CONFIG (CN_ON | CN_IDLE_CON)
#define INTERRUPT (CHANGE_INT_ON | CHANGE_INT_PRI_2)
mCNOpen(CONFIG, CN19_ENABLE, CN19_PULLUP_ENABLE);
temp = mPORTDRead();
/* PORT D and E for motors */
//motor 1
mPORTDSetBits(BIT_4 | BIT_5 | BIT_6 | BIT_7); // Turn on PORTD on startup.
mPORTDSetPinsDigitalOut(BIT_4 | BIT_5 | BIT_6 | BIT_7); // Make PORTD output.
//motor 2
mPORTCSetBits(BIT_1 | BIT_2 | BIT_3 | BIT_4); // Turn on PORTC on startup.
mPORTCSetPinsDigitalOut(BIT_1 | BIT_2 | BIT_3 | BIT_4); // Make PORTC output.
//motor 3 and 4
mPORTESetBits(BIT_0 | BIT_1 | BIT_2 | BIT_3 |
BIT_4 | BIT_5 | BIT_6 | BIT_7); // Turn on PORTE on startup.
mPORTESetPinsDigitalOut(BIT_0 | BIT_1 | BIT_2 | BIT_3 |
BIT_4 | BIT_5 | BIT_6 | BIT_7); // Make PORTE output.
// UART2 to connect to the PC.
// This initialization assumes 36MHz Fpb clock. If it changes,
// you will have to modify baud rate initializer.
UARTConfigure(UART2, UART_ENABLE_PINS_TX_RX_ONLY);
UARTSetFifoMode(UART2, UART_INTERRUPT_ON_TX_NOT_FULL | UART_INTERRUPT_ON_RX_NOT_EMPTY);
UARTSetLineControl(UART2, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1);
UARTSetDataRate(UART2, GetPeripheralClock(), BAUD);
UARTEnable(UART2, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));
// Configure UART2 RX Interrupt
INTEnable(INT_SOURCE_UART_RX(UART2), INT_ENABLED);
INTSetVectorPriority(INT_VECTOR_UART(UART2), INT_PRIORITY_LEVEL_2);
INTSetVectorSubPriority(INT_VECTOR_UART(UART2), INT_SUB_PRIORITY_LEVEL_0);
/* PORTD for LEDs - DEBUGGING */
mPORTDClearBits(BIT_0 | BIT_1 | BIT_2);
mPORTDSetPinsDigitalOut(BIT_0 | BIT_1 | BIT_2);
// Congifure Change/Notice Interrupt Flag
ConfigIntCN(INTERRUPT);
// configure for multi-vectored mode
INTConfigureSystem(INT_SYSTEM_CONFIG_MULT_VECTOR);
// enable interrupts
INTEnableInterrupts();
counterDistanceMeasure=600; //measure ULTRASONICS distance each 60 ms
while (1) {
/***************** Robot MAIN state machine *****************/
unsigned char ret = 0;
switch (Robo_State) {
case 0:
MotorsON = 0;
Robo_State = 0;
InvInitialOrientation(RESET);
TestDog(RESET);
GoToRoom4short(RESET);
BackToStart(RESET);
InitialOrientation(RESET);
GoToCenter(RESET);
GoToRoom4long(RESET);
break;
case 1:
ret = InvInitialOrientation(GO);
if (ret == 1) {
Robo_State = 2;
}
break;
case 2:
ret = TestDog(GO);
if (ret == 1) {
Robo_State = 3; //DOG not found
} else if (ret == 2) {
Robo_State = 4; //DOG found
}
break;
case 3:
ret = GoToRoom4short(GO);
if (ret == 1) {
Robo_State = 0;
}
break;
case 4:
ret = BackToStart(GO);
if (ret == 1) {
Robo_State = 5;
}
break;
case 5:
ret = GoToCenter(GO);
if (ret == 1) {
Robo_State = 6;
}
break;
case 6:
ret = GoToRoom4long(GO);
if (ret == 1) {
Robo_State = 0;
}
break;
}
if (frontDistance < 30 || backDistance < 30 || leftDistance < 30 || rightDistance < 30)
mPORTDSetBits(BIT_0);
else
mPORTDClearBits(BIT_0);
/***************************************************************/
/***************** Motors State Machine ************************/
if (MotorsON) {
/****************************
MOTOR MAP
M1 O-------------O M2 ON EVEN MOTORS, STEPS MUST BE INVERTED
| /\ | i.e. FORWARD IS BACKWARD
| / \ |
| || |
| || |
M3 O-------------O M4
*****************************/
if (M1_counter == 0) {
switch (M1_state) {
case 0: // set 0011
step (0x3 , 1);
if (M1forward)
M1_state = 1;
else
M1_state = 3;
break;
case 1: // set 1001
step (0x9 , 1);
if (M1forward)
M1_state = 2;
else
M1_state = 0;
break;
case 2: // set 1100
step (0xC , 1);
if (M1forward)
M1_state = 3;
else
M1_state = 1;
break;
case 3: // set 0110
default:
step (0x6 , 1);
if (M1forward)
M1_state = 0;
else
M1_state = 2;
break;
}
M1_counter = M1_stepPeriod;
step_counter[0]--;
if (directionNow == countingDirection)
step_counter[1]--;
}
if (M2_counter == 0) {
switch (M2_state) {
case 0: // set 0011
step (0x3 , 2);
if (M2forward)
M2_state = 1;
else
M2_state = 3;
break;
case 1: // set 0110
step (0x6 , 2);
if (M2forward)
M2_state = 2;
else
M2_state = 0;
break;
case 2: // set 1100
step (0xC , 2);
if (M2forward)
M2_state = 3;
else
M2_state = 1;
break;
case 3: // set 1001
default:
step (0x9 , 2);
if (M2forward)
M2_state = 0;
else
M2_state = 2;
break;
}
M2_counter = M2_stepPeriod;
}
if (M3_counter == 0) {
switch (M3_state) {
case 0: // set 0011
step (0x3 , 3);
if (M3forward)
M3_state = 1;
else
M3_state = 3;
break;
case 1: // set 1001
step (0x9 , 3);
if (M3forward)
M3_state = 2;
else
M3_state = 0;
break;
case 2: // set 1100
step (0xC , 3);
if (M3forward)
M3_state = 3;
else
M3_state = 1;
break;
case 3: // set 0110
default:
step (0x6 , 3);
if (M3forward)
M3_state = 0;
else
M3_state = 2;
break;
}
M3_counter = M3_stepPeriod;
}
if (M4_counter == 0) {
switch (M4_state) {
case 0: // set 0011
step (0x3 , 4);
if (M4forward)
M4_state = 1;
else
M4_state = 3;
break;
case 1: // set 0110
step (0x6 , 4);
if (M4forward)
M4_state = 2;
else
M4_state = 0;
break;
case 2: // set 1100
step (0xC , 4);
if (M4forward)
M4_state = 3;
else
M4_state = 1;
break;
case 3: // set 1001
default:
step (0x9 , 4);
if (M4forward)
M4_state = 0;
else
M4_state = 2;
break;
}
M4_counter = M4_stepPeriod;
}
} else {
//motors off
mPORTDSetBits(BIT_4 | BIT_5 | BIT_6 | BIT_7);
mPORTCSetBits(BIT_1 | BIT_2 | BIT_3 | BIT_4);
mPORTESetBits(BIT_0 | BIT_1 | BIT_2 | BIT_3 |
BIT_4 | BIT_5 | BIT_6 | BIT_7);
}
/************************************************************/
/******* TEST CODE, toggles the servos (from 90 deg. to -90 deg.) every 1 s. ********/
/* if (auxcounter == 0) {
servo1_angle = 0;
if (servo2_angle == 90)
servo2_angle = -90;
else
servo2_angle = 90;
auxcounter = 20000; // toggle angle every 2 s.
}
*/
servo1_angle = 0;
servo2_angle = -90;
/*
if (frontDistance > 13 && frontDistance < 17) {
servo2_angle = 90;
}
else
servo2_angle = -90;
*/
/*******************************************************************/
/****************** SERVO CONTROL ******************/
/*
Changing the global servoX_angle at any point in the code will
move the servo to the desired angle.
*/
servo1_counter = (servo1_angle + 90)*(18)/180 + 6; // between 600 and 2400 us
if (servo1_period == 0) {
mPORTASetBits(BIT_2);
servo1_period = SERVOMAXPERIOD; /* 200 * 100us = 20000us period */
}
servo2_counter = (servo2_angle + 90)*(18)/180 + 6; // between 600 and 2400 us
if (servo2_period == 0) {
mPORTASetBits(BIT_3);
servo2_period = SERVOMAXPERIOD; /* 200 * 100us = 20000us period */
}
/*****************************************************/
} /* end of while(1) */
return 0;
}
void hal_uart_interrupt_handler(hal_uart_port port) {
UART_MODULE uart = logic_uart2phy_uart(port);
assert(port >= HAL_UART_PORT_1 && port <= HAL_UART_NUMBER_OF_PORTS );
/* get the txbuffer to send */
struct txbuffer_struct *buffer = get_tx_buffer(port);
/* If the source of interrupt is the TXInterrupt, start
* transmitting the data in output queue. */
if (INTGetFlag(INT_SOURCE_UART_TX(uart))) {
/* Clear interrupt to prevent reentry */
INTClearFlag(INT_SOURCE_UART_TX(uart));
/* if queue is not empty, send tx data to uart while available. */
while (buffer->nbytes > 0) {
if (UARTTransmitterIsReady(uart)) {
UARTSendDataByte(uart, buffer->buffer[buffer->counter++]);
/* decrement buffer count after byte was transmitted */
buffer->nbytes --;
} else {
break;
}
}
/* if queue is empty, disable tx interrupt. */
if (buffer->nbytes <= 0) {
INTEnable(INT_SOURCE_UART_TX(uart), INT_DISABLED);
if(on_data_sent[port]!=NULL)
on_data_sent[port](port);
}
}
/* detect uart rx errors */
if(INTGetFlag(INT_SOURCE_UART_ERROR(uart))){
uint8_t in_byte = 0x00;
hal_uart_error error = HAL_UART_ERR_NONE;
volatile UART_LINE_STATUS lineStatus = UARTGetLineStatus(uart);
/* detect framming error. (break)*/
/* Framing error are only valid if data is available in buffer. */
if(UART_FRAMING_ERROR & lineStatus){
/* trigger an on_data_received_callback */
error = HAL_UART_ERR_FRAMMING;
}
/* detect uart overrun errors. */
if(UART_OVERRUN_ERROR & lineStatus)
{
error = HAL_UART_ERR_OVERRUN;
/* TODO: Not sure what to do if buffer overruns (it means data
* arrives faster than we are able to process. So just
* clear error and continue with our lives as nothing happened.
*/
UARTClearOverrunError(uart);
}
if(UART_PARITY_ERROR & lineStatus){
error = HAL_UART_ERR_PARITY;
}
if(UARTReceivedDataIsAvailable(uart)){
in_byte = UARTGetDataByte(uart);
}
if(on_data_received[port]!=NULL)
on_data_received[port](port,in_byte,error);
/* clear the error flag. */
INTClearFlag(INT_SOURCE_UART_ERROR(uart));
}
/* If receive interrupt was triggered, feed user apps with data. */
if (INTGetFlag(INT_SOURCE_UART_RX(uart))) {
/* Clear interrupt to prevent reentry */
INTClearFlag(INT_SOURCE_UART_RX(uart));
/* Copy the received data into input buffer */
while (UARTReceivedDataIsAvailable(uart)) {
uint8_t c = UARTGetDataByte(uart);
if(on_data_received[port]!=NULL)
on_data_received[port](port, c,HAL_UART_ERR_NONE);
}
}
}
void __ISR(_UART_6_VECTOR, U6_INTERRUPT_PRIORITY) Uart6InterruptHandler(void)
{
UINT8 i
,iMax // Read/write max 8 bytes/interrupt
,data // used in UartFifoWrite/Read functions
;
if ( INTGetFlag ( INT_SOURCE_UART_ERROR(UART6)) )
{
LED_ERROR_ON;
INTClearFlag(INT_SOURCE_UART_ERROR(UART6));
}
// TX interrupt handling
//===========================================================
if ( INTGetEnable ( INT_SOURCE_UART_TX(UART6) ) ) // If TX interrupts enabled
{
if ( INTGetFlag ( INT_SOURCE_UART_TX(UART6) ) ) // If TX interrupt occured
{
if ( UARTTransmitterIsReady(UART6) && !Uart.Var.uartTxFifo[UART6].bufEmpty ) // If TX buffer is ready to receive data and the user's TX buffer is not empty
{
if (Uart.Var.uartTxFifo[UART6].lineBuffer.length < 8) // Write max 8 bytes/interrupt
{
iMax = Uart.Var.uartTxFifo[UART6].lineBuffer.length;
}
else
{
iMax = 8;
}
for (i = 0; i < iMax; i++)
{
UartFifoRead((void *) &Uart.Var.uartTxFifo[UART6], &data); // Copy from user
U6TXREG = data; // Put data in PIC32's TX buffer
}
}
if (Uart.Var.uartTxFifo[UART6].bufEmpty) // If User's TX buffer is empty
{
Uart.DisableTxInterrupts(UART6); // Disable TX interrupts
}
INTClearFlag(INT_SOURCE_UART_TX(UART6)); // Clear the TX interrupt Flag
}
}
//===========================================================
// RX interrupt handling
//===========================================================
if ( INTGetEnable ( INT_SOURCE_UART_RX(UART6) ) ) // If RX interrupts enabled
{
if ( INTGetFlag ( INT_SOURCE_UART_RX(UART6) ) ) // If RX interrupt occured
{
i = 0;
iMax = 8; // Read max 8 bytes/interrupt
while ( UARTReceivedDataIsAvailable(UART6) // While RX data available
&& !Uart.Var.uartRxFifo[UART6].bufFull // and user's RX buffer not full
&& (i < iMax) // and under 8 bytes read
)
{ // while ^
data = UARTGetDataByte(UART6); // Get data for PIC32's RX FIFO buffer and copy it to user (next line)
if ( UartFifoWrite((void *) &Uart.Var.uartRxFifo[UART6], &data) < 0 ) // If copy to user did not work
{
break; // Exit while loop
}
i++;
} // end while
if (!Uart.Var.uartRxFifo[UART6].bufEmpty) // If there is data in the user's RX buffer
{
Uart.Var.oIsRxDataAvailable[UART6] = 1; // Set according flag
}
INTClearFlag (INT_SOURCE_UART_RX(UART6) ); // Clear the RX interrupt Flag
}
}
//===========================================================
}
int32_t main(void)
{
#ifndef PIC32_STARTER_KIT
/*The JTAG is on by default on POR. A PIC32 Starter Kit uses the JTAG, but
for other debug tool use, like ICD 3 and Real ICE, the JTAG should be off
to free up the JTAG I/O */
DDPCONbits.JTAGEN = 0;
#endif
/*Refer to the C32 peripheral library documentation for more
information on the SYTEMConfig function.
This function sets the PB divider, the Flash Wait States, and the DRM
/wait states to the optimum value. It also enables the cacheability for
the K0 segment. It could has side effects of possibly alter the pre-fetch
buffer and cache. It sets the RAM wait states to 0. Other than
the SYS_FREQ, this takes these parameters. The top 3 may be '|'ed
together:
SYS_CFG_WAIT_STATES (configures flash wait states from system clock)
SYS_CFG_PB_BUS (configures the PB bus from the system clock)
SYS_CFG_PCACHE (configures the pCache if used)
SYS_CFG_ALL (configures the flash wait states, PB bus, and pCache)*/
/* TODO Add user clock/system configuration code if appropriate. */
SYSTEMConfig(SYS_FREQ, SYS_CFG_ALL);
/* Initialize I/O and Peripherals for application */
InitApp();
/*Configure Multivector Interrupt Mode. Using Single Vector Mode
is expensive from a timing perspective, so most applications
should probably not use a Single Vector Mode*/
// Configure UART2 RX Interrupt
INTEnable(INT_SOURCE_UART_RX(UART2), INT_ENABLED);
INTSetVectorPriority(INT_VECTOR_UART(UART2), INT_PRIORITY_LEVEL_2);
INTSetVectorSubPriority(INT_VECTOR_UART(UART2), INT_SUB_PRIORITY_LEVEL_0);
// configure for multi-vectored mode
INTConfigureSystem(INT_SYSTEM_CONFIG_MULT_VECTOR);
// enable interrupts
INTEnableInterrupts();
/* TODO <INSERT USER APPLICATION CODE HERE> */
//Open UART2
OpenUART2(UART_EN, UART_BRGH_FOUR|UART_RX_ENABLE | UART_TX_ENABLE, 21);
//Open SPI 1 channel
PORTBbits.RB11 = 1;
OpenSPI1( SPI_MODE8_ON | MASTER_ENABLE_ON | SEC_PRESCAL_1_1 | PRI_PRESCAL_1_1 | FRAME_ENABLE_OFF | CLK_POL_ACTIVE_HIGH | ENABLE_SDO_PIN , SPI_ENABLE );
SPI1BRG=39;
initRadio();
setTXAddress("UNIT2");
setRXAddress(0,"UNIT1");
char temp;
char text[6];
text[0]='H';
text[1]='e';
text[2]='l';
text[3]='l';
text[4]='o';
text[5]='!';
while(1)
{
setTransmitter();
PORTBbits.RB11 = 0;
DelayMs(20);
transmitData(&text[0],6);
printf("Hello world! \r\n");
PORTBbits.RB11 = 1;
DelayMs(20);
}
}
void enableUartISR( UART_MODULE umPortNum )
{
/* Enable Interrupts */
INTEnable( INT_SOURCE_UART_RX( umPortNum ), INT_ENABLED );
INTEnable( INT_SOURCE_UART_TX( umPortNum ), INT_ENABLED );
}
void disableUartISR( UART_MODULE umPortNum )
{
/* Disable Interrupts */
INTEnable( INT_SOURCE_UART_RX( umPortNum ), INT_DISABLED );
INTEnable( INT_SOURCE_UART_TX( umPortNum ), INT_DISABLED );
}
