/*---------------------------------------------------------------------------*/ unsigned char leds_arch_get(void) { #if DISCOVERY return GPIO_READ_PIN(GPIO_C_BASE, LEDS_GPIO_PIN_MASK); #else//DISCOVERY return GPIO_READ_PIN(GPIO_B_BASE, LEDS_GPIO_PIN_MASK); #endif//DISCOVERY }
/*---------------------------------------------------------------------------*/ unsigned char leds_arch_get(void) { uint8_t mask_leds; mask_leds = GPIO_READ_PIN(LED_GREEN_PORT, LED_GREEN_PIN) == 0? LEDS_GREEN : 0; mask_leds |= GPIO_READ_PIN(LED_BLUE_PORT, LED_BLUE_PIN) == 0? LEDS_BLUE : 0; mask_leds |= GPIO_READ_PIN(LED_RED_PORT, LED_RED_PIN) == 0? LEDS_RED : 0; return mask_leds; }
/*---------------------------------------------------------------------------*/ unsigned char leds_arch_get(void) { uint8_t mask_leds; mask_leds = GPIO_READ_PIN(LEDS_GREEN_PORT_BASE, LEDS_GREEN_PIN_MASK) == 0 ? 0: LEDS_GREEN; mask_leds |= GPIO_READ_PIN(LEDS_BLUE_PORT_BASE, LEDS_BLUE_PIN_MASK) == 0 ? 0 : LEDS_BLUE; mask_leds |= GPIO_READ_PIN(LEDS_RED_PORT_BASE, LEDS_RED_PIN_MASK) == 0 ? 0 : LEDS_RED; return mask_leds; }
/*---------------------------------------------------------------------------*/ void cc1200_arch_init(void) { /* First leave RESET high */ GPIO_SOFTWARE_CONTROL(CC1200_RESET_PORT_BASE, CC1200_RESET_PIN_MASK); GPIO_SET_OUTPUT(CC1200_RESET_PORT_BASE, CC1200_RESET_PIN_MASK); ioc_set_over(CC1200_RESET_PORT, CC1200_RESET_PIN, IOC_OVERRIDE_OE); GPIO_SET_PIN(CC1200_RESET_PORT_BASE, CC1200_RESET_PIN_MASK); /* Initialize CSn, enable CSn and then wait for MISO to go low*/ spix_cs_init(CC1200_SPI_CSN_PORT, CC1200_SPI_CSN_PIN); /* Initialize SPI */ spix_init(CC1200_SPI_INSTANCE); /* Configure GPIOx */ GPIO_SOFTWARE_CONTROL(CC1200_GDO0_PORT_BASE, CC1200_GDO0_PIN_MASK); GPIO_SET_INPUT(CC1200_GDO0_PORT_BASE, CC1200_GDO0_PIN_MASK); GPIO_SOFTWARE_CONTROL(CC1200_GDO2_PORT_BASE, CC1200_GDO2_PIN_MASK); GPIO_SET_INPUT(CC1200_GDO2_PORT_BASE, CC1200_GDO2_PIN_MASK); /* Leave CSn as default */ cc1200_arch_spi_deselect(); /* Ensure MISO is high */ BUSYWAIT_UNTIL( GPIO_READ_PIN(CC1200_SPI_MISO_PORT_BASE, CC1200_SPI_MISO_PIN_MASK), RTIMER_SECOND / 10); }
/*---------------------------------------------------------------------------*/ static int user_button_value(int type) { return (GPIO_READ_PIN(USER_BUTTON_PORT_BASE, USER_BUTTON_PIN_MASK) == 0) || !timer_expired(&debouncetimer); }
/*---------------------------------------------------------------------------*/ void cc1200_arch_spi_select(void) { /* Set CSn to low (0) */ GPIO_CLR_PIN(CC1200_SPI_CSN_PORT_BASE, CC1200_SPI_CSN_PIN_MASK); /* The MISO pin should go low before chip is fully enabled. */ BUSYWAIT_UNTIL( GPIO_READ_PIN(CC1200_SPI_MISO_PORT_BASE, CC1200_SPI_MISO_PIN_MASK) == 0, RTIMER_SECOND / 100); }
/*---------------------------------------------------------------------------*/ static int value_GPIO2(int type) { if (type == BUTTON_SENSOR_VALUE_STATE) { return GPIO_READ_PIN(GPIO_D_BASE, 0x4 ) == 0 ? BUTTON_SENSOR_VALUE_PRESSED : BUTTON_SENSOR_VALUE_RELEASED; } else if(type == BUTTON_SENSOR_VALUE_DURATION) return (int)GPIO2_timer.duration; return 0; }
/*---------------------------------------------------------------------------*/ int mp3_wtv020sd_busy(void) { if((initialized != MP3_WTV020SD_GPIO_MODE) && (initialized != MP3_WTV020SD_LINE_MODE)) { return MP3_WTV020SD_ERROR; } if(GPIO_READ_PIN(MP3_BUSY_PORT_BASE, MP3_BUSY_PIN_MASK)) { return MP3_WTV020SD_BUSY; } return MP3_WTV020SD_IDLE; }
/** * \brief Retrieves the value of the button pin * \param type Returns the pin level or the counter of press duration events. * type == BUTTON_SENSOR_VALUE_TYPE_LEVEL or * type == BUTTON_SENSOR_VALUE_TYPE_PRESS_DURATION * respectively */ static int value(int type) { switch(type) { case BUTTON_SENSOR_VALUE_TYPE_LEVEL: return GPIO_READ_PIN(BUTTON_USER_PORT_BASE, BUTTON_USER_PIN_MASK); case BUTTON_SENSOR_VALUE_TYPE_PRESS_DURATION: return press_event_counter; } return 0; }
/*---------------------------------------------------------------------------*/ 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); }
/*---------------------------------------------------------------------------*/ int led_strip_get(void) { if(!initialized) { return LED_STRIP_ERROR; } /* Inverse logic, return ON if the pin is low */ if(GPIO_READ_PIN(LED_STRIP_PORT_BASE, LED_STRIP_PIN_MASK)) { return LED_STRIP_OFF; } return LED_STRIP_ON; }
// IRQ handler - where the timing takes place static irqreturn_t irq_handler(int i, void *blah, struct pt_regs *regs) { struct timeval tv; long deltv; int signal; // use the GPIO signal level signal = GPIO_READ_PIN(gpio_pin); /* reset interrupt */ GPIO_INT_CLEAR(gpio_pin); if(signal==1) // positive rising do_gettimeofday(&lasttv); else { // negative rising do_gettimeofday(&tv); // get time since last interrupt in microseconds deltv = tv.tv_sec-lasttv.tv_sec; pwm_data = (unsigned int) (deltv*1000000 + (tv.tv_usec - lasttv.tv_usec)); } return IRQ_HANDLED; }
/*---------------------------------------------------------------------------*/ static int value(int type) { return GPIO_READ_PIN(MOTION_SENSOR_PORT_BASE, MOTION_SENSOR_PIN_MASK); }
/*---------------------------------------------------------------------------*/ static void cs_isr(uint8_t port, uint8_t pin) { int d, i; /* check if ISR comes from CS pin */ if((port != SPI_CS_PORT) && (pin != SPI_CS_PIN)) { return; } /* CS goes HIGH, End of Transmission */ if(GPIO_READ_PIN(SPI_CS_PORT_BASE, SPI_CS_PIN_MASK)) { /* check if something left in RX FIFO after transaction, and put all remain data into RX ringbuffer */ while(REG(SSI0_BASE + SSI_SR) & SSI_SR_RNE) { d = REG(SSI0_BASE + SSI_DR); ringbuf_put(&spi_rx_buf, d); PRINTF("ERR: Something left in FIFO!\r\n"); } /* pass received data to upper level driver via callback */ d = ringbuf_get(&spi_rx_buf); while(d != -1) { if(input_callback) { input_callback((unsigned char)d); } d = ringbuf_get(&spi_rx_buf); } /* mark that there is no start of frame phase */ /* TODO: is it necessary? */ start_of_frame = 0; /* check if TX FIFO is not empty */ if(!(REG(SSI0_BASE + SSI_SR) & SSI_SR_TNF)) { /* if TX FIFO is not empty, reset SSI to flush TX FIFO it is possible that previous transaction has been failed, so complete frame has not been transmitted. Eg. NBR has been turned off during transmission */ PRINTF("ERR: TX FIFO not empty after transaction!\r\n"); ssi_reset_request = 3; } if(ssi_reset_request) { /* if reset request is active, perform SSI reset */ PRINTF("WARN: SSI reset request %u\r\n", ssi_reset_request); ssi_reconfigure(1); ssi_reset_request = 0; } } else { /* CS goes LOW, Start of Transmission */ start_of_frame = 1; /* fill TX FIFO with data only if we were connected */ if(connected) { /* get number of elements in ringbuffer */ d = ringbuf_elements(&spi_tx_buf); /* send that number to master with characteristic upper nibble */ d = 0x50 | (d > 7 ? 7 : d); REG(SSI0_BASE + SSI_DR) = d; for(i = 0; i < 7; i++) { if(!(REG(SSI0_BASE + SSI_SR) & SSI_SR_TNF)) { /* Error, we shouldn't overflow TX FIFO */ PRINTF("ERR: TX FIFO overflow!\r\n"); break; } d = ringbuf_get(&spi_tx_buf); if(d == -1) { REG(SSI0_BASE + SSI_DR) = 0xff; } else { REG(SSI0_BASE + SSI_DR) = d; } } /* If the CS interrupt was triggered due to slave requesting SPI transfer, * we clear the INT pin, as the transfer has now been completed. */ if(ringbuf_elements(&spi_tx_buf) == 0) { GPIO_CLR_PIN(SPI_INT_PORT_BASE, SPI_INT_PIN_MASK); } } else { /* mark we are connected */ connected = 1; } } }
/*---------------------------------------------------------------------------*/ unsigned char leds_arch_get(void) { return GPIO_READ_PIN(GPIO_C_BASE, LEDS_GPIO_PIN_MASK); }
/*---------------------------------------------------------------------------*/ int cc1200_arch_gpio2_read_pin(void) { return GPIO_READ_PIN(CC1200_GDO2_PORT_BASE, CC1200_GDO2_PIN_MASK); }
/*---------------------------------------------------------------------------*/ int cc1200_arch_gpio0_read_pin(void) { return (GPIO_READ_PIN(CC1200_GDO0_PORT_BASE, CC1200_GDO0_PIN_MASK) ? 1 : 0); }
void GPIO_timer_callback(void *n) { static uint8_t GPIO_handle; GPIO_handle = n; switch (GPIO_handle) { case 0x10: if (GPIO_READ_PIN(GPIO_C_BASE, GPIO_handle ) == 0) { onboard_timer.start = clock_time(); onboard_timer.duration = 0; onboard_timer.status = 0xAA; } else if (onboard_timer.status==0xAA) { onboard_timer.duration = clock_time() - onboard_timer.start; sensors_changed(&button_onboard_sensor); onboard_timer.status = 0; } break; case 0x1: if (GPIO_READ_PIN(GPIO_D_BASE, GPIO_handle ) == 0) { GPIO1_timer.start = clock_time(); GPIO1_timer.duration = 0; GPIO1_timer.status = 0xAA; } else { GPIO1_timer.duration = clock_time() - GPIO1_timer.start; sensors_changed(&button_GPIO1_sensor); GPIO1_timer.status = 0x0; } break; case 0x2: if (GPIO_READ_PIN(GPIO_D_BASE, GPIO_handle ) == 0) { GPIO0_timer.start = clock_time(); GPIO0_timer.duration = 0; GPIO0_timer.status = 0xAA; } else { GPIO0_timer.duration = clock_time() - GPIO0_timer.start; sensors_changed(&button_GPIO0_sensor); GPIO0_timer.status = 0x0; } break; case 0x4: if (GPIO_READ_PIN(GPIO_D_BASE, GPIO_handle ) == 0) { leds_on(LEDS_RED); clock_delay_usec(1000); leds_off(LEDS_RED); GPIO2_timer.start = clock_time(); GPIO2_timer.duration = 0; GPIO2_timer.status = 0xAA; } else if (GPIO2_timer.status==0xAA){ leds_on(LEDS_GREEN); clock_delay_usec(1000); leds_off(LEDS_GREEN); GPIO2_timer.duration = clock_time() - GPIO2_timer.start; sensors_changed(&button_GPIO2_sensor); GPIO2_timer.status = 0x0; } break; } }