/*---------------------------------------------------------------------------*/
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;
}
}
