Пример #1
0
void SEC_SetOutput(SEC_Output_t signal,boolean state) 
{
    
   if (SEC_OutputState[signal] != state) {
      SEC_OutputState[signal] = state;

      if (output_port) {
         switch (signal) {
#ifdef LED_1
             case SEC_LED1_OUTPUT:
                (state) ? lwgpio_set_value(&led1, LWGPIO_VALUE_HIGH):lwgpio_set_value(&led1, LWGPIO_VALUE_LOW);            	
                break;
#endif
#ifdef LED_2
             case SEC_LED2_OUTPUT:
                (state) ? lwgpio_set_value(&led2, LWGPIO_VALUE_HIGH):lwgpio_set_value(&led2, LWGPIO_VALUE_LOW);            	
                break;
#endif
#ifdef LED_3
             case SEC_OPEN_OUTPUT:
                (state) ? lwgpio_set_value(&led3, LWGPIO_VALUE_HIGH):lwgpio_set_value(&led3, LWGPIO_VALUE_LOW);            	
                break;
#endif
#ifdef LED_4
             case SEC_MOVEMENT_OUTPUT:
                (state) ? lwgpio_set_value(&led4, LWGPIO_VALUE_HIGH):lwgpio_set_value(&led4, LWGPIO_VALUE_LOW);            	
                break;
#endif
         }
      }

   }
}
Пример #2
0
void HVAC_SetOutput(HVAC_Output_t signal,boolean state) 
{    
   if (HVAC_OutputState[signal] != state) {
      HVAC_OutputState[signal] = state;
      if (output_port) {
         switch (signal) {
#ifdef LED_1         
             case HVAC_FAN_OUTPUT:
                (state) ? lwgpio_set_value(&led1, LWGPIO_VALUE_HIGH):lwgpio_set_value(&led1, LWGPIO_VALUE_LOW);            	
                break;
#endif   
#ifdef LED_2                
             case HVAC_HEAT_OUTPUT:
                (state) ? lwgpio_set_value(&led2, LWGPIO_VALUE_HIGH):lwgpio_set_value(&led2, LWGPIO_VALUE_LOW);            	 
                break;
#endif	
#ifdef LED_3                
             case HVAC_COOL_OUTPUT:
                (state) ? lwgpio_set_value(&led3, LWGPIO_VALUE_HIGH):lwgpio_set_value(&led3, LWGPIO_VALUE_LOW);            	 
                break;
#endif   
#ifdef LED_4                
             case HVAC_ALIVE_OUTPUT:
               (state) ? lwgpio_set_value(&led4, LWGPIO_VALUE_HIGH):lwgpio_set_value(&led4, LWGPIO_VALUE_LOW);                       	
               break;
#endif                
         }
      }
   }
}
Пример #3
0
/*TASK*----------------------------------------------------------
*
* Task Name : blink_led_task
* Comments  :
*   Set up LED and button.
*   When user presses a button this task blinks the LED and prints
*   out the number of times the system timer interrupt occurred.
*   If the button is pressed again, the LED is turned off and
*   the number of times the system timer interrupt occurred
*   is also printed out.
*END*-----------------------------------------------------------*/
void blink_led_task
    (
        uint32_t initial_data
    )
{
    /* Initialize led */
    init_led((void *)(&led1));
    /* Initialize button 1 */
    init_interrupt_btn((void *)(&btn1));
    while(1)
    {
        if(TRUE == btn_pressed)
        {
            if (TRUE == prv_btn_pressed)
            {
                prv_btn_pressed = FALSE;
                printf("\nLed starts blinking at tick No. = %d\n", num_tick);
            }
            lwgpio_toggle_value(&led1);
            _time_delay(200);
        }
        else if (FALSE == prv_btn_pressed)
        {
            prv_btn_pressed = TRUE;
            printf("\nLed is off at tick No. = %d\n", num_tick);
            lwgpio_set_value(&led1, LWGPIO_VALUE_HIGH);
        }
    }
}
Пример #4
0
void GPIO_init() {

	/******************************************************************************
	       Open the BSP_PINB9 pin as output and drive the output level LOW.
	 ******************************************************************************/
	/* initialize lwgpio handle (CAN_stb)*/
	if (!lwgpio_init(&CAN_stb, BSP_ARDUINO_GPIO2, LWGPIO_DIR_OUTPUT, LWGPIO_VALUE_NOCHANGE))
	{
		printf("Initializing CAN_stb as output failed.\n");
		_task_block();
	}
	/* swich pin functionality (MUX) to GPIO mode */
	lwgpio_set_functionality(&CAN_stb, BSP_ARDUINO_GPIO2_MUX_GPIO);

	/* write logical 0 to the pin */
	lwgpio_set_value(&CAN_stb, LWGPIO_VALUE_LOW); /* set pin to 0 */

	/******************************************************************************
		       Open the BSP_LED1 pin as output
	 ******************************************************************************/

	/* initialize lwgpio handle (led1) for BSP_LED1 pin
	 * (defined in mqx/source/bsp/<bsp_name>/<bsp_name>.h file)
	 */
	if (!lwgpio_init(&led1, BSP_LED1, LWGPIO_DIR_OUTPUT, LWGPIO_VALUE_NOCHANGE))
	{
		printf("Initializing LED1 GPIO as output failed.\n");
		_task_block();
	}
	/* swich pin functionality (MUX) to GPIO mode */
	lwgpio_set_functionality(&led1, BSP_LED1_MUX_GPIO);
}
Пример #5
0
/*FUNCTION*****************************************************************
* 
* Function Name    : lwgpio_init
* Returned Value   : TRUE if succesfull, FALSE otherwise
* Comments         :
*    Decodes ID to HW specific struct and then performs pin initialization
*
*END*********************************************************************/
bool lwgpio_init
(
    /* Pointer to LWGPIO internal structure to be filled in */
    LWGPIO_STRUCT_PTR handle,
    /* Pin ID, bitmask integer value */
    LWGPIO_PIN_ID     id,
    /* Direction to be set within initialization */
    LWGPIO_DIR        dir,
    /* Value to be set within initialization */
    LWGPIO_VALUE      value
)
{ /* Body */
    uint32_t port_idx, pin_idx;

    port_idx = LWGPIO_PORT_FROM_ID(id);
    pin_idx = LWGPIO_PIN_FROM_ID(id);

    handle->flags = id;
    handle->pcr_reg = (uint32_t *) pcr_reg_arr[port_idx] + pin_idx;
    handle->gpio_ptr = gpio_ptr_arr[port_idx];
    handle->pinmask = 1 << pin_idx;

    /* Set value prior to set to output */
    if (value != LWGPIO_VALUE_NOCHANGE) {
        /* Note: there is no check for values not defined as LWGPIO_VALUE enum */
        lwgpio_set_value(handle, value);
    }

    if (dir != LWGPIO_DIR_NOCHANGE) {
        /* Note: there is no check for values not defined as LWGPIO_DIR enum */
        lwgpio_set_direction(handle, dir);
    }

    return TRUE;
}
Пример #6
0
void pm2p5_sample_start()
{
    adcc_init(0);
    sample_timer_init();
    // set led high
    lwgpio_set_value(&pm2p5_ledgpio, SAMPLE_LED_HIGH);
    sample_state = WAIT_START_SAMPLE_STATE;
    sample_timer_set(0, 0,START_SAMPLE_TIME_US);
}
Пример #7
0
static void set_CS (uint_32 cs_mask, uint_32 logic_level, pointer user_data)
{
    LWGPIO_STRUCT_PTR gpiofd = user_data;

    if (cs_mask & BSP_SDCARD_SPI_CS)
    {
        lwgpio_set_value(gpiofd, logic_level ? LWGPIO_VALUE_HIGH : LWGPIO_VALUE_LOW);
    }
}
Пример #8
0
/*TASK**************************************************************************
*
* Function Name   : led_blink
*
* Input Params    : None
*
* Returned Value  : None
*
* Comments        : Perform blink BSP_LED1 led when the board is connected to a USB charger
*
*END***************************************************************************/
void led_blink()
{
   LWGPIO_STRUCT Charging_led;
   uint_32       value = 1;
   lwgpio_init(&Charging_led, CHARGING_LED, LWGPIO_DIR_OUTPUT, LWGPIO_VALUE_LOW);
   lwgpio_set_functionality(&Charging_led, CHARGING_LED_MUX_GPIO);
   lwgpio_set_value(&Charging_led, LWGPIO_VALUE_HIGH);
   while (1)
   {
      if (Vbus_flag)
      {
         lwgpio_set_value(&Charging_led, value);
         _time_delay (500);
         value ^= 1;
      }
      else
      {
         lwgpio_set_value(&Charging_led, LWGPIO_VALUE_HIGH);
      }
   }
}
Пример #9
0
static void SAMPLE_TIMER_ISR(void * p)
{
    VQPIT_REG_STRUCT_PTR  qpit_ptr = sample_qpit_ptr;
    qpit_ptr->TIMERS[SAMPLE_PIT_CH].TFLG |= QPIT_TFLG_TIF;
    qpit_ptr->TIMERS[SAMPLE_PIT_CH].TCTRL &= (~ QPIT_TCTRL_TIE); // ~(QPIT_TCTRL_TIE|QPIT_TCTRL_TEN)
	// todo
	if(WAIT_START_SAMPLE_STATE == sample_state){
		// set wait sample stop time
            sample_timer_set(0, 0,STOP_SAMPLE_TIME_US);
		sample_state = WAIT_STOP_SAMPLE_STATE;
		// set event ,could sample adc
#ifdef ALWAYS_SAMPLING
	   sample_value = adc_measure_pm2p5();
#else
		_lwevent_set(&sample_event, 1);
#endif
	}
        else if (WAIT_STOP_SAMPLE_STATE == sample_state) {
            sample_timer_set(0, SAMPLE_PERIOD_TIME_MS,SAMPLE_PERIOD_TIME_US);
		sample_state = WAIT_NEXT_START_STATE;
		// set led low
		lwgpio_set_value(&pm2p5_ledgpio, SAMPLE_LED_LOW);
		sample_value = 0;
        } 
	else if(WAIT_NEXT_START_STATE == sample_state) {
        sample_timer_set(0, 0 ,START_SAMPLE_TIME_US);
		sample_state = WAIT_START_SAMPLE_STATE;
		// set led high
		lwgpio_set_value(&pm2p5_ledgpio, SAMPLE_LED_HIGH);

		//_lwevent_set(&sample_event, 1);

	}
	else {
		printf("error sample state!\n");
	}

    /* Enable PIT interrupt neeed due to errata on Kinetis PIT */
    qpit_ptr->TIMERS[SAMPLE_PIT_CH].TCTRL |= QPIT_TCTRL_TIE;
}
Пример #10
0
uint32_t nRF24L01_write(uint8_t cmd, uint8_t *buff, uint8_t size, nRF24L01_STRUCT_PTR 

nRF_PTR){
    uint32_t written_bytes;
    if(buff == NULL){
        return MQX_INVALID_POINTER;
    }
    if(nRF_PTR == NULL){
        return MQX_INVALID_POINTER;
    }
    /* write logical 1 to the pin to clear the LED*/
    lwgpio_set_value(&(nRF_PTR -> CSN),LWGPIO_VALUE_HIGH);
    /* write logical 0 to write*/
    lwgpio_set_value(&(nRF_PTR -> CSN ), LWGPIO_VALUE_LOW); 
#if(0)
    for(int i=0; i<size; i++){
        written_bytes = fwrite((void *)&buff[i], 1, 1, nRF_PTR ->spi_ptr);
        if(written_bytes == 0){
            printf("\nNo se escribio ningun valor");
        }
        else{
            printf("\nDato #%d se escribieron %d", i, written_bytes);
        }
    }
#else
    written_bytes = fwrite((void *)buff, 1, size, nRF_PTR ->spi_ptr);
    if(written_bytes != size){
        printf("\nNo se escribieron todos los valores");
    }
    else{
        printf("\nSe escribieron %d", written_bytes);
    }
#endif
    
    /* write logical 1 to stop the writing*/
    lwgpio_set_value(&(nRF_PTR -> CSN), LWGPIO_VALUE_HIGH);
    return MQX_OK;
}
Пример #11
0
/*******************************************************************
*
* Function Name : init_led.
* Comments      :
*   Open the BSP_LED1 pin as output and drive the output level high.
*
********************************************************************/
void init_led(void * led)
{
    LWGPIO_STRUCT_PTR led_ptr = (LWGPIO_STRUCT_PTR)led;
    if (!lwgpio_init(led_ptr, BSP_LED1, LWGPIO_DIR_OUTPUT, LWGPIO_VALUE_NOCHANGE))
    {
        printf("Initializing LED1 GPIO as output failed.\n");
        _task_block();
    }
    /* swich pin functionality (MUX) to GPIO mode */
    lwgpio_set_functionality(led_ptr, BSP_LED1_MUX_GPIO);

    /* write logical 1 to the pin */
    lwgpio_set_value(led_ptr, LWGPIO_VALUE_HIGH);
}
Пример #12
0
static inline void init_set_vbus_low(LWGPIO_STRUCT * vbus){

    //LWGPIO_STRUCT vbus;
    _time_delay(50);

    /* initialize lwgpio handle vbus for PORTB 8 pin */
    if (!lwgpio_init(vbus, VBUSPIN, LWGPIO_DIR_OUTPUT, LWGPIO_VALUE_NOCHANGE))
    {
        printf("Initializing VBUS PORTB 8 as GPIO output failed.\n");
        _task_block();
    }
    /* swich pin functionality (MUX) to GPIO mode */
    lwgpio_set_functionality(vbus, VBUS_MUX_GPIO);

    /* write logical 0 to the pin */
    lwgpio_set_value(vbus, LWGPIO_VALUE_LOW); /* set pin to 0 */
}
Пример #13
0
static _mqx_int write_cs_callback(uint32_t pre_cfg_mask, void *user_data)
{
	VDSPI_REG_STRUCT_PTR               dspi_ptr;
	LWGPIO_STRUCT  em9301_spi_mosi;
	if(pre_cfg_mask & PRE_CONFIGURE_FLAG)
	{
		dspi_ptr = _bsp_get_dspi_base_address(1);
		dspi_ptr->MCR = (dspi_ptr->MCR & ~(uint32_t)DSPI_MCR_PCSIS_MASK) | DSPI_MCR_PCSIS(0xFF);
		/*MOSI set pin*/
		lwgpio_init(&em9301_spi_mosi, BSP_EM9301_MOSI_PIN, LWGPIO_DIR_OUTPUT, LWGPIO_VALUE_NOCHANGE);
		lwgpio_set_functionality(&em9301_spi_mosi, 1);
		lwgpio_set_value(&em9301_spi_mosi, 1);
		/*Assert CS pin*/
		dspi_ptr->MCR = (dspi_ptr->MCR & ~(uint32_t)DSPI_MCR_PCSIS_MASK) | DSPI_MCR_PCSIS(~0x01);
		lwgpio_set_functionality(&em9301_spi_mosi, 7);
	}
	return MQX_OK;
}
Пример #14
0
static _mqx_int read_cs_callback(uint32_t pre_cfg_mask, void *user_data)
{		
	
	BleStatus				status;
	MQX_FILE_PTR					dev = (MQX_FILE_PTR)user_data; 
	SPI_DEV_DATA_STRUCT_PTR			dev_data = (SPI_DEV_DATA_STRUCT_PTR)(dev->DEV_DATA_PTR);

	U8 byteReceievd;
	VDSPI_REG_STRUCT_PTR               dspi_ptr;  
	LWGPIO_STRUCT  em9301_spi_mosi;
	if(pre_cfg_mask & PRE_CONFIGURE_FLAG)
	{
		dspi_ptr = _bsp_get_dspi_base_address(1);    
		dspi_ptr->MCR = (dspi_ptr->MCR & ~(uint32_t)DSPI_MCR_PCSIS_MASK) | DSPI_MCR_PCSIS(0xFF);
		lwgpio_init(&em9301_spi_mosi, BSP_EM9301_MOSI_PIN, LWGPIO_DIR_OUTPUT, LWGPIO_VALUE_NOCHANGE);
		lwgpio_set_functionality(&em9301_spi_mosi, 1);
		lwgpio_set_value(&em9301_spi_mosi, 0);		
		/*Assert CS pin*/ 	
		dspi_ptr->MCR |= DSPI_MCR_MSTR_MASK;	
		dspi_ptr->MCR = (dspi_ptr->MCR & ~(uint32_t)DSPI_MCR_PCSIS_MASK) | DSPI_MCR_PCSIS(~0x01);
		lwgpio_set_functionality(&em9301_spi_mosi, 7);	
	}
	else
	{
		if(dev_data->STATS.RX_PACKETS)
		{
			if(dev_data->STATS.RX_PACKETS >= EM9301_READ_BUFFER_SIZE)
			{
				status = BLETRANSPORT_UartDataReceived(hciBuffer, dev_data->STATS.RX_PACKETS);
				if(status == BLESTATUS_FAILED)
				{
					BLEUART_Deinit();
					return BLESTATUS_FAILED;					
				}			
			}
			byteReceievd = dev_data->STATS.RX_PACKETS;
			status = BLETRANSPORT_UartDataReceived(hciBuffer, byteReceievd);			
			if(SPI_OK != ioctl(dev, IO_IOCTL_SPI_CLEAR_STATS, 0))
				status = BLESTATUS_FAILED;
		}			
        
	}	
	return status;
}
Пример #15
0
/*FUNCTION*---------------------------------------------------------------------
*
* Function Name    : _bsp_flexbus_lcd_setup
* Returned Value   :
* Comments         :
*    Setup FlexBus for LCD operation
*
*END*-------------------------------------------------------------------------*/
void _bsp_flexbus_lcd_setup (const uint_32 base_address)
{
    FB_MemMapPtr fb_ptr = FB_BASE_PTR;
    LWGPIO_STRUCT ale_pin;

    /* Enable external LCD mapped on CS0 */
    fb_ptr->CS[0].CSAR = base_address;
    fb_ptr->CS[0].CSCR = FB_CSCR_BLS_MASK |
                         FB_CSCR_AA_MASK  |
                         FB_CSCR_PS(2)    |
                         FB_CSCR_BEM_MASK;

    /*
     * The address range is set to 128K because
     * the DC signal is connected on address wire
     */
    fb_ptr->CS[0].CSMR = FB_CSMR_BAM(1) | FB_CSMR_V_MASK;

    lwgpio_init(&ale_pin, GPIO_PORT_E | GPIO_PIN6, LWGPIO_DIR_NOCHANGE, LWGPIO_VALUE_NOCHANGE);
    lwgpio_set_direction(&ale_pin, LWGPIO_DIR_OUTPUT);
    lwgpio_set_value(&ale_pin, LWGPIO_VALUE_HIGH);
    lwgpio_set_functionality(&ale_pin, 1);
}
Пример #16
0
boolean HVAC_InitializeIO(void) 
{
 
/* Init Gpio for Leds as output to drive LEDs (LED10 - LED13) */
#ifdef LED_1
   output_port = lwgpio_init(&led1, LED_1, LWGPIO_DIR_OUTPUT, LWGPIO_VALUE_NOCHANGE);
   if(!output_port){
      printf("Initializing LWGPIO for LED1 failed.\n");
   }
   lwgpio_set_functionality(&led1, BSP_LED1_MUX_GPIO);
   /*Turn off Led */
   lwgpio_set_value(&led1, LWGPIO_VALUE_LOW);
#endif

#ifdef LED_2
   output_port = lwgpio_init(&led2, LED_2, LWGPIO_DIR_OUTPUT, LWGPIO_VALUE_NOCHANGE);
   if(!output_port){
      printf("Initializing LWGPIO for LED2 failed.\n");

   }
   lwgpio_set_functionality(&led2, BSP_LED2_MUX_GPIO);
   /*Turn off Led */
   lwgpio_set_value(&led2, LWGPIO_VALUE_LOW);
#endif

#ifdef LED_3
   output_port = lwgpio_init(&led3, LED_3, LWGPIO_DIR_OUTPUT, LWGPIO_VALUE_NOCHANGE);
   if(!output_port){
      printf("Initializing LWGPIO for LED3 failed.\n");
   }
   lwgpio_set_functionality(&led3, BSP_LED3_MUX_GPIO);
   /*Turn off Led */
   lwgpio_set_value(&led3, LWGPIO_VALUE_LOW);
#endif

#ifdef LED_4
   output_port = lwgpio_init(&led4, LED_4, LWGPIO_DIR_OUTPUT, LWGPIO_VALUE_NOCHANGE);
   if(!output_port){
      printf("Initializing LWGPIO for LED4 failed.\n");
   }
   lwgpio_set_functionality(&led4, BSP_LED4_MUX_GPIO);
   /*Turn off Led */
   lwgpio_set_value(&led4, LWGPIO_VALUE_LOW);
#endif

#ifdef BSP_BUTTON1
    /* Open and set port DD as input to read value from switches */
       input_port = lwgpio_init(&button1, TEMP_PLUS, LWGPIO_DIR_INPUT, LWGPIO_VALUE_NOCHANGE);
       if(!input_port)
       {
           printf("Initializing LW GPIO for button1 as input failed.\n");
           _task_block();
       }    
       lwgpio_set_functionality(&button1 ,BSP_BUTTON1_MUX_GPIO);
       lwgpio_set_attribute(&button1, LWGPIO_ATTR_PULL_UP, LWGPIO_AVAL_ENABLE);
#endif
       
#ifdef BSP_BUTTON2
       input_port = lwgpio_init(&button2, TEMP_MINUS, LWGPIO_DIR_INPUT, LWGPIO_VALUE_NOCHANGE);
       if(!input_port)
       {
           printf("Initializing LW GPIO for button2 as input failed.\n");
           _task_block();
       }
       lwgpio_set_functionality(&button2, BSP_BUTTON2_MUX_GPIO);
       lwgpio_set_attribute(&button2, LWGPIO_ATTR_PULL_UP, LWGPIO_AVAL_ENABLE);
 
#endif
       
#ifdef BSP_BUTTON3
       input_port = lwgpio_init(&button3, TEMP_MINUS, LWGPIO_DIR_INPUT, LWGPIO_VALUE_NOCHANGE);
       if(!input_port)
       {
           printf("Initializing LW GPIO for button3 as input failed.\n");
           _task_block();
       }
       lwgpio_set_functionality(&button3, BSP_BUTTON3_MUX_GPIO);
       lwgpio_set_attribute(&button3, LWGPIO_ATTR_PULL_UP, LWGPIO_AVAL_ENABLE);
#endif
       
#if BUTTONS
    return (input_port!=0) && (output_port!=0);
#else
   return (output_port!=0);
#endif   
       
}
Пример #17
0
static void DIO__vSetLwgpio(LWGPIO_STRUCT * pstPortReg,LWGPIO_VALUE Value)
{
	lwgpio_set_value(pstPortReg,Value);
}
Пример #18
0
boolean SEC_InitializeIO(void)
{

    /* Init Gpio for Leds as output to drive LEDs (LED10 - LED13) */
#ifdef LED_1
       output_port = lwgpio_init(&led1, LED_1, LWGPIO_DIR_OUTPUT, LWGPIO_VALUE_NOCHANGE);
       if(!output_port){
          printf("Initializing LWGPIO for LED1 failed.\n");
       }
       lwgpio_set_functionality(&led1, BSP_LED1_MUX_GPIO);
       /*Turn off Led */
       lwgpio_set_value(&led1, LWGPIO_VALUE_LOW);
#endif

#ifdef LED_2
       output_port = lwgpio_init(&led2, LED_2, LWGPIO_DIR_OUTPUT, LWGPIO_VALUE_NOCHANGE);
       if(!output_port){
          printf("Initializing LWGPIO for LED2 failed.\n");
       }
       lwgpio_set_functionality(&led2, BSP_LED2_MUX_GPIO);
       /*Turn off Led */
       lwgpio_set_value(&led2, LWGPIO_VALUE_LOW);
#endif

#ifdef LED_3
       output_port = lwgpio_init(&led3, LED_3, LWGPIO_DIR_OUTPUT, LWGPIO_VALUE_NOCHANGE);
       if(!output_port){
          printf("Initializing LWGPIO for LED3 failed.\n");
       }
       lwgpio_set_functionality(&led3, BSP_LED3_MUX_GPIO);
       /*Turn off Led */
       lwgpio_set_value(&led3, LWGPIO_VALUE_LOW);
#endif

#ifdef LED_4
       output_port = lwgpio_init(&led4, LED_4, LWGPIO_DIR_OUTPUT, LWGPIO_VALUE_NOCHANGE);
       if(!output_port){
          printf("Initializing LWGPIO for LED3 failed.\n");
       }
       lwgpio_set_functionality(&led4, BSP_LED4_MUX_GPIO);
       /*Turn off Led */
       lwgpio_set_value(&led4, LWGPIO_VALUE_LOW);
#endif

#ifdef BSP_BUTTON1
    /* Open and set port DD as input to read value from switches */
       input_port = lwgpio_init(&button1, DOOR_STATE, LWGPIO_DIR_INPUT, LWGPIO_VALUE_NOCHANGE);
       if(!input_port)
       {
           printf("Initializing LW GPIO for button1 as input failed.\n");
           _task_block();
       }    
       #if (defined BSP_BUTTON1_MUX_IRQ && defined SECEMAIL_TWRMCF51CN_STOP_ENABLED)
       lwgpio_set_functionality(&button1 ,BSP_BUTTON1_MUX_IRQ);
       lwgpio_set_attribute(&button1, LWGPIO_ATTR_PULL_UP, LWGPIO_AVAL_ENABLE);
       if (!lwgpio_int_init(&button1, LWGPIO_INT_MODE_RISING))
       {
           printf("Initializing button GPIO for interrupt failed.\n");
       }
       #else 
       lwgpio_set_functionality(&button1 ,BSP_BUTTON1_MUX_GPIO);
       lwgpio_set_attribute(&button1, LWGPIO_ATTR_PULL_UP, LWGPIO_AVAL_ENABLE);
       #endif
       /* install gpio interrupt service routine */
       _int_install_isr(lwgpio_int_get_vector(&button1), kbi_callback, (void *) &button1);
       _bsp_int_init(lwgpio_int_get_vector(&button1), 3, 0, TRUE);
       lwgpio_int_enable(&button1, TRUE);
#endif
       
#ifdef BSP_BUTTON2
       input_port = lwgpio_init(&button2, WINDOW_STATE, LWGPIO_DIR_INPUT, LWGPIO_VALUE_NOCHANGE);
       if(!input_port)
       {
           printf("Initializing LW GPIO for button2 as input failed.\n");
           _task_block();
       }
       #if (defined BSP_BUTTON2_MUX_IRQ && defined SECEMAIL_TWRMCF51CN_STOP_ENABLED)
       lwgpio_set_functionality(&button2 ,BSP_BUTTON2_MUX_IRQ);
       lwgpio_set_attribute(&button2, LWGPIO_ATTR_PULL_UP, LWGPIO_AVAL_ENABLE);
       if (!lwgpio_int_init(&button2, LWGPIO_INT_MODE_FALLING))
       {
           printf("Initializing button GPIO for interrupt failed.\n");
       }
       #else 
       lwgpio_set_functionality(&button2 ,BSP_BUTTON2_MUX_GPIO);
       lwgpio_set_attribute(&button2, LWGPIO_ATTR_PULL_UP, LWGPIO_AVAL_ENABLE);
       #endif
       /* install gpio interrupt service routine */
       _int_install_isr(lwgpio_int_get_vector(&button2), kbi_callback, (void *) &button2);
       _bsp_int_init(lwgpio_int_get_vector(&button2), 3, 0, TRUE);
       lwgpio_int_enable(&button2, TRUE);
#endif

    return (input_port!=0) && (output_port!=0);
}
Пример #19
0
uint32_t OS_Gpio_set_value(os_gpio_handle handle, uint32_t value)
{
    LWGPIO_STRUCT_PTR    pGpio = (LWGPIO_STRUCT_PTR)handle;
    lwgpio_set_value(pGpio, (LWGPIO_VALUE)value);
    return OS_GPIO_OK;
}
void nRF24L01_pin_high(LWGPIO_STRUCT_PTR pin){
    /* write logical 1 to the pin to clear the LED*/
    lwgpio_set_value(pin, LWGPIO_VALUE_HIGH);
}
Пример #21
0
int adcc_init(int adc_num)
{
    //PORT_MemMapPtr pctl = NULL;
    //uint8_t gpio_port;

	/* led pin init */
    if(!lwgpio_init(&pm2p5_ledgpio, PM2P5_LED_PWREN, LWGPIO_DIR_OUTPUT, LWGPIO_VALUE_NOCHANGE)) {
        printf("Initializing GPIO with associated pins failed.\n");
        _time_delay (200L);
        _task_block();
    }
    lwgpio_set_functionality(&pm2p5_ledgpio, PM2P5_LED_MUX_GPIO);
    //lwgpio_set_value(&pm2p5_ledgpio, LWGPIO_VALUE_LOW);
    lwgpio_set_value(&pm2p5_ledgpio, LWGPIO_VALUE_HIGH);
    
	if(adc_num == 0) {
		/* SIM_SCGC6: ADC0=1 */
		adc_ptr = ADC0_BASE_PTR;
		SIM_SCGC6 |= SIM_SCGC6_ADC0_MASK;
	}
	else {
		adc_ptr = ADC1_BASE_PTR;
		SIM_SCGC6 |= SIM_SCGC6_ADC1_MASK;
	}

#ifdef ADC_HW_TRIGER
    SIM_SCGC6 |= SIM_SCGC6_PIT_MASK;                 /* enable PIT */

    SIM_SOPT7 |= SIM_SOPT7_ADC1ALTTRGEN_MASK;
    SIM_SOPT7 |= (SIM_SOPT7_ADC1PRETRGSEL_MASK);     /* Pre Trigger B */
    SIM_SOPT7 &= ~(SIM_SOPT7_ADC1TRGSEL_MASK); 
    SIM_SOPT7 |= SIM_SOPT7_ADC1TRGSEL(7);            /* PIT trigger 3 */
    PIT_MCR_REG(PIT_BASE_PTR) = 0;
#endif

	// pin mux config : spec P216 ADC0_DP0/ADC1_DP3 is default
	/* set pin's multiplexer to analog
    gpio_port = ADC_SIG_PORTB | 4;
    pctl = (PORT_MemMapPtr) PORTB_BASE_PTR;
    pctl->PCR[gpio_port & 0x1F] &= ~PORT_PCR_MUX_MASK; 
	*/

    // Initialize ADC0/1 =================================================================================
    //averages (4 h/w)   // bus 60M /8/2 = 3.75M ADC clock
    ADC_CFG1_REG(adc_ptr) = ADLPC_NORMAL | ADC_CFG1_ADIV(ADIV_8) /*| ADLSMP_LONG*/ | ADC_CFG1_MODE(MODE_16)
      | ADC_CFG1_ADICLK(/*ADICLK_BUS_2*/ADICLK_BUS);

    // do calibration
    if(adc_calibrate(adc_ptr))
        printf("adc-%x calibrate failed\n",(int)adc_ptr);

    /* channel A/B selected */
#ifdef ADC_HW_TRIGER
    ADC_CFG2_REG(adc_ptr)  = MUXSEL_ADCB | ADACKEN_ENABLED | ADHSC_HISPEED | ADC_CFG2_ADLSTS(ADLSTS_20);
#else
	ADC_CFG2_REG(adc_ptr)  = MUXSEL_ADCA /*| ADACKEN_ENABLED */| ADHSC_HISPEED | ADC_CFG2_ADLSTS(ADLSTS_20);
#endif
	
    //ADC_CV1_REG(adc_ptr) = 0x0;
    //ADC_CV2_REG(adc_ptr) = 0x0;
        
    //ADC_SC1_REG(adc_ptr,0) =  AIEN_ON | DIFF_SINGLE | ADC_SC1_ADCH(ADC_INPUT_CH);   /* SC1 A */
    //ADC_SC1_REG(adc_ptr,1) =  AIEN_ON | DIFF_SINGLE | ADC_SC1_ADCH(ADC_INPUT_CH);   /* SC1 B */

#ifdef ADC_HW_TRIGER
    ADC_SC2_REG(adc_ptr) = ADTRG_HW /*ADTRG_SW*/ | ACFE_DISABLED | ACFGT_GREATER | ACREN_DISABLED
                     | DMAEN_DISABLED /* DMAEN_ENABLED*/| ADC_SC2_REFSEL(REFSEL_EXT);
#else
    ADC_SC2_REG(adc_ptr) = ADTRG_SW /*| ACFE_DISABLED | ACFGT_GREATER | ACREN_DISABLED
                     | DMAEN_DISABLED*/ | ADC_SC2_REFSEL(REFSEL_EXT);
#endif

    ADC_SC3_REG(adc_ptr) = /*ADC_SC3_CALF_MASK |*/ CAL_OFF | ADCO_SINGLE /*| AVGE_ENABLED | ADC_SC3_AVGS(AVGS_4)*/;  /* averages 4 h/w */
}
Пример #22
0
static inline void delay_set_vbus_high(LWGPIO_STRUCT * vbus) {
    _time_delay(150);
    /* write logical 1 to the pin */
    lwgpio_set_value(vbus, LWGPIO_VALUE_HIGH); /* set pin to 1 */
    _time_delay(200);
}