Beispiel #1
0
void hal_tick_init(void){
    ledIsOn = false;
    handleTmr = DRV_TMR_Open(APP_TMR_DRV_INDEX, DRV_IO_INTENT_EXCLUSIVE);
    if( DRV_HANDLE_INVALID == handleTmr ){
        log_error("Timer init failed");
        return;
    }
    DRV_TMR_Alarm16BitRegister(handleTmr, APP_TMR_ALARM_PERIOD, true, (uintptr_t)NULL, sys_tick_handler);
    DRV_TMR_Start(handleTmr);
    SYS_PORTS_PinDirectionSelect(PORTS_ID_0, SYS_PORTS_DIRECTION_OUTPUT, APP_LED_PORT, APP_LED_PIN);
}
Beispiel #2
0
void hal_uart_dma_init(void){

    bytes_to_write = 0;
    bytes_to_read = 0;

    /* PPS Input Remapping */
    PLIB_PORTS_RemapInput(PORTS_ID_0, INPUT_FUNC_U2RX, INPUT_PIN_RPF4 );
    PLIB_PORTS_RemapInput(PORTS_ID_0, INPUT_FUNC_U2CTS, INPUT_PIN_RPB2 );

    /* PPS Output Remapping */
    PLIB_PORTS_RemapOutput(PORTS_ID_0, OUTPUT_FUNC_U2RTS, OUTPUT_PIN_RPG9 );
    PLIB_PORTS_RemapOutput(PORTS_ID_0, OUTPUT_FUNC_U2TX, OUTPUT_PIN_RPF5 );

    /* Initialize USART */
    PLIB_USART_BaudRateSet(BT_USART_ID, SYS_CLK_PeripheralFrequencyGet(CLK_BUS_PERIPHERAL_1), BT_USART_BAUD);
    PLIB_USART_HandshakeModeSelect(BT_USART_ID, USART_HANDSHAKE_MODE_FLOW_CONTROL);
    PLIB_USART_OperationModeSelect(BT_USART_ID, USART_ENABLE_TX_RX_CTS_RTS_USED);
    PLIB_USART_LineControlModeSelect(BT_USART_ID, USART_8N1);
    PLIB_USART_TransmitterEnable(BT_USART_ID);
//    PLIB_USART_TransmitterInterruptModeSelect(bluetooth_uart_id, USART_TRANSMIT_FIFO_IDLE);
    PLIB_USART_ReceiverEnable(BT_USART_ID);
//    PLIB_USART_ReceiverInterruptModeSelect(bluetooth_uart_id, USART_RECEIVE_FIFO_ONE_CHAR);

    PLIB_USART_Enable(BT_USART_ID);

    // enable _RESET
    SYS_PORTS_PinDirectionSelect(PORTS_ID_0, SYS_PORTS_DIRECTION_OUTPUT, BT_RESET_PORT, BT_RESET_BIT);

    bluetooth_power_cycle();

    // After reset, CTS is high and we need to wait until CTS is low again

    // HACK: CTS doesn't seem to work right now
    msleep(250);

    // HACK: CSR seems to do an auto-baud on the uart, which makes the first HCI RESET fail
    // 2 options: a) check for CTS going high within 10 ms, b) just send HCI RESET twice

//    const uint8_t hci_reset_cmd[] = {0x01, 0x03, 0x0c, 0x00};
//    int pos = 0;
//    while(pos < sizeof(hci_reset_cmd)){
//        if (PLIB_USART_TransmitterIsEmpty(BT_USART_ID)){
//            PLIB_USART_TransmitterByteSend(BT_USART_ID, hci_reset_cmd[pos]);
//            pos++;
//        }
//    }
//    msleep(250);

}
Beispiel #3
0
void lineTimerCallback( TimerHandle_t pxTimer )
{
    
    outputEvent(LINE_READING_START);
    
    if(!wait)
        if( xTimerStart( lineTimer, 0 ) != pdPASS )
            outputEvent(LINETIMER_NOT_STARTED);
   
    
    //Set Pins to digital output and HIGH
    SYS_PORTS_PinDirectionSelect(PORTS_ID_0, SYS_PORTS_DIRECTION_OUTPUT, PORT_CHANNEL_B, PORTS_BIT_POS_11);
    SYS_PORTS_PinDirectionSelect(PORTS_ID_0, SYS_PORTS_DIRECTION_OUTPUT, PORT_CHANNEL_B, PORTS_BIT_POS_12);
    SYS_PORTS_PinDirectionSelect(PORTS_ID_0, SYS_PORTS_DIRECTION_OUTPUT, PORT_CHANNEL_B, PORTS_BIT_POS_13);
    SYS_PORTS_PinDirectionSelect(PORTS_ID_0, SYS_PORTS_DIRECTION_OUTPUT, PORT_CHANNEL_G, PORTS_BIT_POS_8);
    SYS_PORTS_PinDirectionSelect(PORTS_ID_0, SYS_PORTS_DIRECTION_OUTPUT, PORT_CHANNEL_A, PORTS_BIT_POS_10);
    SYS_PORTS_PinDirectionSelect(PORTS_ID_0, SYS_PORTS_DIRECTION_OUTPUT, PORT_CHANNEL_F, PORTS_BIT_POS_0);
    SYS_PORTS_PinDirectionSelect(PORTS_ID_0, SYS_PORTS_DIRECTION_OUTPUT, PORT_CHANNEL_F, PORTS_BIT_POS_1);
    SYS_PORTS_PinDirectionSelect(PORTS_ID_0, SYS_PORTS_DIRECTION_OUTPUT, PORT_CHANNEL_D, PORTS_BIT_POS_6);
    
    
    SYS_PORTS_PinSet(PORTS_ID_0, PORT_CHANNEL_B, PORTS_BIT_POS_11);
    SYS_PORTS_PinSet(PORTS_ID_0, PORT_CHANNEL_B, PORTS_BIT_POS_13);
    SYS_PORTS_PinSet(PORTS_ID_0, PORT_CHANNEL_B, PORTS_BIT_POS_12);
    SYS_PORTS_PinSet(PORTS_ID_0, PORT_CHANNEL_G, PORTS_BIT_POS_8);
    SYS_PORTS_PinSet(PORTS_ID_0, PORT_CHANNEL_A, PORTS_BIT_POS_10);
    SYS_PORTS_PinSet(PORTS_ID_0, PORT_CHANNEL_F, PORTS_BIT_POS_0);
    SYS_PORTS_PinSet(PORTS_ID_0, PORT_CHANNEL_F, PORTS_BIT_POS_1);
    SYS_PORTS_PinSet(PORTS_ID_0, PORT_CHANNEL_D, PORTS_BIT_POS_6);
    
    //Start timer to charge cap and read data
    validData = false;
    if( xTimerStart( readTimer, 0 ) != pdPASS ){
        outputEvent(READTIMER_NOT_STARTED);
    }
}
Beispiel #4
0
void readTimerCallback( TimerHandle_t pxTimer )
{
    if(validData){
        outputEvent(LINE_VALID_DATA);
        
        //Read pins and send message to sensor queue
        bool pin1 = SYS_PORTS_PinRead(PORTS_ID_0, PORT_CHANNEL_B, PORTS_BIT_POS_11);
        bool pin2 = SYS_PORTS_PinRead(PORTS_ID_0, PORT_CHANNEL_B, PORTS_BIT_POS_13);
        bool pin3 = SYS_PORTS_PinRead(PORTS_ID_0, PORT_CHANNEL_B, PORTS_BIT_POS_12);
        bool pin4 = SYS_PORTS_PinRead(PORTS_ID_0, PORT_CHANNEL_G, PORTS_BIT_POS_8);
        bool pin5 = SYS_PORTS_PinRead(PORTS_ID_0, PORT_CHANNEL_A, PORTS_BIT_POS_10);
        bool pin6 = SYS_PORTS_PinRead(PORTS_ID_0, PORT_CHANNEL_F, PORTS_BIT_POS_0);
        bool pin7 = SYS_PORTS_PinRead(PORTS_ID_0, PORT_CHANNEL_F, PORTS_BIT_POS_1);
        bool pin8 = SYS_PORTS_PinRead(PORTS_ID_0, PORT_CHANNEL_D, PORTS_BIT_POS_6);
        
        uint8_t line = 0;      
        if(pin1)
            line += 0x1;
        if(pin2)
            line += 0x2;
        if(pin3)
            line += 0x4;
        if(pin4)
            line += 0x8;
        if(pin5)
            line += 0x10;
        if(pin6)
            line += 0x20;
        if(pin7)
            line += 0x40;
        if(pin8)
            line += 0x80;        
        
        MESSAGE lineMsg;
        lineMsg.id = 0x36;
        lineMsg.msg = 0x12;
        lineMsg.data1 = line;
        lineMsg.data2 = 0x0;    

        if( xQueueSendToBack(sensorQueue, (void *)&lineMsg, (TickType_t)0) != pdPASS )
        {
            outputEvent(SENSOR_QUEUE_FULL);
        }
        else
        {
            outputEvent(SENT_TO_SENSOR_QUEUE);
        }
        validData = false;
        
    }else{
        outputEvent(LINE_CAP_CHARGED);
        
        //Set Pins to digital input
        SYS_PORTS_PinDirectionSelect(PORTS_ID_0, SYS_PORTS_DIRECTION_INPUT, PORT_CHANNEL_B, PORTS_BIT_POS_11);
        SYS_PORTS_PinDirectionSelect(PORTS_ID_0, SYS_PORTS_DIRECTION_INPUT, PORT_CHANNEL_B, PORTS_BIT_POS_13);
        SYS_PORTS_PinDirectionSelect(PORTS_ID_0, SYS_PORTS_DIRECTION_INPUT, PORT_CHANNEL_B, PORTS_BIT_POS_12);
        SYS_PORTS_PinDirectionSelect(PORTS_ID_0, SYS_PORTS_DIRECTION_INPUT, PORT_CHANNEL_G, PORTS_BIT_POS_8);
        SYS_PORTS_PinDirectionSelect(PORTS_ID_0, SYS_PORTS_DIRECTION_INPUT, PORT_CHANNEL_A, PORTS_BIT_POS_10);
        SYS_PORTS_PinDirectionSelect(PORTS_ID_0, SYS_PORTS_DIRECTION_INPUT, PORT_CHANNEL_F, PORTS_BIT_POS_0);
        SYS_PORTS_PinDirectionSelect(PORTS_ID_0, SYS_PORTS_DIRECTION_INPUT, PORT_CHANNEL_F, PORTS_BIT_POS_1);
        SYS_PORTS_PinDirectionSelect(PORTS_ID_0, SYS_PORTS_DIRECTION_INPUT, PORT_CHANNEL_D, PORTS_BIT_POS_6);
       
        
        //Reset timer
        validData = true;
        if( xTimerReset( readTimer, 0 ) != pdPASS ){
           outputEvent(READTIMER_NOT_RESET);
        }
    }   
}