Пример #1
0
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);
}
Пример #2
0
//******************************************************************************
//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));

}
Пример #3
0
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
Пример #4
0
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');
}
Пример #5
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");
    
   
}
Пример #6
0
//******************************************************
// 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));
}
Пример #7
0
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));
}
Пример #8
0
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;
}
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));
}
Пример #10
0
		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);
			}
		}
Пример #11
0
Файл: Uart.c Проект: sdajani/sdp
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);
    }
}
Пример #12
0
// *****************************************************************************
// 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));

}
Пример #13
0
// 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);
}
Пример #14
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++;

        }
    }
Пример #15
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);
}
Пример #16
0
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);
}
Пример #17
0
//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;
}
Пример #18
0
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);
}
Пример #19
0
Файл: gps.c Проект: mdunne/ANIMA
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();
}
/*

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);
}
Пример #21
0
/*******************************************************************************
 * 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);
}
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;
}
Пример #23
0
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 );
}
Пример #24
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();
}
Пример #25
0
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;
}
Пример #27
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();


    // 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;
    }
    extern void T1Setup();
    extern void T1Stop();
    extern void T1Start();

    // Enable LED outputs 0-7 by setting TRISE register
    TRISECLR = 0x00FF;
    // Initialize the PORTE to 0
    PORTECLR = 0x00FF;
    // Set the lowest bit
    PORTESET = 1;

    OledInit();
    OledDisplayOn();
    printf("Starting Timer Set-up\n");
    T1Setup();

    int stopped = 0, reset = 0;

    extern volatile int milliseconds;
    int temp = 0;
    int count = 0;
    printTime(0, 0);
    while(1) {
        // Display the least significant part of the time for debugging
       int x = PORTD & 0xfff;
       if(x == 272) {
           if(stopped) {
               stopped = 0;
               T1Start();
           }
           if(reset)
               reset = 0;
        if(milliseconds - temp >= 1000) {
            count++;
            int minutes = count/60;
            int seconds = count % 60;
            printTime(minutes,seconds);
            temp = milliseconds;
        }
       }
       else if(x == 784 || x == 528) {
           if(reset != 1) {
             printTime(0, 0);
             T1Stop();
             stopped = 1;
             reset = 1;
             count = 0;
          }

       }
       else {
           stopped = 1;
           continue;
       }

    }

}
Пример #28
0
int main(void)
{
#if defined( DUMP_DIAGNOSTICS_VIA_UART )
    char   ButtonMeasString[133];
# if defined( UART_DUMP_RAW_COUNTS ) || \
    defined( UART_DUMP_ALL_COUNTS )
    UINT16 iHF_Read;
# endif//defined( UART_DUMP_RAW_COUNTS )...
#endif//defined( DUMP_DIAGNOSTICS_VIA_UART )

    UINT16 CurrentButtonStatus, LastButtonStatus, CurrentButtonAsserts = 0,
           CurrentButtonMeasurements[MAX_ADC_CHANNELS],
           CurrentAveragedMeasurements[MAX_ADC_CHANNELS];
    UINT16 CurrentWeights[MAX_ADC_CHANNELS];

    CFGCONbits.JTAGEN = 0; // Disable JTAG

    // Initalize global interrupt enable
    INTEnableSystemMultiVectoredInt();

    // Configure the device for maximum performance
    // 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.
    SYSTEMConfig(SYS_FREQ, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);

#if defined( DUMP_DIAGNOSTICS_VIA_UART )
    // Setup UART2 for transmission of button data.
    // Taken from C:\Program Files\Microchip\mplabc32\v1.12\examples\plib_examples\uart\uart_basic
    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(), 115200 );
    UARTEnable(UART2, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_TX ));

    // RPS setup to bring U1TX out on pin 33 (RB4) to Switch 2 on board
    PPSOutput(4,RPC4,U2TX);
#endif//defined( DUMP_DIAGNOSTICS_VIA_UART )

    // Setup data structures for using Direct Keys
    mTouchCapApp_MatrixKeys_Create();

    /* This is mandatory function call to initilize physical layer.
       Call this function before any application layer code. */
    mTouchCapAPI_Init();

    // Initial startup demo of board LEDs.
    PORTB = PORTB_ROW_ALL | PORTB_COL_ALL; //Turn on all LEDs
    PORTC = PORTC_ROW_ALL | PORTC_COL_ALL;
    DelayMs(1000);
    mTouchCapLED_PowerUpSequence(); // turn on each LED in sliding motion
    PORTB = PORTB_ROW_ALL | PORTB_COL_ALL; //Turn on all LEDs
    PORTC = PORTC_ROW_ALL | PORTC_COL_ALL;
    DelayMs(1000);
    PORTB = PORTB_ROW_NIL | PORTB_COL_NIL; //Turn off all LEDs
    PORTC = PORTC_ROW_NIL | PORTC_COL_NIL;

    // Start button measurements
    Set_ScanTimer_IE_Bit_State(ENABLE);  //Enable interrupt
    Set_ScanTimer_ON_Bit_State(ENABLE);  //Run timer

    // Setup for detection/interpretation
    LastButtonStatus = 0;

    while(1)
    {
        if(EmTouchDataReady == 1)  //This flag is set by Timer ISR when all channels have been read
        {
            //  Calculate new button values and return the measurement updates
            mTouchCapPhy_UpdateData(CurrentButtonMeasurements,
                                    CurrentAveragedMeasurements,
                                    CurrentWeights,
                                    TRUE, FILTER_METHOD_USECHANNEL);

            // Update button and LED status and return button status for use with mTouch GUI on PC
            CurrentButtonStatus = mTouchCapApp_MatrixKeys_Demo();

            // Check for button asserts: If buttons were pressed before, but none pressed now
            if ( LastButtonStatus > 0 && CurrentButtonStatus == 0 )
            {
                CurrentButtonAsserts = LastButtonStatus; //Buttons have fired.
            }
            else
            { // Commented out to provide memory of last button asserted.
              //ButtonAsserts = 0;
            }

            /*
               Determining Channel Load Order:

               Button Layout:

                     Column: Col 1  Col 2  Col 3  Col 4
                              AN0    AN1   AN4    AN5
                Row 1: AN8   Btn 0  Btn 1  Btn 2  Btn 3

                Row 2: AN7   Btn 4  Btn 5  Btn 6  Btn 7

                Row 3: AN6   Btn 8  Btn 9  Btn10  Btn11

               Resulting load Order
                (AN8,AN0), (AN8,AN1), (AN8,AN4), (AN8,AN5),
                (AN7,AN0), (AN7,AN1), (AN7,AN4), (AN7,AN5),
                (AN6,AN0), (AN6,AN1), (AN6,AN4), (AN6,AN5),

               Removing channels already loaded:
                (AN8,AN0), (---,AN1), (---,AN4), (---,AN5),
                (AN7,---), (---,---), (---,---), (---,---),
                (AN6,---), (---,---), (---,---), (---,---),

               So the channels are loaded into memory in this order:
                Channel Load:  #0,   #1,   #2,   #3,   #4,   #5,  #6
                ADC Channel:  AN8,  AN0,  AN1,  AN4,  AN5, AN13, AN12
                Button Func: Row1, Col1, Col2, Col3, Col4, Row2, Row3

               Sorting to output rows in order followed by columns:
                Channel Load:  #0,   #5,   #6,   #1,   #2,   #3,   #4,
                Button Func: Row1, Row2, Row3, Col1, Col2, Col3, Col4,

               This order is used below to output measurements to the mTouch GUI
               or to a hyperterminal for later analysis.
             */

#          if defined( UART_DUMP_RAW_COUNTS )
            for ( iHF_Read = 0; iHF_Read <   NUM_HF_READS; iHF_Read++ )
#          elif defined( UART_DUMP_ALL_COUNTS )
            for ( iHF_Read = 0; iHF_Read < 3*NUM_HF_READS; iHF_Read++ )
#          endif
#          if defined( UART_DUMP_RAW_COUNTS ) || defined( UART_DUMP_ALL_COUNTS )
            {
                sprintf(ButtonMeasString,
                        "%05d,%05d,%05d,"
                        "%05d,%05d,%05d,%05d,"
                        "%05d,%05d,%05d,%05d,"
                        "%05d,%05d,%05d,%05d,"
                        "%05d\r\n",
                        CurrentButtonStatus,CurrentButtonAsserts,
                        CurRawData[iHF_Read][0],CurRawData[iHF_Read][5],CurRawData[iHF_Read][6], 0,
                        CurRawData[iHF_Read][1],CurRawData[iHF_Read][2],CurRawData[iHF_Read][3],CurRawData[iHF_Read][4],
                        0,0,0,0,
                        0,0,0,0,
                        iHF_Read+1);
                SendDataBuffer(ButtonMeasString, strlen(ButtonMeasString) );
            }
#          endif

#if       defined( DUMP_DIAGNOSTICS_VIA_UART )
            // Format report string
            sprintf(ButtonMeasString,
                    "%05d,%05d,%05d,"
                    "%05d,%05d,%05d,%05d,"
                    "%05d,%05d,%05d,%05d\r\n",
                    CurrentButtonStatus, CurrentButtonAsserts, 0, // Zero for slider value
                    CurrentButtonMeasurements[0], //Row 1: AN14: Load #0
                    CurrentButtonMeasurements[5], //Row 2: AN13: Load #5
                    CurrentButtonMeasurements[6], //Row 3: AN12: Load #6
                                               0, //Placeholder for unused row
                    CurrentButtonMeasurements[1], //Col 1: AN8:  Load #1
                    CurrentButtonMeasurements[2], //Col 2: AN9:  Load #2
                    CurrentButtonMeasurements[3], //Col 3: AN10: Load #3
                    CurrentButtonMeasurements[4]);//Col 4: AN11: Load #4

            // Send report string back to mTouch GUI via UART #2
            SendDataBuffer(ButtonMeasString, strlen(ButtonMeasString) );
#         endif//defined( DUMP_DIAGNOSTICS_VIA_UART )

            LastButtonStatus = CurrentButtonStatus; //Remember button status

            EmTouchDataReady = 0;                  //clear flag
            Set_ScanTimer_IE_Bit_State(ENABLE);    //Enable interrupt
            Set_ScanTimer_ON_Bit_State(ENABLE);    //Run timer

        } // end if(EmTouchDataReady)
    } //end while (1)
}  // end main()
Пример #29
0
int main(void)
{
    WDTCTL = WDTPW + WDTHOLD; // Stop WDT
    BCSCTL1 = CALBC1_16MHZ; // Set DCO to 1MHz
    DCOCTL = CALDCO_16MHZ; // Set DCO to 1MHz
    
    UARTConfigure();
    
    P2DIR |= PWRLED;               // Set P2.4 as output
    P2OUT |= PWRLED;
    //P2OUT &= ~PWRLED;
    
    P1SEL &= ~ PROX;
    P1SEL2 &= ~ PROX;
    P1DIR &= ~ PROX;  // Set switch pin as an input
    P1OUT |= PROX;    // Set pull up resistor on for button
    P1REN |= PROX;    // Enable pullup or pulldown resistors
    P1IES &= ~PROX;    // Enable Interrupt to trigger on the rising edge
    P1IFG &= ~PROX;   // Clear the interrupt flag for the button
    
    
  /* Configure timer A1 as a pulse width modulator */
    TA1CCR0 = 420;             // Set maximum count value to determine PWM Frequency = SMCLK/TACCR0 (1MHz/1000 = 1kHz)
    TA1CCR1 = 0;             // Initialise counter compare value 1 to control Duty Cycle = TACCR1/TACCR0 (500/1000 = 50%)
    TA1CCR2 = 0;             // Initialise counter compare value 1 to control Duty Cycle = TACCR1/TACCR0 (500/1000 = 50%)
    
    TA1CCTL2 = OUTMOD_7;          // Set output to on when counter resets and off when counter equals TACCR1. Normal PWM.
    TA1CCTL1 = OUTMOD_7;          // Set output to on when counter resets and off when counter equals TACCR1. Normal PWM.
    TA1CTL = TASSEL_2 + MC_1;     // Use the SMCLK to clock the counter and set to count up mode
    
    P2DIR |= RIGHTMOTOR;               // Set P2.4 as output
    P2SEL |= RIGHTMOTOR;               // Select output P2.4 to be TA1.2
    P2SEL2 &= ~RIGHTMOTOR;             // Select output P2.4 to be TA1.2
    
    P2DIR |= LEFTMOTOR;               // Set P2.1 as output
    P2SEL |= LEFTMOTOR;               // Select output P2.1 to be TA1.1
    P2SEL2 &= ~LEFTMOTOR;             // Select output P2.1 to be TA1.1
    
    /* Configure timer A0 as a pulse width modulator */
    TA0CCR0 = 422;             // Set maximum count value to determine PWM Frequency = SMCLK/TACCR0 (1MHz/1000 = 1kHz)
    TA0CCR1 = 5;             // Initialise counter compare value 1 to control Duty Cycle = TACCR1/TACCR0 (500/1000 = 50%)
    
    TA0CCTL1 = OUTMOD_7;          // Set output to on when counter resets and off when counter equals TACCR1. Normal PWM.
    TA0CTL = TASSEL_2 | MC_1 | TAIE;     // Use the SMCLK to clock the counter and set to count up mode
    P1IE = PROX;     // Enable interrupts on port 1 for the proximaty sensor
    
    //TA0CCTL0 = CM_1 | CCIS_0 | SCS | CAP | CCIE ;    // Raising Edge + CCI0A + Sync + Capture Mode + Interrupt enable
     //P1SEL |= BIT5; //set this bit as Input Capture (TA0.CCI0A)
    
    P1DIR |= IRLED;               // Set P1.6 as output
    P1SEL |= IRLED;               // Select output P1.6 to be TA0.1
    P1SEL2 &= ~IRLED;             // Select output P1.6 to be TA0.1
    
    WDTCTL = WDT_MDLY_8;        // Start and set watchdog timer (WDT) to trigger every 0ms
    //IFG1 &= ~WDTIFG;                // Clear the interrupt flag for the WDT
    IE1 |= WDTIE;                   // enable WDT interrupt

    
    __bis_SR_register(CPUOFF + GIE); // LPM0 with interrupts enabled
    
}
Пример #30
0
/**
 * @fn void InitSystem(void)
 *
 * @brief This function initializes the microcontroller peripherals needed, the 
 *        application and the protocol.
 */
