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);
}
void GPS_Configure(void) {
//send the string to always change the baud
//printf("about to change the baud");
//char *NMEA_String="$PMTK251,115200*1F\r\n\0";
GPS_PutString(MEDIATEK_CHANGE_BAUD);
while (!GPS_IsTransmitEmpty());
//disable the uart and change baud and then re-enable
UARTEnable(UART2, UART_DISABLE_FLAGS(UART_PERIPHERAL | UART_TX | UART_RX));
UARTSetDataRate(UART2, F_PB, 115200);
UARTEnable(UART2, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_TX | UART_RX));
#ifdef DEBUG_VERBOSE
printf("UART at Higher BaudRate\r\n");
#endif
//while(!GPS_IsReceiveEmpty());
while (GPS_GetChar() != '$');
GPS_PutString(MEDIATEK_NMEA);
while (!GPS_IsTransmitEmpty());
while (!GPS_IsReceiveEmpty()) {
GPS_GetChar();
}
while (GPS_GetChar() != '$');
GPS_PutString(MEDIATEK_REFRESH_RATE);
printf("GPS Should be at 115200");
}
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
void SERIAL_Init(void) {
transmitBuffer = (struct CircBuffer*) &outgoingUart; //set up buffer for receive
newCircBuffer(transmitBuffer);
receiveBuffer = (struct CircBuffer*) &incomingUart; //set up buffer for transmit
newCircBuffer(receiveBuffer);
UARTConfigure(UART1, 0x00);
UARTSetDataRate(UART1, F_PB, 115200);
UARTSetFifoMode(UART1, UART_INTERRUPT_ON_RX_NOT_EMPTY | UART_INTERRUPT_ON_TX_BUFFER_EMPTY);
INTSetVectorPriority(INT_UART_1_VECTOR, INT_PRIORITY_LEVEL_4); //set the interrupt priority
//RPC5R = 1;
PPSOutput(1, RPC5, U1TX);
PORTSetPinsDigitalIn(IOPORT_C, BIT_3);
//U1RXRbits.U1RXR = 0b111;
PPSInput(3, U1RX, RPC3);
UARTEnable(UART1, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_TX | UART_RX));
INTEnable(INT_U1RX, INT_ENABLED);
//INTSetFlag(INT_U1RX);
//INTEnable(INT_U1TX, INT_ENABLED);
//PutChar('z');
}
//******************************************************************************
//Public Function Definitions
//******************************************************************************
void FIFOUART1_initialize()
{
UARTConfigure(UART1, UART_ENABLE_PINS_TX_RX_ONLY);
UARTSetLineControl(UART1, UART_DATA_SIZE_8_BITS | //Sets the data transfer size to 8-bits per frame.�
UART_PARITY_NONE | //Disables parity bit generation.�
UART_STOP_BITS_1); //1 stop bit per frame (default).�
UARTSetDataRate(UART1, GetPeripheralClock(), FIFOUART1_BAUD_RATE);
//Interrupt Stuff
INTSetVectorPriority(INT_UART_1_VECTOR, INT_PRIORITY_LEVEL_5);
INTSetVectorSubPriority(INT_UART_1_VECTOR, INT_SUB_PRIORITY_LEVEL_0);
INTClearFlag(INT_U1RX);
INTClearFlag(INT_U1TX);
//configure what triggers UART1 itnerrupts
UARTSetFifoMode(UART1,
UART_INTERRUPT_ON_TX_BUFFER_EMPTY | //TX interrupt will occur when the TX buffer is empty.�
UART_INTERRUPT_ON_RX_NOT_EMPTY); //RX interrupt will occur whenever the RX buffer has any data.�
//Enable UART1 Rx Interrupt
INTEnable(INT_U1RX, INT_ENABLED);
//Enable UART1 Tx Interrupt
//INTEnable(INT_U1TX, INT_ENABLED);
UARTEnable(UART1, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));
}
//******************************************************
// void OpenUart ( const UARTx,long BaudRate)
// Overture d'un port serie
// @param : UARTx : choix du port
// UART1,UART2,UART3,UART4,UART5,UART6
// BaudeRate : Vitesse du port serie
// 1200,2400,4800,9600,19200,38400,57600,115200
//
//******************************************************
void OpenUart ( const UARTx,long BaudRate)
{
UARTConfigure(UARTx, UART_ENABLE_PINS_TX_RX_ONLY);
UARTSetFifoMode(UARTx, UART_INTERRUPT_ON_TX_NOT_FULL | UART_INTERRUPT_ON_RX_NOT_EMPTY);
UARTSetLineControl(UARTx, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1);
UARTSetDataRate(UARTx, GetPeripheralClock(), BAUDERATE);
UARTEnable(UARTx, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));
}
void initUART2(){
UARTConfigure(UART2, UART_ENABLE_PINS_TX_RX_ONLY);//configure uart for rx and tx
UARTSetFifoMode(UART2, UART_INTERRUPT_ON_RX_NOT_EMPTY);//configure for interrupts
UARTSetLineControl(UART2, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1);//set uart line options
UARTSetDataRate(UART2, getPBusClock(), UART_BAUD);//data rate 9600 baud and pbus 10MHz
UARTEnable(UART2, UART_PERIPHERAL | UART_RX | UART_TX | UART_ENABLE); //enable the uart for tx rx
while(!UARTTransmitterIsReady(UART2));
}
void setupSerial(void) {
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, PBCLK, BAUDRATE);
UARTEnable(UART2, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));
SendDataBuffer("\n\r***Radiometer Serial port configured***\n\r", sizeof("\n\r***Radiometer Serial port configured***\n\r"));
return;
}
//#=================================================================================================
// COMM1
//#=================================================================================================
//#-------------------------------------------------------------------------------------------------
void COMM1_Init( void )
{
_TRISB13 = 1;
U1RXRbits.U1RXR = 3; //
RPB15Rbits.RPB15R = 1; //
U1BRG = (SYS_FREQ/17/(115200)); //
UARTSetDataRate(UART1, SYS_FREQ, 115200);
U1MODE = UART_EN;
U1STA = (UART_RX_ENABLE | UART_TX_ENABLE);
}
void initUART(void)
{
PORTFbits.RF4 = 1; //U2RX
PORTFbits.RF5 = 0; //U2TX
UARTConfigure(UART2, UART_ENABLE_PINS_TX_RX_ONLY);
UARTSetFifoMode(UART2, 0);
UARTSetLineControl(UART2, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1);
UARTSetDataRate(UART2, SYS_CLOCK, 115200);
UARTEnable(UART2, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));
}
//-----------------------------------------------==================================================
// COMM2
//#-------------------------------------------------------------------------------------------------
void COMM2_Init( void )
{
_TRISB5 = 1;
U2RXRbits.U2RXR = 1; //
RPB10Rbits.RPB10R = 2; //
U2BRG = (SYS_FREQ/17/(9600));
UARTSetDataRate(UART2, SYS_FREQ, 9600);
U2MODE = UART_EN;
U2STA = (UART_RX_ENABLE | UART_TX_ENABLE);
}
void setup(bool use_interrupt = false,
INT_PRIORITY int_priority = INT_PRIORITY_DISABLED,
UART_CONFIGURATION uart_config = (UART_CONFIGURATION)UART_ENABLE_PINS_TX_RX_ONLY,
UART_FIFO_MODE interrupt_modes = (UART_FIFO_MODE)0,
UART_LINE_CONTROL_MODE line_control_modes = (UART_LINE_CONTROL_MODE)(UART_DATA_SIZE_8_BITS|UART_PARITY_NONE|UART_STOP_BITS_1),
UART_ENABLE_MODE enable_modes = (UART_ENABLE_MODE)(UART_PERIPHERAL|UART_RX|UART_TX))
{
UARTConfigure(module, uart_config);
UARTSetFifoMode(module, interrupt_modes);
UARTSetLineControl(module, line_control_modes);
UARTSetDataRate(module, param::pbus_hz(), baud);
UARTEnable(module, (UART_ENABLE_MODE) UART_ENABLE_FLAGS(enable_modes));
if (use_interrupt) {
INT_VECTOR int_vect;
INT_SOURCE int_src;
switch(module) {
case UART1:
int_vect = INT_UART_1_VECTOR;
int_src = INT_U1RX;
break;
case UART2:
int_vect = INT_UART_2_VECTOR;
int_src = INT_U2RX;
break;
case UART3:
int_vect = INT_UART_3_VECTOR;
int_src = INT_U3RX;
break;
case UART4:
int_vect = INT_UART_4_VECTOR;
int_src = INT_U4RX;
break;
case UART5:
int_vect = INT_UART_5_VECTOR;
int_src = INT_U5RX;
break;
case UART6:
int_vect = INT_UART_6_VECTOR;
int_src = INT_U6RX;
break;
case UART_NUMBER_OF_MODULES:
default:
return; // WTF
}
INTEnable(int_src, INT_ENABLED);
INTSetVectorPriority(int_vect, int_priority);
INTSetVectorSubPriority(int_vect, INT_SUB_PRIORITY_LEVEL_0);
}
}
void UART_init(uint8_t id, uint32_t baudRate){
//will need buffers for both the UARTS
if(id == UART1_ID){
transmitBufferUart1 = (struct CircBuffer*) &outgoingUart1; //set up buffer for receive
newCircBuffer(transmitBufferUart1);
receiveBufferUart1 = (struct CircBuffer*) &incomingUart1; //set up buffer for transmit
newCircBuffer(receiveBufferUart1);
UARTConfigure(UART1, 0x00);
UARTSetDataRate(UART1, F_PB, baudRate);
UARTSetFifoMode(UART1, UART_INTERRUPT_ON_RX_NOT_EMPTY);
mU1SetIntPriority(4); //set the interrupt priority
UARTEnable(UART1, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_TX | UART_RX));
mU1RXIntEnable(1);
mU1TXIntEnable(1);
}else if(id == UART2_ID){
transmitBufferUart2 = (struct CircBuffer*) &outgoingUart2; //set up buffer for receive
newCircBuffer(transmitBufferUart2);
receiveBufferUart2 = (struct CircBuffer*) &incomingUart2; //set up buffer for transmit
newCircBuffer(receiveBufferUart2);
UARTConfigure(UART2, 0x00);
UARTSetDataRate(UART2, F_PB, baudRate);
UARTSetFifoMode(UART2, UART_INTERRUPT_ON_RX_NOT_EMPTY);
mU2SetIntPriority(4); //set the interrupt priority
UARTEnable(UART2, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_TX | UART_RX));
mU2RXIntEnable(1);
mU2TXIntEnable(1);
}
}
// *****************************************************************************
// 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));
}
// Initialize the serial port
// Note: the NU32v2 is hard wired to use UART3 (= UART2A)
void initSerialNU32v2() {
int pbClk;
// Configure the system performance
pbClk = SYSTEMConfigPerformance(SYS_FREQ);
UARTConfigure(UART3, UART_ENABLE_PINS_TX_RX_ONLY);
UARTSetFifoMode(UART3, UART_INTERRUPT_ON_TX_DONE | UART_INTERRUPT_ON_RX_NOT_EMPTY);
UARTSetLineControl(UART3, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1);
UARTSetDataRate(UART3, pbClk, DESIRED_BAUDRATE_NU32);
UARTEnable(UART3, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));
// Configure UART3 RX Interrupt
INTEnable(INT_U3RX, INT_ENABLED);
INTSetVectorPriority(INT_UART_3_VECTOR, INT_PRIORITY_LEVEL_2);
INTSetVectorSubPriority(INT_UART_3_VECTOR, INT_SUB_PRIORITY_LEVEL_0);
}
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);
}
int main(void)
{
// 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(SYS_FREQ, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
// Auto-configure the PIC32 for optimum performance at the specified operating frequency.
SYSTEMConfigPerformance(SYS_FREQ);
// osc source, PLL multipler value, PLL postscaler , RC divisor
OSCConfig(OSC_POSC_PLL, OSC_PLL_MULT_20, OSC_PLL_POST_1, OSC_FRC_POST_1);
// Configure the PB bus to run at 1/4 the CPU frequency
OSCSetPBDIV(OSC_PB_DIV_4);
// Enable multi-vector interrupts
INTEnableSystemMultiVectoredInt();
INTEnableInterrupts();
// Set up the UART peripheral so we can send serial data.
UARTConfigure(UART_USED, UART_ENABLE_PINS_TX_RX_ONLY);
UARTSetFifoMode(UART_USED, UART_INTERRUPT_ON_TX_NOT_FULL | UART_INTERRUPT_ON_RX_NOT_EMPTY);
UARTSetLineControl(UART_USED, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1);
UARTSetDataRate(UART_USED, F_PB, UART_BAUD_RATE);
UARTEnable(UART_USED, UART_ENABLE | UART_TX);
// And configure printf/scanf to use the correct UART.
if (UART_USED == UART1) {
__XC_UART = 1;
}
/***************************************************************************************************
* Your code goes in between this comment and the following one with asterisks.
**************************************************************************************************/
/***************************************************************************************************
* Your code goes in between this comment and the preceding one with asterisks.
**************************************************************************************************/
// Returning from main() is bad form in embedded environments. So we sit and spin.
while (1);
}
void NU32_EnableUART2Interrupt(void) {
// turn off the module to change the settings
UARTEnable(UART2, UART_ENABLE_FLAGS(UART_DISABLE));
// Configure UART1 RX Interrupt
// UARTConfigure(UART2, UART_ENABLE_PINS_CTS_RTS );
UARTSetFifoMode(UART2, UART_INTERRUPT_ON_TX_DONE | UART_INTERRUPT_ON_RX_NOT_EMPTY);
UARTSetLineControl(UART2, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1);
UARTSetDataRate(UART2, SYSCLK, 115200);
UARTEnable(UART2, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));
INTEnable(INT_U2RX, INT_ENABLED);
INTSetVectorPriority(INT_UART_2_VECTOR, INT_PRIORITY_LEVEL_2);
INTSetVectorSubPriority(INT_UART_2_VECTOR, INT_SUB_PRIORITY_LEVEL_0);
}
/****************************************************************************
Function:
void SelfTest()
Description:
This routine performs a self test of the hardware.
Precondition:
None
Parameters:
None - None
Returns:
None
Remarks:
None
***************************************************************************/
static void SelfTest(void)
{
char value = 0;
char* buf[32];
Exosite_Init("microchip","dv102412",IF_WIFI, 1);
// Configure Sensor Serial Port
UARTConfigure(SENSOR_UART, UART_ENABLE_PINS_TX_RX_ONLY);
UARTSetFifoMode(SENSOR_UART, UART_INTERRUPT_ON_TX_NOT_FULL | UART_INTERRUPT_ON_RX_NOT_EMPTY);
UARTSetLineControl(SENSOR_UART, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1);
UARTSetDataRate(SENSOR_UART, GetPeripheralClock(), 9600);
UARTEnable(SENSOR_UART, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));
// Verify MRF24WB/G0MA MAC Address
if(AppConfig.MyMACAddr.v[0] == 0x00 && AppConfig.MyMACAddr.v[1] == 0x1E)
{
//********************************************************************
// Prints a label using ESC/P commands to a Brother PT-9800PCN printer
//********************************************************************
// Send ESC/P Commands to setup printer
UARTTxBuffer("\033ia\000\033@\033X\002",9); // ESC i a 0 = Put Printer in ESC/P Mode
// ESC @ = Reset Printer to Default settings
// ESC X 2 = Specify Character Size
// Send the Info to Print for the MAC Address label
UARTTxBuffer("MRF24WB0MA\r",11);
sprintf((char *)buf,"MAC: %02X%02X%02X%02X%02X%02X",AppConfig.MyMACAddr.v[0],AppConfig.MyMACAddr.v[1],AppConfig.MyMACAddr.v[2],AppConfig.MyMACAddr.v[3],AppConfig.MyMACAddr.v[4], AppConfig.MyMACAddr.v[5]);
UARTTxBuffer((char *)buf, strlen((const char *)buf));
// Print the label
UARTTxBuffer("\f",1);
// Toggle LED's
while(1)
{
LED0_IO = value;
LED1_IO = value >> 1;
LED2_IO = value >> 2;
DelayMs(400);
if(value == 8)
value = 0;
else
value++;
}
}
void SERIAL_Init(void)
{
transmitBuffer = (struct CircBuffer*) &outgoingUart; //set up buffer for receive
newCircBuffer(transmitBuffer);
receiveBuffer = (struct CircBuffer*) &incomingUart; //set up buffer for transmit
newCircBuffer(receiveBuffer);
UARTConfigure(UART1, 0x00);
UARTSetDataRate(UART1, F_PB, 115200);
UARTSetFifoMode(UART1, UART_INTERRUPT_ON_RX_NOT_EMPTY | UART_INTERRUPT_ON_RX_NOT_EMPTY);
INTSetVectorPriority(INT_UART_1_VECTOR, INT_PRIORITY_LEVEL_4); //set the interrupt priority
UARTEnable(UART1, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_TX | UART_RX));
INTEnable(INT_U1RX, INT_ENABLED);
INTEnable(INT_U1TX, INT_ENABLED);
}
//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;
}
/*
1. Select the desired basic configuration from the UART_CONFIGURATION Enumeration and set the selected options using the UARTConfigure Function.
2. Set the desired FIFO trigger levels for receive and transmit from the UART_FIFO_MODE Enumeration and set the selected options using the UARTSetFifoMode Function.
3. Set the line control configuration from the UART_LINE_CONTROL_MODE Enumeration and set the selected options using the UARTSetLineControl Function.
4. Set the desired data rate using UARTSetDataRate Function.
5. Enable the mode for operation using UART_ENABLE_MODE Enumeration and set the selected options using the UARTEnable Function.
*/
UINT UARTiConfigure(UART_MODULE iUART, UINT32 uiDataRate)
{
UINT uiActualDataRate;
//step 1 - set the configuration, not available to be set on UART5
if(iUART != UART5) UARTConfigure(iUART, UART_ENABLE_PINS_TX_RX_ONLY);
//step 2 - set the fifo interrupt settings
// UARTSetFifoMode(iUART, UART_INTERRUPT_ON_TX_NOT_FULL | UART_INTERRUPT_ON_RX_NOT_EMPTY);
UARTSetFifoMode(iUART, UART_INTERRUPT_ON_RX_NOT_EMPTY);
//step 3 - set the data mode
UARTSetLineControl(iUART, UART_DATA_SIZE_8_BITS|UART_PARITY_NONE|UART_STOP_BITS_1);
//step 4 - set the baud (data) rate
uiActualDataRate = UARTSetDataRate(iUART, GetPeripheralClock(), uiDataRate);
//step 5 - enable uart
UARTEnable(iUART, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));
return(uiActualDataRate);
}
/*******************************************************************************
* FUNCTION: vUART2Init
*
* PARAMETERS:
* ~ void
*
* RETURN:
* ~ void
*
* DESCRIPTIONS:
* Initialize the UART2 module.
* UART 2 is used by bluetooth module.
*
*******************************************************************************/
void vUART2Init(void)
{
// Configure UART 2.
UARTConfigure(UART2, UART_ENABLE_HIGH_SPEED | 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(), BT2_BAUDRATE);
UARTEnable(UART2, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));
// Configure the interrupt.
INTSetVectorPriority(INT_UART_2_VECTOR, INT_PRIORITY_LEVEL_7);
INTClearFlag(INT_U2TX);
INTClearFlag(INT_U2RX);
INTClearFlag(INT_U2E);
INTEnable(INT_U2RX, INT_ENABLED);
INTEnable(INT_U2E, INT_ENABLED);
}
void GPS_Init(void) {
GtransmitBuffer = (struct CircBuffer*) &GoutgoingUart; //set up buffer for receive
GPSnewCircBuffer(GtransmitBuffer);
GreceiveBuffer = (struct CircBuffer*) &GincomingUart; //set up buffer for transmit
GPSnewCircBuffer(GreceiveBuffer);
UARTConfigure(UART2, 0x00);
UARTSetDataRate(UART2, F_PB, 38400);
UARTSetFifoMode(UART2, UART_INTERRUPT_ON_RX_NOT_EMPTY | UART_INTERRUPT_ON_RX_NOT_EMPTY);
mU2SetIntPriority(4); //set the interrupt priority
UARTEnable(UART2, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_TX | UART_RX));
mU2RXIntEnable(1);
mU2TXIntEnable(1);
GPS_Configure();
}
int main(void)
{
UINT8 buf[1024];
UARTConfigure(UART_MODULE_ID, UART_ENABLE_PINS_TX_RX_ONLY);
UARTSetFifoMode(UART_MODULE_ID, UART_INTERRUPT_ON_TX_NOT_FULL | UART_INTERRUPT_ON_RX_NOT_EMPTY);
UARTSetLineControl(UART_MODULE_ID, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1);
UARTSetDataRate(UART_MODULE_ID, GetPeripheralClock(), 9600);
UARTEnable(UART_MODULE_ID, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));
//Receive and echo back mode only
while(1)
{
UINT32 rx_size;
rx_size = GetDataBuffer(buf, 1024);
SendDataBuffer(buf, rx_size);
}
return -1;
}
void initUart( UART_MODULE umPortNum, uint32_t ui32WantedBaud )
{
/* UART Configuration */
UARTConfigure( umPortNum, UART_ENABLE_PINS_TX_RX_ONLY );
/* UART FIFO Mode */
UARTSetFifoMode( umPortNum, UART_INTERRUPT_ON_TX_NOT_FULL | UART_INTERRUPT_ON_RX_NOT_EMPTY );
/* UART Line Control */
UARTSetLineControl( umPortNum, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1 );
/* Set the Baud Rate of the UART */
UARTSetDataRate( umPortNum, (uint32_t)configPERIPHERAL_CLOCK_HZ, ui32WantedBaud );
/* Enable the UART for Transmit Only*/
UARTEnable( umPortNum, UART_ENABLE_FLAGS( UART_PERIPHERAL | UART_TX | UART_RX ) );
/* Set UART INterrupt Vector Priority*/
INTSetVectorPriority( INT_VECTOR_UART( UART1 ), INT_PRIORITY_LEVEL_2 );
disableUartISR( UART1 );
}
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();
}
void initSerialNU32v2() {
int pbClk;
// Configure the system performance
pbClk = SYSTEMConfigPerformance(SYS_FREQ);
UARTConfigure(UART3, UART_ENABLE_PINS_TX_RX_ONLY);
//UARTSetFifoMode(UART3, UART_INTERRUPT_ON_TX_DONE | UART_INTERRUPT_ON_RX_NOT_EMPTY);
UARTSetLineControl(UART3, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1);
UARTSetDataRate(UART3, pbClk, DESIRED_BAUDRATE_NU32);
UARTEnable(UART3, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));
// unbuffered i/o works well for printf and gets, but not for scanf
//setbuf(stdin, NULL); //no input buffer (for scanf)
//setbuf(stdout, NULL); //no output buffer (for printf)
// in the future want to set both to line buffering.
// This would make the UART a character stream, a
// different set up would be required for byte streams.
// Configure UART3 RX Interrupt
//INTEnable(INT_U3RX, INT_ENABLED);
//INTSetVectorPriority(INT_UART_3_VECTOR, INT_PRIORITY_LEVEL_2);
//INTSetVectorSubPriority(INT_UART_3_VECTOR, INT_SUB_PRIORITY_LEVEL_0);
}
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;
}
