/** Routine Description: Gets the mode (function) of a GPIO pin Arguments: This - pointer to protocol Gpio - which pin Mode - pointer to output mode value Returns: EFI_SUCCESS - mode value retrieved EFI_INVALID_PARAMETER - Mode is a null pointer or Gpio pin is out of range **/ EFI_STATUS EFIAPI GetMode ( IN EMBEDDED_GPIO *This, IN EMBEDDED_GPIO_PIN Gpio, OUT EMBEDDED_GPIO_MODE *Mode ) { EFI_STATUS Status = EFI_SUCCESS; UINTN Index, Offset, RegisterBase; Status = PL061Locate (Gpio, &Index, &Offset, &RegisterBase); ASSERT_EFI_ERROR (Status); // Check for errors if (Mode == NULL) { return EFI_INVALID_PARAMETER; } // Check if it is input or output if (MmioRead8 (RegisterBase + PL061_GPIO_DIR_REG) & GPIO_PIN_MASK(Offset)) { // Pin set to output if (PL061GetPins (RegisterBase, GPIO_PIN_MASK(Offset))) { *Mode = GPIO_MODE_OUTPUT_1; } else { *Mode = GPIO_MODE_OUTPUT_0; } } else { // Pin set to input *Mode = GPIO_MODE_INPUT; } return EFI_SUCCESS; }
/*---------------------------------------------------------------------------*/ void spi_cs_init(uint8_t port, uint8_t pin) { GPIO_SOFTWARE_CONTROL(GPIO_PORT_TO_BASE(port), GPIO_PIN_MASK(pin)); ioc_set_over(port, pin, IOC_OVERRIDE_DIS); GPIO_SET_OUTPUT(GPIO_PORT_TO_BASE(port), GPIO_PIN_MASK(pin)); GPIO_SET_PIN(GPIO_PORT_TO_BASE(port), GPIO_PIN_MASK(pin)); }
/*---------------------------------------------------------------------------*/ static void config_gpio(uint8_t port, uint8_t pin, uint8_t type) { GPIO_SOFTWARE_CONTROL(GPIO_PORT_TO_BASE(port), GPIO_PIN_MASK(pin)); if(type == HWTEST_GPIO_OUTPUT) { GPIO_SET_OUTPUT(GPIO_PORT_TO_BASE(port), GPIO_PIN_MASK(pin)); } else if(type == HWTEST_GPIO_INPUT) { GPIO_SET_INPUT(GPIO_PORT_TO_BASE(port), GPIO_PIN_MASK(pin)); } }
/** Routine Description: Sets the state of a GPIO pin Arguments: This - pointer to protocol Gpio - which pin to modify Mode - mode to set Returns: EFI_SUCCESS - GPIO set as requested EFI_UNSUPPORTED - Mode is not supported EFI_INVALID_PARAMETER - Gpio pin is out of range **/ EFI_STATUS EFIAPI Set ( IN EMBEDDED_GPIO *This, IN EMBEDDED_GPIO_PIN Gpio, IN EMBEDDED_GPIO_MODE Mode ) { EFI_STATUS Status = EFI_SUCCESS; UINTN Index, Offset, RegisterBase; Status = PL061Locate (Gpio, &Index, &Offset, &RegisterBase); if (EFI_ERROR (Status)) goto EXIT; // Initialize the hardware if not already done if (!mPL061Initialized) { Status = PL061Initialize(); if (EFI_ERROR(Status)) { goto EXIT; } } switch (Mode) { case GPIO_MODE_INPUT: // Set the corresponding direction bit to LOW for input MmioAnd8 (RegisterBase + PL061_GPIO_DIR_REG, ~GPIO_PIN_MASK(Gpio)); break; case GPIO_MODE_OUTPUT_0: // Set the corresponding data bit to LOW for 0 MmioWrite8 (RegisterBase + PL061_GPIO_DATA_REG + (GPIO_PIN_MASK(Offset) << 2), 0); // Set the corresponding direction bit to HIGH for output MmioOr8 (RegisterBase + PL061_GPIO_DIR_REG, GPIO_PIN_MASK(Offset)); break; case GPIO_MODE_OUTPUT_1: // Set the corresponding data bit to HIGH for 1 MmioWrite8 (RegisterBase + PL061_GPIO_DATA_REG + (GPIO_PIN_MASK(Offset) << 2), 0xff); // Set the corresponding direction bit to HIGH for output MmioOr8 (RegisterBase + PL061_GPIO_DIR_REG, GPIO_PIN_MASK(Offset)); break; default: // Other modes are not supported return EFI_UNSUPPORTED; } EXIT: return Status; }
/*---------------------------------------------------------------------------*/ static void floppin(uint8_t port, uint8_t pin) { uint8_t i; GPIO_CLR_PIN(GPIO_PORT_TO_BASE(port), GPIO_PIN_MASK(pin)); clock_delay_usec(500); for(i = 0; i < 50; i++) { GPIO_SET_PIN(GPIO_PORT_TO_BASE(port), GPIO_PIN_MASK(pin)); clock_delay_usec(500); GPIO_CLR_PIN(GPIO_PORT_TO_BASE(port), GPIO_PIN_MASK(pin)); clock_delay_usec(500); } }
void gpio_irq_enable(gpio_t dev) { if (gpio_enabled(dev)) { int pin = pin_lut[dev]; GPIO_NUM_TO_DEV(pin)->IE |= GPIO_PIN_MASK(GPIO_BIT_NUM(pin)); } }
/** Routine Description: Gets the state of a GPIO pin Arguments: This - pointer to protocol Gpio - which pin to read Value - state of the pin Returns: EFI_SUCCESS - GPIO state returned in Value EFI_INVALID_PARAMETER - Value is NULL pointer or Gpio pin is out of range **/ EFI_STATUS EFIAPI Get ( IN EMBEDDED_GPIO *This, IN EMBEDDED_GPIO_PIN Gpio, OUT UINTN *Value ) { EFI_STATUS Status = EFI_SUCCESS; UINTN Index, Offset, RegisterBase; Status = PL061Locate (Gpio, &Index, &Offset, &RegisterBase); ASSERT_EFI_ERROR (Status); if (Value == NULL) { return EFI_INVALID_PARAMETER; } if (PL061GetPins (RegisterBase, GPIO_PIN_MASK(Offset))) { *Value = 1; } else { *Value = 0; } return EFI_SUCCESS; }
int gpio_init_int(gpio_t dev, gpio_mode_t mode, gpio_flank_t flank, gpio_cb_t cb, void *arg) { int res, pin, irq_num; uint32_t mask; cc2538_gpio_t* instance; /* Note: gpio_init() also checks if the gpio is enabled. */ res = gpio_init(dev, mode); if (res < 0) { return res; } /* Store the callback information for later: */ gpio_config[dev].cb = cb; gpio_config[dev].arg = arg; pin = pin_lut[dev]; mask = GPIO_PIN_MASK(GPIO_BIT_NUM(pin)); instance = GPIO_NUM_TO_DEV(pin); /* Enable power-up interrupts for this GPIO port: */ SYS_CTRL_IWE |= BIT(GPIO_NUM_TO_PORT_NUM(pin)); switch(flank) { case GPIO_FALLING: instance->IBE &= ~mask; /**< Not both edges */ instance->IEV &= ~mask; /**< Falling edge */ instance->P_EDGE_CTRL |= BIT(pin); /**< Falling edge power-up interrupt */ break; case GPIO_RISING: instance->IBE &= ~mask; /**< Not both edges */ instance->IEV |= mask; /**< Rising edge */ instance->P_EDGE_CTRL &= ~BIT(pin); /**< Rising edge power-up interrupt */ break; case GPIO_BOTH: instance->IBE = mask; /**< Both edges */ break; } instance->IS &= ~mask; /**< Edge triggered (as opposed to level-triggered) */ instance->IC |= mask; /**< Clear any preexisting interrupt state */ instance->PI_IEN |= BIT(pin); /**< Enable power-up interrupts for this pin */ /* Set interrupt priority for the whole GPIO port: */ irq_num = GPIO_PORT_A_IRQn + GPIO_NUM_TO_PORT_NUM(pin); NVIC_SetPriority(irq_num, GPIO_IRQ_PRIO); /* Enable interrupts for the whole GPIO port: */ NVIC_EnableIRQ(irq_num); /* Enable interrupts for the specific pin: */ instance->IE |= mask; return 0; }
/*---------------------------------------------------------------------------*/ static void at_cmd_gpio_callback(struct at_cmd *cmd, uint8_t len, char *data) { /* Format: AT&GPIO=PN,s where P(ort)N(number), s(tate)=1/0 */ uint8_t port; uint8_t state = strncmp(&data[11], "1", 1) ? 0 : 1; uint8_t pin = atoi(&data[9]); if(strncmp(&data[10], ",", 1) != 0) { AT_RESPONSE(AT_DEFAULT_RESPONSE_ERROR); return; } if((pin < 0) || (pin > 7)) { AT_RESPONSE(AT_DEFAULT_RESPONSE_ERROR); return; } if((state < 0) || (state > 1)) { AT_RESPONSE(AT_DEFAULT_RESPONSE_ERROR); return; } if(strncmp(&data[8], "A", 1) == 0) { port = GPIO_A_NUM; } else if(strncmp(&data[8], "B", 1) == 0) { port = GPIO_B_NUM; } else if(strncmp(&data[8], "C", 1) == 0) { port = GPIO_C_NUM; } else if(strncmp(&data[8], "D", 1) == 0) { port = GPIO_D_NUM; } else { AT_RESPONSE(AT_DEFAULT_RESPONSE_ERROR); return; } config_gpio(port, pin, HWTEST_GPIO_OUTPUT); if(state) { GPIO_SET_PIN(GPIO_PORT_TO_BASE(port), GPIO_PIN_MASK(pin)); } else { GPIO_CLR_PIN(GPIO_PORT_TO_BASE(port), GPIO_PIN_MASK(pin)); } AT_RESPONSE(AT_DEFAULT_RESPONSE_OK); }
/** Routine Description: Sets the state of a GPIO pin Arguments: This - pointer to protocol Gpio - which pin to modify Mode - mode to set Returns: EFI_SUCCESS - GPIO set as requested EFI_UNSUPPORTED - Mode is not supported EFI_INVALID_PARAMETER - Gpio pin is out of range **/ EFI_STATUS EFIAPI Set ( IN EMBEDDED_GPIO *This, IN EMBEDDED_GPIO_PIN Gpio, IN EMBEDDED_GPIO_MODE Mode ) { EFI_STATUS Status = EFI_SUCCESS; UINTN Index, Offset, RegisterBase; Status = PL061Locate (Gpio, &Index, &Offset, &RegisterBase); ASSERT_EFI_ERROR (Status); switch (Mode) { case GPIO_MODE_INPUT: // Set the corresponding direction bit to LOW for input MmioAnd8 (RegisterBase + PL061_GPIO_DIR_REG, ~GPIO_PIN_MASK(Offset) & 0xFF); break; case GPIO_MODE_OUTPUT_0: // Set the corresponding direction bit to HIGH for output MmioOr8 (RegisterBase + PL061_GPIO_DIR_REG, GPIO_PIN_MASK(Offset)); // Set the corresponding data bit to LOW for 0 PL061SetPins (RegisterBase, GPIO_PIN_MASK(Offset), 0); break; case GPIO_MODE_OUTPUT_1: // Set the corresponding direction bit to HIGH for output MmioOr8 (RegisterBase + PL061_GPIO_DIR_REG, GPIO_PIN_MASK(Offset)); // Set the corresponding data bit to HIGH for 1 PL061SetPins (RegisterBase, GPIO_PIN_MASK(Offset), 0xff); break; default: // Other modes are not supported return EFI_UNSUPPORTED; } return EFI_SUCCESS; }
void cb(uint8_t port, uint8_t pin){ GPIO_CLEAR_INTERRUPT(GPIO_PORT_TO_BASE(port), GPIO_PIN_MASK(pin)); if(port==2 && pin==0){ start_time = vtimer_arch_now(); } else{ printf("time = %lu\n", vtimer_arch_now()-start_time); } }
//Use C0 to receive interrupt void configGPIOInterrupt(){ GPIO_SOFTWARE_CONTROL(GPIO_PORT_TO_BASE(GPIO_C_NUM), GPIO_PIN_MASK(0)); GPIO_SET_INPUT(GPIO_PORT_TO_BASE(GPIO_C_NUM), GPIO_PIN_MASK(0)); GPIO_DETECT_EDGE(GPIO_PORT_TO_BASE(GPIO_C_NUM), GPIO_PIN_MASK(0)); GPIO_DETECT_RISING(GPIO_PORT_TO_BASE(GPIO_C_NUM), GPIO_PIN_MASK(0)); GPIO_ENABLE_INTERRUPT(GPIO_PORT_TO_BASE(GPIO_C_NUM), GPIO_PIN_MASK(0)); GPIO_SOFTWARE_CONTROL(GPIO_PORT_TO_BASE(GPIO_C_NUM), GPIO_PIN_MASK(2)); GPIO_SET_INPUT(GPIO_PORT_TO_BASE(GPIO_C_NUM), GPIO_PIN_MASK(2)); GPIO_DETECT_EDGE(GPIO_PORT_TO_BASE(GPIO_C_NUM), GPIO_PIN_MASK(2)); GPIO_DETECT_FALLING(GPIO_PORT_TO_BASE(GPIO_C_NUM), GPIO_PIN_MASK(2)); GPIO_ENABLE_INTERRUPT(GPIO_PORT_TO_BASE(GPIO_C_NUM), GPIO_PIN_MASK(2)); ioc_set_over(GPIO_C_NUM,0, IOC_OVERRIDE_PUE); ioc_set_over(GPIO_C_NUM,2, IOC_OVERRIDE_PUE); nvic_interrupt_enable(NVIC_INT_GPIO_PORT_C); gpio_register_callback(cb,GPIO_C_NUM,0); gpio_register_callback(cb,GPIO_C_NUM,2); }
void gpio_set(gpio_t dev) { int pin; if (!gpio_enabled(dev)) { return; } pin = pin_lut[dev]; GPIO_NUM_TO_DEV(pin)->DATA |= GPIO_PIN_MASK(GPIO_BIT_NUM(pin)); }
/*---------------------------------------------------------------------------*/ void i2c_init(uint8_t port_sda, uint8_t pin_sda, uint8_t port_scl, uint8_t pin_scl, uint32_t bus_speed) { /* Enable I2C clock in different modes */ REG(SYS_CTRL_RCGCI2C) |= 1; /* Run mode */ /* Reset I2C peripheral */ REG(SYS_CTRL_SRI2C) |= 1; /* Reset position */ /* Delay for a little bit */ clock_delay_usec(50); REG(SYS_CTRL_SRI2C) &= ~1; /* Normal position */ /* Set pins in input */ GPIO_SET_INPUT(GPIO_PORT_TO_BASE(port_sda), GPIO_PIN_MASK(pin_sda)); GPIO_SET_INPUT(GPIO_PORT_TO_BASE(port_scl), GPIO_PIN_MASK(pin_scl)); /* Set peripheral control for the pins */ GPIO_PERIPHERAL_CONTROL(GPIO_PORT_TO_BASE(port_sda), GPIO_PIN_MASK(pin_sda)); GPIO_PERIPHERAL_CONTROL(GPIO_PORT_TO_BASE(port_scl), GPIO_PIN_MASK(pin_scl)); /* Set the pad to no drive type */ ioc_set_over(port_sda, pin_sda, IOC_OVERRIDE_DIS); ioc_set_over(port_scl, pin_scl, IOC_OVERRIDE_DIS); /* Set pins as peripheral inputs */ REG(IOC_I2CMSSDA) = ioc_input_sel(port_sda, pin_sda); REG(IOC_I2CMSSCL) = ioc_input_sel(port_scl, pin_scl); /* Set pins as peripheral outputs */ ioc_set_sel(port_sda, pin_sda, IOC_PXX_SEL_I2C_CMSSDA); ioc_set_sel(port_scl, pin_scl, IOC_PXX_SEL_I2C_CMSSCL); /* Enable the I2C master module */ i2c_master_enable(); /* t the master clock frequency */ i2c_set_frequency(bus_speed); }
/*---------------------------------------------------------------------------*/ static int configure(int type, int value) { uint8_t pin_mask = GPIO_PIN_MASK(value); if((type != ANALOG_GROVE_LIGHT) && (type != ANALOG_PHIDGET_ROTATION_1109) && (type != ANALOG_GROVE_LOUDNESS)) { PRINTF("ADC sensors: sensor not supported, check adc_wrapper.h header\n"); return ADC_WRAPPER_ERROR; } if(sensors.sensors_num >= ADC_SENSORS_MAX) { PRINTF("ADC sensors: all adc channels available have been assigned\n"); return ADC_WRAPPER_ERROR; } if((value < 0x01) || (value > 0x07) || (value == BUTTON_USER_PIN)) { PRINTF("ADC sensors: invalid pin value, (PA0-PA1, PA3) are reserved\n"); return ADC_WRAPPER_ERROR; } if(sensors.sensors_ports & pin_mask) { PRINTF("ADC sensors: a sensor has been already assigned to this pin\n"); return ADC_WRAPPER_ERROR; } switch(type) { /* V+3.3 sensors */ case ANALOG_GROVE_LIGHT: case ANALOG_GROVE_LOUDNESS: case ANALOG_PHIDGET_ROTATION_1109: if(adc_zoul.configure(SENSORS_HW_INIT, pin_mask) == ZOUL_SENSORS_ERROR) { return ADC_WRAPPER_ERROR; } sensors.sensor[sensors.sensors_num].type = type; sensors.sensor[sensors.sensors_num].pin_mask = pin_mask; sensors.sensor[sensors.sensors_num].vdd3 = 1; break; default: return ADC_WRAPPER_ERROR; } PRINTF("ADC sensors: type %u mask 0x%02X vdd3 %u\n", sensors.sensor[sensors.sensors_num].type, sensors.sensor[sensors.sensors_num].pin_mask, sensors.sensor[sensors.sensors_num].vdd3); sensors.sensors_num++; sensors.sensors_ports |= pin_mask; return ADC_WRAPPER_SUCCESS; }
/*---------------------------------------------------------------------------*/ static void at_cmd_read_callback(struct at_cmd *cmd, uint8_t len, char *data) { /* Format: AT&READ=PN where P(ort)N(number), N can be "*" to read all */ uint8_t port, pin; char read_result[5]; if(strncmp(&data[9], "*", 1) == 0) { pin = 0xFF; } else { pin = atoi(&data[9]); } if((pin < 0) || (pin > 7)) { if(pin != 0xFF) { AT_RESPONSE(AT_DEFAULT_RESPONSE_ERROR); return; } } if(pin < 8) { pin = GPIO_PIN_MASK(pin); } /* Exclude PA0-PA3 */ if(strncmp(&data[8], "A", 1) == 0) { port = GPIO_A_NUM; if(pin < 0x1F) { AT_RESPONSE(AT_DEFAULT_RESPONSE_ERROR); return; } else { if(pin == 0xFF) { pin = 0xF0; } } } else if(strncmp(&data[8], "B", 1) == 0) { port = GPIO_B_NUM; } else if(strncmp(&data[8], "C", 1) == 0) { port = GPIO_C_NUM; } else if(strncmp(&data[8], "D", 1) == 0) { port = GPIO_D_NUM; } else { AT_RESPONSE(AT_DEFAULT_RESPONSE_ERROR); return; } config_gpio(port, pin, HWTEST_GPIO_INPUT); snprintf(read_result, 5, "0x%02X", (uint16_t)GPIO_READ_PIN(GPIO_PORT_TO_BASE(port), pin)); AT_RESPONSE(read_result); AT_RESPONSE(AT_DEFAULT_RESPONSE_OK); }
/** Routine Description: Gets the mode (function) of a GPIO pin Arguments: This - pointer to protocol Gpio - which pin Mode - pointer to output mode value Returns: EFI_SUCCESS - mode value retrieved EFI_INVALID_PARAMETER - Mode is a null pointer or Gpio pin is out of range **/ EFI_STATUS EFIAPI GetMode ( IN EMBEDDED_GPIO *This, IN EMBEDDED_GPIO_PIN Gpio, OUT EMBEDDED_GPIO_MODE *Mode ) { EFI_STATUS Status; UINTN Index, Offset, RegisterBase; Status = PL061Locate (Gpio, &Index, &Offset, &RegisterBase); if (EFI_ERROR (Status)) return Status; // Initialize the hardware if not already done if (!mPL061Initialized) { Status = PL061Initialize(); if (EFI_ERROR(Status)) { return Status; } } // Check if it is input or output if (MmioRead8 (RegisterBase + PL061_GPIO_DIR_REG) & GPIO_PIN_MASK(Offset)) { // Pin set to output if (MmioRead8 (RegisterBase + PL061_GPIO_DATA_REG + (GPIO_PIN_MASK(Offset) << 2))) { *Mode = GPIO_MODE_OUTPUT_1; } else { *Mode = GPIO_MODE_OUTPUT_0; } } else { // Pin set to input *Mode = GPIO_MODE_INPUT; } return EFI_SUCCESS; }
//Config PA1 as an PWM output pin void initPWM() { //Timer is 16Mhz /* Enable module clock for the GPTx in Active mode, GPT0 clock enable, CPU running */ REG(SYS_CTRL_RCGCGPT) |= SYS_CTRL_RCGCGPT_GPT0; disable_gptimer(); /* Use 16-bit timer */ REG(GPT_CONF_BASE + GPTIMER_CFG) = 0x04; /* Configure PWM mode, 0x00000008 Timer A alternate mode. */ REG(GPT_CONF_BASE + GPTIMER_TAMR) = 0; REG(GPT_CONF_BASE + GPTIMER_TAMR) |= GPTIMER_TAMR_TAAMS; /* To enable PWM mode, the TACM bit must be cleared and the lowest 2 bits (TAMR) field must be configured to 0x2. GPTIMER_TnMR bit values, GPTIMER_TAMR_TAMR_PERIODIC is 0x00000002 */ REG(GPT_CONF_BASE + GPTIMER_TAMR) |= GPTIMER_TAMR_TAMR_PERIODIC; //how often the counter is incremented: every pre-scaler / clock 16000000 seconds REG(GPT_CONF_BASE + GPTIMER_TAPR) = 0; //PRESCALER_VALUE /* Set the start value (period), count down */ REG(GPT_CONF_BASE+ GPTIMER_TAILR) = 16000; //frequency: 1kHz. 16000: 3E80, 16000000:F42400 /* Set the deassert period */ REG(GPT_CONF_BASE + GPTIMER_TAMATCHR) = 12800; //duty cycle: 20% so vibrator time is 20%. 800: 0x1F40, 8000000: 7A1200 // Defined in contiki/cpu/cc2538/dev/ioc.h /* Function select for Port:Pin. The third param sel can be any of the IOC_PXX_SEL_xyz defines. For example, IOC_PXX_SEL_UART0_TXD will set the port to act as UART0 TX. Selects one of the 32 pins on the four 8-pin I/O-ports (port A, port B, port C, and port D) to be the GPT0OCP1. Configure pin : PA:1 selected as GPT0OCP1*/ ioc_set_sel(PWM_GPIO_CONF_PORT, PWM_GPIO_CONF_PIN, IOC_CONF_SEL); /* Set Port:Pin override function, IOC_OVERRIDE_OE: Output */ ioc_set_over(PWM_GPIO_CONF_PORT, PWM_GPIO_CONF_PIN, IOC_OVERRIDE_OE); /* Configure the pin to be under peripheral control with PIN_MASK of port with PORT_BASE.*/ GPIO_PERIPHERAL_CONTROL(GPIO_PORT_TO_BASE(PWM_GPIO_CONF_PORT), GPIO_PIN_MASK(PWM_GPIO_CONF_PIN)); enable_gptimer(); }
void rv3049_init() { /* Set the HOLD_N and WP_N pins to outputs and high */ GPIO_SET_INPUT(GPIO_PORT_TO_BASE(RV3049_INT_N_PORT_NUM), GPIO_PIN_MASK(RV3049_INT_N_PIN)); spix_cs_init(RV3049_CS_PORT_NUM, RV3049_CS_PIN); SPI_CS_CLR(RV3049_CS_PORT_NUM, RV3049_CS_PIN); // Write the initial values { rv3049_time_t start_time = {RTC_SECONDS, RTC_MINUTES, RTC_HOURS, RTC_DAYS, RTC_WEEKDAY, RTC_MONTH, RTC_YEAR}; rv3049_set_time(&start_time); } }
/** Routine Description: Gets the state of a GPIO pin Arguments: This - pointer to protocol Gpio - which pin to read Value - state of the pin Returns: EFI_SUCCESS - GPIO state returned in Value EFI_INVALID_PARAMETER - Value is NULL pointer or Gpio pin is out of range **/ EFI_STATUS EFIAPI Get ( IN EMBEDDED_GPIO *This, IN EMBEDDED_GPIO_PIN Gpio, OUT UINTN *Value ) { EFI_STATUS Status = EFI_SUCCESS; UINTN Index, Offset, RegisterBase; Status = PL061Locate (Gpio, &Index, &Offset, &RegisterBase); if (EFI_ERROR (Status)) goto EXIT; if (Value == NULL) { Status = EFI_INVALID_PARAMETER; goto EXIT; } // Initialize the hardware if not already done if (!mPL061Initialized) { Status = PL061Initialize(); if (EFI_ERROR(Status)) { goto EXIT; } } if (MmioRead8 (RegisterBase + PL061_GPIO_DATA_REG + (GPIO_PIN_MASK(Offset) << 2))) { *Value = 1; } else { *Value = 0; } EXIT: return Status; }
/** * \brief Initialize the fm25lb. */ void fm25lb_init() { /* Set the HOLD_N and WP_N pins to outputs and high */ GPIO_SET_OUTPUT(GPIO_PORT_TO_BASE(FM25LB_HOLD_N_PORT_NUM), GPIO_PIN_MASK(FM25LB_HOLD_N_PIN)); GPIO_SET_OUTPUT(GPIO_PORT_TO_BASE(FM25LB_WP_N_PORT_NUM), GPIO_PIN_MASK(FM25LB_WP_N_PIN)); GPIO_SOFTWARE_CONTROL(GPIO_PORT_TO_BASE(FM25LB_HOLD_N_PORT_NUM), GPIO_PIN_MASK(FM25LB_HOLD_N_PIN)); GPIO_SOFTWARE_CONTROL(GPIO_PORT_TO_BASE(FM25LB_WP_N_PORT_NUM), GPIO_PIN_MASK(FM25LB_WP_N_PIN)); GPIO_SET_PIN(GPIO_PORT_TO_BASE(FM25LB_HOLD_N_PORT_NUM), GPIO_PIN_MASK(FM25LB_HOLD_N_PIN)); GPIO_SET_PIN(GPIO_PORT_TO_BASE(FM25LB_WP_N_PORT_NUM), GPIO_PIN_MASK(FM25LB_WP_N_PIN)); spi_cs_init(FM25LB_CS_N_PORT_NUM, FM25LB_CS_N_PIN); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(gpiot_process, ev, data) { PROCESS_BEGIN(); etimer_set(&periodic_timer_gpio, CLOCK_SECOND/10); GPIO_SOFTWARE_CONTROL(GPIO_PORT_TO_BASE(GPIO_C_NUM), GPIO_PIN_MASK(0)); GPIO_SET_INPUT(GPIO_PORT_TO_BASE(GPIO_C_NUM), GPIO_PIN_MASK(0));//input: pin: C0 GPIO_DETECT_EDGE(GPIO_PORT_TO_BASE(GPIO_C_NUM), GPIO_PIN_MASK(0)); GPIO_TRIGGER_SINGLE_EDGE(GPIO_PORT_TO_BASE(GPIO_C_NUM), GPIO_PIN_MASK(0)); GPIO_DETECT_RISING(GPIO_PORT_TO_BASE(GPIO_C_NUM), GPIO_PIN_MASK(0)); GPIO_ENABLE_INTERRUPT(GPIO_PORT_TO_BASE(GPIO_C_NUM), GPIO_PIN_MASK(0)); ioc_set_over(GPIO_C_NUM, 0, IOC_OVERRIDE_PUE); nvic_interrupt_enable(NVIC_INT_GPIO_PORT_C); gpio_register_callback(gp_int,GPIO_C_NUM, 0); while(1) { PROCESS_YIELD(); leds_toggle(LEDS_RED); etimer_restart(&periodic_timer_gpio); } PROCESS_END(); }
/** * \brief Initialize the FM25V02. */ void fm25v02_init() { #if defined(VERSION9) || defined(VERSION10) || defined(VERSION11) /* Set the HOLD_N and WP_N pins to outputs and high */ GPIO_SET_OUTPUT(GPIO_PORT_TO_BASE(FM25V02_HOLD_N_PORT_NUM), GPIO_PIN_MASK(FM25V02_HOLD_N_PIN)); GPIO_SET_OUTPUT(GPIO_PORT_TO_BASE(FM25V02_WP_N_PORT_NUM), GPIO_PIN_MASK(FM25V02_WP_N_PIN)); GPIO_SOFTWARE_CONTROL(GPIO_PORT_TO_BASE(FM25V02_HOLD_N_PORT_NUM), GPIO_PIN_MASK(FM25V02_HOLD_N_PIN)); GPIO_SOFTWARE_CONTROL(GPIO_PORT_TO_BASE(FM25V02_WP_N_PORT_NUM), GPIO_PIN_MASK(FM25V02_WP_N_PIN)); GPIO_SET_PIN(GPIO_PORT_TO_BASE(FM25V02_HOLD_N_PORT_NUM), GPIO_PIN_MASK(FM25V02_HOLD_N_PIN)); GPIO_SET_PIN(GPIO_PORT_TO_BASE(FM25V02_WP_N_PORT_NUM), GPIO_PIN_MASK(FM25V02_WP_N_PIN)); #endif spi_cs_init(FM25V02_CS_N_PORT_NUM, FM25V02_CS_N_PIN); SPI_CS_SET(FM25V02_CS_N_PORT_NUM, FM25V02_CS_N_PIN); }
/*---------------------------------------------------------------------------*/ void uart_init(uint8_t uart) { const uart_regs_t *regs; if(uart >= UART_INSTANCE_COUNT) { return; } regs = &uart_regs[uart]; if(regs->rx.port < 0 || regs->tx.port < 0) { return; } lpm_register_peripheral(permit_pm1); /* Enable clock for the UART while Running, in Sleep and Deep Sleep */ REG(SYS_CTRL_RCGCUART) |= regs->sys_ctrl_rcgcuart_uart; REG(SYS_CTRL_SCGCUART) |= regs->sys_ctrl_scgcuart_uart; REG(SYS_CTRL_DCGCUART) |= regs->sys_ctrl_dcgcuart_uart; /* Run on SYS_DIV */ REG(regs->base | UART_CC) = 0; /* * Select the UARTx RX pin by writing to the IOC_UARTRXD_UARTn register * * The value to be written will be on of the IOC_INPUT_SEL_Pxn defines from * ioc.h. The value can also be calculated as: * * (port << 3) + pin */ REG(regs->ioc_uartrxd_uart) = (regs->rx.port << 3) + regs->rx.pin; /* * Pad Control for the TX pin: * - Set function to UARTn TX * - Output Enable */ ioc_set_sel(regs->tx.port, regs->tx.pin, regs->ioc_pxx_sel_uart_txd); ioc_set_over(regs->tx.port, regs->tx.pin, IOC_OVERRIDE_OE); /* Set RX and TX pins to peripheral mode */ GPIO_PERIPHERAL_CONTROL(GPIO_PORT_TO_BASE(regs->tx.port), GPIO_PIN_MASK(regs->tx.pin)); GPIO_PERIPHERAL_CONTROL(GPIO_PORT_TO_BASE(regs->rx.port), GPIO_PIN_MASK(regs->rx.pin)); /* * UART Interrupt Masks: * Acknowledge RX and RX Timeout * Acknowledge Framing, Overrun and Break Errors */ REG(regs->base | UART_IM) = UART_IM_RXIM | UART_IM_RTIM; REG(regs->base | UART_IM) |= UART_IM_OEIM | UART_IM_BEIM | UART_IM_FEIM; REG(regs->base | UART_IFLS) = UART_IFLS_RXIFLSEL_1_8 | UART_IFLS_TXIFLSEL_1_2; /* Make sure the UART is disabled before trying to configure it */ REG(regs->base | UART_CTL) = UART_CTL_VALUE; /* Baud Rate Generation */ REG(regs->base | UART_IBRD) = regs->ibrd; REG(regs->base | UART_FBRD) = regs->fbrd; /* UART Control: 8N1 with FIFOs */ REG(regs->base | UART_LCRH) = UART_LCRH_WLEN_8 | UART_LCRH_FEN; /* * Enable hardware flow control (RTS/CTS) if requested. * Note that hardware flow control is available only on UART1. */ if(regs->cts.port >= 0) { REG(IOC_UARTCTS_UART1) = ioc_input_sel(regs->cts.port, regs->cts.pin); GPIO_PERIPHERAL_CONTROL(GPIO_PORT_TO_BASE(regs->cts.port), GPIO_PIN_MASK(regs->cts.pin)); ioc_set_over(regs->cts.port, regs->cts.pin, IOC_OVERRIDE_DIS); REG(UART_1_BASE | UART_CTL) |= UART_CTL_CTSEN; } if(regs->rts.port >= 0) { ioc_set_sel(regs->rts.port, regs->rts.pin, IOC_PXX_SEL_UART1_RTS); GPIO_PERIPHERAL_CONTROL(GPIO_PORT_TO_BASE(regs->rts.port), GPIO_PIN_MASK(regs->rts.pin)); ioc_set_over(regs->rts.port, regs->rts.pin, IOC_OVERRIDE_OE); REG(UART_1_BASE | UART_CTL) |= UART_CTL_RTSEN; } /* UART Enable */ REG(regs->base | UART_CTL) |= UART_CTL_UARTEN; /* Enable UART0 Interrupts */ nvic_interrupt_enable(regs->nvic_int); }
static void recv_handler(void) { char* str; int z; int tag1=0; int tag2=0; int tag3=0; int tag4=0; int tag5=0; //int tag5=0; str = uip_appdata; //printf("string is: '%s':",str); if (BLE==0) { set_bluetooth(); initPWM(); BLE=1; } // For Beacon 1 for (z=0; z<=2; z++) { if (str[z]==data1[z]) { tag1=1; } else { tag1=0; break; } } // For Beacon 2 for (z=0; z<=2; z++) { if (str[z]==data2[z]) { tag2=1; } else { tag2=0; break; } } // For Beacon 3 for (z=0; z<=2; z++) { if (str[z]==data3[z]) { tag3=1; } else { tag3=0; break; } } //For Beacon 4 for (z=0; z<=2; z++) { if (str[z]==data4[z]) { tag4=1; } else { tag4=0; break; } } for (z=0; z<=2; z++) { if (str[z]==data5[z]) { tag5=1; } else { tag5=0; break; } } if (tag5==1) { cycle=1; if (vat1==0) { GPIO_SET_OUTPUT(GPIO_C_BASE, GPIO_PIN_MASK(1)); GPIO_SET_PIN(GPIO_C_BASE, GPIO_PIN_MASK(1)); vat1=1; } else if (vat1==1) { GPIO_CLR_PIN(GPIO_C_BASE, GPIO_PIN_MASK(1)); vat1=0; } } else if (tag1==1) { IMU.RSS1=packetbuf_attr(PACKETBUF_ATTR_RSSI); //TODO: when approaching beacon1, start vibrate. if(IMU.RSS1 <= 100) { if(get_gptimer_state() == GPTIMER_OFF) {} //enable_gptimer(); } else { if(get_gptimer_state() == GPTIMER_ON) {} //disable_gptimer(); } } else if (tag2==1) { IMU.RSS2=packetbuf_attr(PACKETBUF_ATTR_RSSI); } else if (tag3==1) { IMU.RSS3=packetbuf_attr(PACKETBUF_ATTR_RSSI); } else if (tag4==1) { IMU.RSS4=packetbuf_attr(PACKETBUF_ATTR_RSSI); } }
void set_bluetooth() { GPIO_SET_OUTPUT(GPIO_D_BASE, GPIO_PIN_MASK(3)); GPIO_SET_PIN(GPIO_D_BASE, GPIO_PIN_MASK(3)); //Make sure the Reset is off on bluetooth //GPIO_SET_OUTPUT(GPIO_B_BASE, GPIO_PIN_MASK(0)); //GPIO_SET_PIN(GPIO_B_BASE, GPIO_PIN_MASK(0)); /* uart_write_byte(0,'P'); uart_write_byte(0,'O'); uart_write_byte(0,'W'); uart_write_byte(0,'E'); uart_write_byte(0,'R'); uart_write_byte(0,' '); uart_write_byte(0,'O'); uart_write_byte(0,'N'); uart_write_byte(0,'\r'); */ uart_write_byte(0,'R'); uart_write_byte(0,'E'); uart_write_byte(0,'S'); uart_write_byte(0,'T'); uart_write_byte(0,'O'); uart_write_byte(0,'R'); uart_write_byte(0,'E'); uart_write_byte(0,'\r'); Delay_ms(1000); uart_write_byte(0,'R'); uart_write_byte(0,'E'); uart_write_byte(0,'S'); uart_write_byte(0,'E'); uart_write_byte(0,'T'); uart_write_byte(0,'\r'); Delay_ms(400); //TODO: 'SET BAUD=115200\r' uart_write_byte(0,'S'); uart_write_byte(0,'E'); uart_write_byte(0,'T'); uart_write_byte(0,' '); uart_write_byte(0,'B'); uart_write_byte(0,'A'); uart_write_byte(0,'U'); uart_write_byte(0,'D'); uart_write_byte(0,'='); uart_write_byte(0,'1'); uart_write_byte(0,'1'); uart_write_byte(0,'5'); uart_write_byte(0,'2'); uart_write_byte(0,'0'); uart_write_byte(0,'0'); uart_write_byte(0,'\r'); Delay_ms(400); uart_write_byte(0,'w'); uart_write_byte(0,'r'); uart_write_byte(0,'i'); uart_write_byte(0,'t'); uart_write_byte(0,'e'); uart_write_byte(0,'\r'); Delay_ms(400); uart_write_byte(0,'R'); uart_write_byte(0,'E'); uart_write_byte(0,'S'); uart_write_byte(0,'E'); uart_write_byte(0,'T'); uart_write_byte(0,'\r'); Delay_ms(400); //TODO: change UART to 115200 after we set Bluetooth to 115200 set_uart_baud_rate(UART_CONF_BASE); uart_write_byte(0,'D'); uart_write_byte(0,'I'); uart_write_byte(0,'S'); uart_write_byte(0,'C'); uart_write_byte(0,'O'); uart_write_byte(0,'V'); uart_write_byte(0,'E'); uart_write_byte(0,'R'); uart_write_byte(0,'A'); uart_write_byte(0,'B'); uart_write_byte(0,'L'); uart_write_byte(0,'E'); uart_write_byte(0,' '); uart_write_byte(0,'O'); uart_write_byte(0,'N'); uart_write_byte(0,'\r'); Delay_ms(400); uart_write_byte(0,'A'); uart_write_byte(0,'U'); uart_write_byte(0,'T'); uart_write_byte(0,'O'); uart_write_byte(0,'C'); uart_write_byte(0,'O'); uart_write_byte(0,'N'); uart_write_byte(0,'N'); uart_write_byte(0,'='); uart_write_byte(0,'0'); uart_write_byte(0,'\r'); Delay_ms(400); uart_write_byte(0,'S'); uart_write_byte(0,'E'); uart_write_byte(0,'T'); uart_write_byte(0,' '); uart_write_byte(0,'D'); uart_write_byte(0,'E'); uart_write_byte(0,'E'); uart_write_byte(0,'P'); uart_write_byte(0,'_'); uart_write_byte(0,'S'); uart_write_byte(0,'L'); uart_write_byte(0,'E'); uart_write_byte(0,'E'); uart_write_byte(0,'P'); uart_write_byte(0,'='); uart_write_byte(0,'O'); uart_write_byte(0,'F'); uart_write_byte(0,'F'); uart_write_byte(0,'\r'); Delay_ms(400); uart_write_byte(0,'M'); uart_write_byte(0,'A'); uart_write_byte(0,'X'); uart_write_byte(0,'_'); uart_write_byte(0,'R'); uart_write_byte(0,'E'); uart_write_byte(0,'C'); uart_write_byte(0,'='); uart_write_byte(0,'0'); uart_write_byte(0,'\r'); Delay_ms(400); uart_write_byte(0,'S'); uart_write_byte(0,'E'); uart_write_byte(0,'T'); uart_write_byte(0,' '); uart_write_byte(0,'D'); uart_write_byte(0,'I'); uart_write_byte(0,'S'); uart_write_byte(0,'C'); uart_write_byte(0,'O'); uart_write_byte(0,'V'); uart_write_byte(0,'E'); uart_write_byte(0,'R'); uart_write_byte(0,'A'); uart_write_byte(0,'B'); uart_write_byte(0,'L'); uart_write_byte(0,'E'); uart_write_byte(0,'='); uart_write_byte(0,'2'); uart_write_byte(0,' '); uart_write_byte(0,'0'); uart_write_byte(0,'\r'); Delay_ms(400); uart_write_byte(0,'w'); uart_write_byte(0,'r'); uart_write_byte(0,'i'); uart_write_byte(0,'t'); uart_write_byte(0,'e'); uart_write_byte(0,'\r'); Delay_ms(400); uart_write_byte(0,'R'); uart_write_byte(0,'E'); uart_write_byte(0,'S'); uart_write_byte(0,'E'); uart_write_byte(0,'T'); uart_write_byte(0,'\r'); Delay_ms(400); uart_write_byte(0,'E'); uart_write_byte(0,'N'); uart_write_byte(0,'T'); uart_write_byte(0,'E'); uart_write_byte(0,'R'); uart_write_byte(0,'_'); uart_write_byte(0,'D'); uart_write_byte(0,'A'); uart_write_byte(0,'T'); uart_write_byte(0,'A'); uart_write_byte(0,'\r'); Delay_ms(400); }
PROCESS_THREAD(MPU_DATA, ev, data) { static struct etimer sdtimer; PROCESS_BEGIN(); if(isInitialized==0) { // Turn off 3.3-V domain (lcd/sdcard power, output low) //GPIOPinTypeGPIOOutput(BSP_3V3_EN_BASE, BSP_3V3_EN); //GPIOPinWrite(BSP_3V3_EN_BASE, BSP_3V3_EN, 0); GPIO_SET_OUTPUT(BSP_3V3_EN_BASE, BSP_3V3_EN); GPIO_CLR_PIN(BSP_3V3_EN_BASE, BSP_3V3_EN); // If 3.3-V domain is initially off, make sure it's off >1 ms for a complete // sd card power cycle // Approx 10 ms delay Delay_ms(10); // Enable 3.3-V domain (it takes <= 600 us to stabilize) //GPIOPinWrite(BSP_3V3_EN_BASE, BSP_3V3_EN, BSP_3V3_EN); // high GPIO_SET_PIN(BSP_3V3_EN_BASE, BSP_3V3_EN); Delay_ms(100);//100ms //Disable LCD //GPIOPinTypeGPIOOutput(GPIO_B_BASE, (5)); //GPIOPinWrite(GPIO_B_BASE, (5), (5)); GPIO_SET_OUTPUT(GPIO_B_BASE, GPIO_PIN_MASK(5)); GPIO_SET_PIN(GPIO_B_BASE, GPIO_PIN_MASK(5)); GPIO_SET_INPUT(GPIO_B_BASE, GPIO_PIN_MASK(3)); GPIO_CLEAR_INTERRUPT(GPIO_B_BASE, 0xFF); GPIO_ENABLE_INTERRUPT(GPIO_B_BASE, 0X08); GPIO_DETECT_RISING(GPIO_B_BASE, 0X08); //Turn on Bluetooth //GPIO_SET_OUTPUT(GPIO_D_BASE, GPIO_PIN_MASK(3)); //GPIO_SET_PIN(GPIO_D_BASE, GPIO_PIN_MASK(3)); uart_init(UART_CONF_BASE); GPIO_SET_OUTPUT(GPIO_B_BASE, GPIO_PIN_MASK(6)); GPIO_CLR_PIN(GPIO_B_BASE, GPIO_PIN_MASK(6)); clock_delay(6000); GPIO_SET_PIN(GPIO_B_BASE, GPIO_PIN_MASK(6)); clock_delay(6000); init_i2c(); clock_delay(6000); init_MPU9150 (); isInitialized = 1; } while(1) { // PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&sdtimer)); //GPIO_SET_PIN(GPIO_C_BASE, lGPIO_PIN_MASK(2)); etimer_set(&sdtimer, CLOCK_SECOND/400); //TODO: change from 80 ---> 200 PROCESS_YIELD(); //GPIO_SET_PIN(GPIO_C_BASE, GPIO_PIN_MASK(1)); #define GPIO_B_BASE 0x400DA000 // GPIO #define GPIO_PIN_3 0x00000008 // GPIO pin 3 uint32_t gpio = REG(GPIO_B_BASE + (0x00000000 + (GPIO_PIN_3 << 2))) & GPIO_PIN_3; if(gpio) { read_sensor_data(IMU.Payload); PKT_NUM ++; IMU_PACKET[0]=IMU.Payload[0]; IMU_PACKET[1]=IMU.Payload[1]; IMU_PACKET[2]=IMU.Payload[2]; IMU_PACKET[3]=IMU.Payload[3]; IMU_PACKET[4]=IMU.Payload[4]; IMU_PACKET[5]=IMU.Payload[5]; IMU_PACKET[6]=IMU.Payload[6]; IMU_PACKET[7]=IMU.Payload[7]; IMU_PACKET[8]=IMU.Payload[8]; IMU_PACKET[9]=IMU.Payload[9]; IMU_PACKET[10]=IMU.Payload[10]; IMU_PACKET[11]=IMU.Payload[11]; IMU_PACKET[12]=IMU.Payload[12]; IMU_PACKET[13]=IMU.Payload[13]; IMU_PACKET[14]=IMU.Payload[14]; IMU_PACKET[15]=IMU.Payload[15]; IMU_PACKET[16]=IMU.Payload[16]; IMU_PACKET[17]=IMU.Payload[17]; if (cycle==1) { IMU_PACKET[18]=IMU.RSS1; IMU_PACKET[19]=IMU.RSS2; IMU_PACKET[20]=IMU.RSS3; IMU_PACKET[21]=IMU.RSS4; if (vat==0) { GPIO_SET_OUTPUT(GPIO_C_BASE, GPIO_PIN_MASK(0)); GPIO_SET_PIN(GPIO_C_BASE, GPIO_PIN_MASK(0)); vat=1; } else if (vat==1) { GPIO_CLR_PIN(GPIO_C_BASE, GPIO_PIN_MASK(0)); vat=0; } cycle=0; } else if (cycle==0) { IMU_PACKET[18]=0; IMU_PACKET[19]=0; IMU_PACKET[20]=0; IMU_PACKET[21]=0; } // Add packet number, so we can detect packet loss. IMU_PACKET[22]=PKT_NUM & 0x00ff; IMU_PACKET[23]=PKT_NUM >> 8 & 0x00ff ; unsigned char outLen = 0; byteStuff (&IMU_PACKET[0], PKT_LEN, outPkt, &outLen); char i; for(i=0; i<outLen; i++) { uart_write_byte(0,outPkt[i]); } } //push_data_to_buffer_imu(); /* if ((stage_imu==1) &&(SD_BUSY==0)) writedata_imu(); */ } PROCESS_END(); }
void configGPIOOuput(){ GPIO_SOFTWARE_CONTROL(GPIO_PORT_TO_BASE(GPIO_C_NUM), GPIO_PIN_MASK(1)); GPIO_SET_OUTPUT(GPIO_PORT_TO_BASE(GPIO_C_NUM), GPIO_PIN_MASK(1)); }
void set_up_single_driver_gpio(uint32_t gpio_port_num, uint32_t gpio_pin_num) { GPIO_SOFTWARE_CONTROL(GPIO_PORT_TO_BASE(gpio_port_num), GPIO_PIN_MASK(gpio_pin_num)); GPIO_SET_OUTPUT(GPIO_PORT_TO_BASE(gpio_port_num), GPIO_PIN_MASK(gpio_pin_num)); ioc_set_over(gpio_port_num, gpio_pin_num, IOC_OVERRIDE_OE); }