void InitSystem(void)
{
  // Initialize microcontroller peripherals and application.

  // Disable all interrupts while setting up microcontroller.
  __BSP_DISABLE_INTERRUPT();

  // Halt the watchdog.
  WatchdogHold();                                                               // Stop the watchdog timer
 
  Nodes[0].ID = CreateRandomAddress();                                          // Generate a random address.  This must be done
                                                                                // before the clocks and ADC are initialized.
  // Setup board clock system.
  BoardClockSystemInit();                                                       // Intialize the system clocks
  SetOFIEBit(0);                                                                // Disable Osc Fault interrupt
  SetOFIFGBit(0);                                                               // Clear Osc Fault interrupt flag

  FCTL2 = FWKEY | FSSEL_1 | 19;
  SetMyNodeID(0);                                                               // Set node ID. The Flash block requires the clock
                                                                                // to be configured prior to calling this function.
  // Setup timers.
  TimerConfigure(__BSP_TIMER1);                                                 // Initialize Timer1
  AttachEvent(__BSP_TIMER1_CCR0_EVENT_HANDLE, Timer1CCREventHandler);
  AttachEvent(__BSP_TIMER1_CCR1_EVENT_HANDLE, Timer1CCREventHandler);
  TimerConfigure(__BSP_TIMER2);                                                 // Initialize Timer2
  AttachEvent(__BSP_TIMER2_CCR0_EVENT_HANDLE, Timer2CCREventHandler);
  TimerSetCCR(__BSP_TIMER2, __BSP_TIMER2_CCR0, __BSP_CONFIG_SWTIMER1_SOURCE_DIV);

  // Setup software timers.
  SoftwareTimerConfigure();                                                     // Initialize Software Timer
  SoftwareTimerSetInterval(__BSP_SWTIMER[0], 100);
  SoftwareTimerEnable(__BSP_SWTIMER[0]);
  AttachEvent(__BSP_SWTIMER[0].event, SWTimer0EventHandler);
//  AttachEvent(__BSP_SWTIMER[1].event, SWTimer1EventHandler);                                   

  RadioConfigure(&__BSP_RADIO1_CONNECTION);                                     // Initialize the Radio Communication module

  // Setup UART.
  UARTConfigure(__BSP_UART1);                                                   // Initialize the UART Communication module
  AttachEvent(__BSP_UART1_RX_EVENT_HANDLE, UARTRXEventHandler);                 // Attach UART RX event handler

  // Setup LEDs.
  LEDConfigure(__BSP_LEDRED1);                                                  // Initialize the Red LED
  LEDConfigure(__BSP_LEDGREEN1);                                                // Initialize the Green LED

  // Setup push button.
  PushButtonConfigure(__BSP_PUSHBUTTON1);                                       // Initialize push button.
  AttachEvent(__BSP_PUSHBUTTON1_EVENT_HANDLE, PushButton1EventHandler);
  
  AttachEvent(__BSP_PORT1_EVENT_HANDLE, PortEventHandler);
  AttachEvent(__BSP_PORT2_EVENT_HANDLE, PortEventHandler);

  // Setup ADC.
  ADCChannelConfigure(__BSP_ADC1, __BSP_ADC1_CHAN9);                            // Initialize ADC channel.
  ADCReferenceOn(__BSP_ADC1);
  ADCEnableInterrupt(__BSP_ADC1);
  ADCOn(__BSP_ADC1);
  ADCEnableConversion(__BSP_ADC1);
  AttachEvent(__BSP_ADC1_EVENT_HANDLE, ADCEventHandler);
  
  // Setup Application.
  InitApplication(Nodes[0].ID);                                                 // Initialize the Application (application state of the module, supporting protocol)

  // Start timers in "UP" mode.
  TimerEnable(__BSP_TIMER1, UP_MODE);                                           // Start the timer prior to enabling interrupts
  TimerEnable(__BSP_TIMER2, UP_MODE);                                           // Start the timer prior to enabling interrupts

  // Enable interrupts now that microcontroller is ready for normal operation.
  __BSP_ENABLE_INTERRUPT();
}