/*---------------------------------------------------------------------------*/ int mp3_line_command(uint16_t cmd) { uint16_t mask; if(initialized != MP3_WTV020SD_LINE_MODE) { return MP3_WTV020SD_ERROR; } GPIO_CLR_PIN(MP3_CLK_PORT_BASE, MP3_CLK_PIN_MASK); clock_delay_usec(MP3_USEC_CMD_DELAY / 10); for(mask = 0x8000; mask > 0; mask >> 1) { GPIO_CLR_PIN(MP3_CLK_PORT_BASE, MP3_CLK_PIN_MASK); clock_delay_usec(MP3_USEC_CMD_DELAY / 2); if(cmd & mask) { GPIO_SET_PIN(MP3_DATA_PORT_BASE, MP3_DATA_PIN_MASK); } else { GPIO_CLR_PIN(MP3_DATA_PORT_BASE, MP3_DATA_PIN_MASK); } clock_delay_usec(MP3_USEC_CMD_DELAY / 2); GPIO_SET_PIN(MP3_CLK_PORT_BASE, MP3_CLK_PIN_MASK); clock_delay_usec(MP3_USEC_CMD_DELAY); if(mask > 0x0001) { clock_delay_usec(MP3_USEC_CMD_DELAY / 10); } } clock_delay_usec(MP3_USEC_CMD_DELAY / 8); return MP3_WTV020SD_SUCCESS; }
/*---------------------------------------------------------------------------*/ 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 leds_arch_init(void) { /* Initialize LED2 (Green) and LED3 (Blue) */ GPIO_SOFTWARE_CONTROL(GPIO_B_BASE, LEDS_PORTB_PIN_MASK); GPIO_SET_OUTPUT(GPIO_B_BASE, LEDS_PORTB_PIN_MASK); GPIO_CLR_PIN(GPIO_B_BASE, LEDS_PORTB_PIN_MASK); /* Initialize LED1 (Red) */ GPIO_SOFTWARE_CONTROL(LEDS_RED_PORT_BASE, LEDS_RED_PIN_MASK); GPIO_SET_OUTPUT(LEDS_RED_PORT_BASE, LEDS_RED_PIN_MASK); GPIO_CLR_PIN(LEDS_RED_PORT_BASE, LEDS_RED_PIN_MASK); }
/*---------------------------------------------------------------------------*/ int mp3_wtv020sd_reset(void) { if(initialized != MP3_WTV020SD_LINE_MODE) { return MP3_WTV020SD_ERROR; } GPIO_CLR_PIN(MP3_CLK_PORT_BASE, MP3_CLK_PIN_MASK); GPIO_SET_PIN(MP3_RESET_PORT_BASE, MP3_RESET_PIN_MASK); GPIO_CLR_PIN(MP3_RESET_PORT_BASE, MP3_RESET_PIN_MASK); clock_delay_usec(MP3_USEC_DELAY); GPIO_SET_PIN(MP3_RESET_PORT_BASE, MP3_RESET_PIN_MASK); GPIO_SET_PIN(MP3_CLK_PORT_BASE, MP3_CLK_PIN_MASK); clock_delay_usec(MP3_USEC_RESET_DELAY); return MP3_WTV020SD_SUCCESS; }
/* -------------------------------------------------------------------------- */ int8_t pm_init(void) { /* Configure and clear immediately */ GPIO_SOFTWARE_CONTROL(PM_DONE_PORT_BASE, PM_DONE_PIN_MASK); GPIO_SET_OUTPUT(PM_DONE_PORT_BASE, PM_DONE_PIN_MASK); GPIO_CLR_PIN(PM_DONE_PORT_BASE, PM_DONE_PIN_MASK); /* Set as output/low to set IDLE state */ GPIO_SOFTWARE_CONTROL(PM_CMD_PORT_BASE, PM_CMD_PIN_MASK); PM_CMD_AS_OUTPUT; PM_CMD_LINE_CLR; /* Ensure the battery charger is on, so we don't lock ourselves out and left * stranded in a state the CC2538 and components are kept off */ if(pm_send_cmd(PM_CMD_PWR_ON) == PM_SUCCESS) { initialized = 1; PRINTF("PM: Initialized\n"); return PM_SUCCESS; } PRINTF("PM: Failed to initialize\n"); return PM_ERROR; }
/*---------------------------------------------------------------------------*/ int mp3_wtv020sd_gpio_play(void) { if(initialized != MP3_WTV020SD_GPIO_MODE) { return MP3_WTV020SD_ERROR; } GPIO_CLR_PIN(MP3_PLAY_PORT_BASE, MP3_PLAY_PIN_MASK); return MP3_WTV020SD_SUCCESS; }
/*---------------------------------------------------------------------------*/ 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); }
/*---------------------------------------------------------------------------*/ int mp3_wtv020sd_gpio_next(void) { if(initialized != MP3_WTV020SD_GPIO_MODE) { return MP3_WTV020SD_ERROR; } GPIO_CLR_PIN(MP3_PLAY_PORT_BASE, MP3_PLAY_PIN_MASK); clock_delay_usec(MP3_USEC_DELAY); GPIO_SET_PIN(MP3_PLAY_PORT_BASE, MP3_PLAY_PIN_MASK); return MP3_WTV020SD_SUCCESS; }
/** * @brief Timer0 IRQHandler * * @param None * * @return None * * @details Toggles PIN64:PB8_TM0 every 10ms and PIN10:PB4_LED blinks every 1s at Duty=10%. */ void TMR0_IRQHandler(void) { static uint16_t Relay = 0 ; //Every 100 times = 1s if(++Relay >= PERIOD_LIGHT){ Relay = 0 ; } if(Relay < Light) GPIO_CLR_PIN(PB4) ; else GPIO_SET_PIN(PB4) ; TIM_CLEAR_INTERRUPT_FLAG(TIMER0) ; //Clear IF flag }
/*---------------------------------------------------------------------------*/ void leds_arch_set(unsigned char leds) { if(leds & LEDS_GREEN) { GPIO_SET_PIN(LEDS_GREEN_PORT_BASE, LEDS_GREEN_PIN_MASK); } else { GPIO_CLR_PIN(LEDS_GREEN_PORT_BASE, LEDS_GREEN_PIN_MASK); } if(leds & LEDS_BLUE) { GPIO_SET_PIN(LEDS_BLUE_PORT_BASE, LEDS_BLUE_PIN_MASK); } else { GPIO_CLR_PIN(LEDS_BLUE_PORT_BASE, LEDS_BLUE_PIN_MASK); } if(leds & LEDS_RED) { GPIO_SET_PIN(LEDS_RED_PORT_BASE, LEDS_RED_PIN_MASK); } else { GPIO_CLR_PIN(LEDS_RED_PORT_BASE, LEDS_RED_PIN_MASK); } }
/*---------------------------------------------------------------------------*/ static int configure(int type, int value) { if(type != SENSORS_ACTIVE) { return DIMMER_ERROR; } if(value) { /* This is the Triac's gate pin */ GPIO_SOFTWARE_CONTROL(DIMMER_GATE_PORT_BASE, DIMMER_GATE_PIN_MASK); GPIO_SET_OUTPUT(DIMMER_GATE_PORT_BASE, DIMMER_GATE_PIN_MASK); ioc_set_over(DIMMER_GATE_PORT, DIMMER_GATE_PIN, IOC_OVERRIDE_OE); GPIO_CLR_PIN(DIMMER_GATE_PORT_BASE, DIMMER_GATE_PIN_MASK); /* This is the zero-crossing pin and interrupt */ GPIO_SOFTWARE_CONTROL(DIMMER_SYNC_PORT_BASE, DIMMER_SYNC_PIN_MASK); GPIO_SET_INPUT(DIMMER_SYNC_PORT_BASE, DIMMER_SYNC_PIN_MASK); /* Pull-up resistor, detect rising edge */ GPIO_DETECT_EDGE(DIMMER_SYNC_PORT_BASE, DIMMER_SYNC_PIN_MASK); GPIO_TRIGGER_SINGLE_EDGE(DIMMER_SYNC_PORT_BASE, DIMMER_SYNC_PIN_MASK); GPIO_DETECT_RISING(DIMMER_SYNC_PORT_BASE, DIMMER_SYNC_PIN_MASK); gpio_register_callback(dimmer_zero_cross_int_handler, DIMMER_SYNC_PORT, DIMMER_SYNC_PIN); /* Spin process until an interrupt is received */ process_start(&ac_dimmer_int_process, NULL); /* Enable interrupts */ GPIO_ENABLE_INTERRUPT(DIMMER_SYNC_PORT_BASE, DIMMER_SYNC_PIN_MASK); // ioc_set_over(DIMMER_SYNC_PORT, DIMMER_SYNC_PIN, IOC_OVERRIDE_PUE); NVIC_EnableIRQ(DIMMER_INT_VECTOR); enabled = 1; dimming = DIMMER_DEFAULT_START_VALUE; return DIMMER_SUCCESS; } /* Disable interrupt and pins */ GPIO_DISABLE_INTERRUPT(DIMMER_SYNC_PORT_BASE, DIMMER_SYNC_PIN_MASK); GPIO_SET_INPUT(DIMMER_GATE_PORT_BASE, DIMMER_GATE_PIN_MASK); GPIO_SET_OUTPUT(DIMMER_SYNC_PORT_BASE, DIMMER_SYNC_PIN_MASK); process_exit(&ac_dimmer_int_process); enabled = 0; dimming = 0; return DIMMER_SUCCESS; }
/*---------------------------------------------------------------------------*/ void felicia_spi_init(void) { /* Initialize ring buffers for RX and TX data */ ringbuf_init(&spi_rx_buf, rxbuf_data, sizeof(rxbuf_data)); ringbuf_init(&spi_tx_buf, txbuf_data, sizeof(txbuf_data)); /* Configre SSI interface and init TX FIFO */ ssi_reconfigure(1); /* Set the mux correctly to connect the SSI pins to the correct GPIO pins */ /* set input pin with ioc */ REG(IOC_CLK_SSIIN_SSI0) = ioc_input_sel(SPI_CLK_PORT, SPI_CLK_PIN); REG(IOC_SSIFSSIN_SSI0) = ioc_input_sel(SPI_SEL_PORT, SPI_SEL_PIN); REG(IOC_SSIRXD_SSI0) = ioc_input_sel(SPI_MOSI_PORT, SPI_MOSI_PIN); /* set output pin */ ioc_set_sel(SPI_MISO_PORT, SPI_MISO_PIN, IOC_PXX_SEL_SSI0_TXD); /* Set pins as input and MISo as output */ GPIO_SET_INPUT(SPI_CLK_PORT_BASE, SPI_CLK_PIN_MASK); GPIO_SET_INPUT(SPI_MOSI_PORT_BASE, SPI_MOSI_PIN_MASK); GPIO_SET_INPUT(SPI_SEL_PORT_BASE, SPI_SEL_PIN_MASK); /* it seems that setting SEL as input is not necessary */ GPIO_SET_OUTPUT(SPI_MISO_PORT_BASE, SPI_MISO_PIN_MASK); /* Put all the SSI gpios into peripheral mode */ GPIO_PERIPHERAL_CONTROL(SPI_CLK_PORT_BASE, SPI_CLK_PIN_MASK); GPIO_PERIPHERAL_CONTROL(SPI_MOSI_PORT_BASE, SPI_MOSI_PIN_MASK); GPIO_PERIPHERAL_CONTROL(SPI_MISO_PORT_BASE, SPI_MISO_PIN_MASK); GPIO_PERIPHERAL_CONTROL(SPI_SEL_PORT_BASE, SPI_SEL_PIN_MASK); /* it seems that setting SEL: as peripheral controlled is not necessary */ /* Disable any pull ups or the like */ ioc_set_over(SPI_CLK_PORT, SPI_CLK_PIN, IOC_OVERRIDE_DIS); ioc_set_over(SPI_MOSI_PORT, SPI_MOSI_PIN, IOC_OVERRIDE_DIS); ioc_set_over(SPI_MISO_PORT, SPI_MISO_PIN, IOC_OVERRIDE_DIS); ioc_set_over(SPI_SEL_PORT, SPI_SEL_PIN, IOC_OVERRIDE_PDE); /* it seems that configuring pull-ups/downs on SEL is not necessary */ /* Configure output INT pin (from Felicia to Host */ GPIO_SET_OUTPUT(SPI_INT_PORT_BASE, SPI_INT_PIN_MASK); GPIO_CLR_PIN(SPI_INT_PORT_BASE, SPI_INT_PIN_MASK); /* Configure CS pin and detection for both edges on that pin */ GPIO_SOFTWARE_CONTROL(SPI_CS_PORT_BASE, SPI_CS_PIN_MASK); GPIO_SET_INPUT(SPI_CS_PORT_BASE, SPI_CS_PIN_MASK); GPIO_DETECT_EDGE(SPI_CS_PORT_BASE, SPI_CS_PIN_MASK); GPIO_TRIGGER_BOTH_EDGES(SPI_CS_PORT_BASE, SPI_CS_PIN_MASK); GPIO_ENABLE_INTERRUPT(SPI_CS_PORT_BASE, SPI_CS_PIN_MASK); ioc_set_over(SPI_CS_PORT, SPI_CS_PIN, IOC_OVERRIDE_PUE); /* Enable interrupt form CS pin */ nvic_interrupt_enable(NVIC_INT_GPIO_PORT_B); gpio_register_callback(cs_isr, SPI_CS_PORT, SPI_CS_PIN); }
/*---------------------------------------------------------------------------*/ static int value(int type) { uint8_t channel = SOC_ADC_ADCCON_CH_AIN0 + ADC_ALS_OUT_PIN; int16_t res; GPIO_SET_PIN(ADC_ALS_PWR_PORT_BASE, ADC_ALS_PWR_PIN_MASK); clock_delay_usec(2000); res = adc_get(channel, SOC_ADC_ADCCON_REF_INT, SOC_ADC_ADCCON_DIV_512); GPIO_CLR_PIN(ADC_ALS_PWR_PORT_BASE, ADC_ALS_PWR_PIN_MASK); return res; }
/*---------------------------------------------------------------------------*/ 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); }
/*---------------------------------------------------------------------------*/ static int configure(int type, int value) { switch(type) { case SENSORS_HW_INIT: GPIO_SOFTWARE_CONTROL(ADC_ALS_PWR_PORT_BASE, ADC_ALS_PWR_PIN_MASK); GPIO_SET_OUTPUT(ADC_ALS_PWR_PORT_BASE, ADC_ALS_PWR_PIN_MASK); GPIO_CLR_PIN(ADC_ALS_PWR_PORT_BASE, ADC_ALS_PWR_PIN_MASK); ioc_set_over(ADC_ALS_PWR_PORT, ADC_ALS_PWR_PIN, IOC_OVERRIDE_DIS); GPIO_SOFTWARE_CONTROL(GPIO_A_BASE, ADC_ALS_OUT_PIN_MASK); GPIO_SET_INPUT(GPIO_A_BASE, ADC_ALS_OUT_PIN_MASK); ioc_set_over(GPIO_A_NUM, ADC_ALS_OUT_PIN, IOC_OVERRIDE_ANA); break; } return 0; }
void simistor_strob_callback(void) { // rt_now = RTIMER_NOW(); // ct = clock_time(); // printf("Task called at %lu (clock = %lu)\n", rt_now, ct); GPIO_SET_PIN(GPIO_C_BASE, LAMP_CHAN0); clock_delay_usec(50); //disable simistor GPIO_CLR_PIN(GPIO_C_BASE, LAMP_CHAN0); //GPIO_SET_PIN(GPIO_C_BASE, 0x80); //GPIO_CLR_PIN(GPIO_C_BASE, 0x80); // GPIO_ENABLE_INTERRUPT(BUTTON_LEFT_PORT, BUTTON_LEFT_PIN); // nvic_interrupt_enable(BUTTON_LEFT_VECTOR); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(ac_dimmer_int_process, ev, data) { PROCESS_EXITHANDLER(); PROCESS_BEGIN(); int dimtime; while(1) { PROCESS_YIELD_UNTIL(ev == PROCESS_EVENT_POLL); dimtime = (uint8_t)(100 - dimming); dimtime *= 100; /* Off cycle */ clock_delay_usec(dimtime); GPIO_SET_PIN(DIMMER_GATE_PORT_BASE, DIMMER_GATE_PIN_MASK); /* Triac on propagation delay */ clock_delay_usec(DIMMER_DEFAULT_GATE_PULSE_US); GPIO_CLR_PIN(DIMMER_GATE_PORT_BASE, DIMMER_GATE_PIN_MASK); } PROCESS_END(); }
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); } }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(mainProcess, ev, data) { PROCESS_BEGIN(); GPIO_SET_OUTPUT(GPIO_A_BASE, 0xf8); GPIO_SET_OUTPUT(GPIO_B_BASE, 0x0f); GPIO_SET_OUTPUT(GPIO_C_BASE, 0x02); GPIO_CLR_PIN(GPIO_A_BASE, 0xf8); GPIO_CLR_PIN(GPIO_B_BASE, 0x07); GPIO_SET_PIN(EDISON_WAKEUP_BASE, EDISON_WAKEUP_PIN_MASK); // edison WAKEUP GPIO_SET_INPUT(RESET_PORT_BASE, RESET_PIN_MASK); // reset ioc_set_over(RESET_PORT, RESET_PIN, IOC_OVERRIDE_PUE); leds_off(LEDS_RED); leds_off(LEDS_GREEN); leds_off(LEDS_BLUE); // RESET interrupt, active low GPIO_DETECT_EDGE(RESET_PORT_BASE, RESET_PIN_MASK); GPIO_DETECT_FALLING(RESET_PORT_BASE, RESET_PIN_MASK); GPIO_TRIGGER_SINGLE_EDGE(RESET_PORT_BASE, RESET_PIN_MASK); gpio_register_callback(resetcallBack, RESET_PORT, RESET_PIN); GPIO_ENABLE_INTERRUPT(RESET_PORT_BASE, RESET_PIN_MASK); nvic_interrupt_enable(RESET_NVIC_PORT); GPIO_CLR_PIN(TRIUMVI_DATA_READY_PORT_BASE, TRIUMVI_DATA_READY_MASK); // SPI CS interrupt GPIO_DETECT_EDGE(SPI0_CS_PORT_BASE, SPI0_CS_PIN_MASK); GPIO_DETECT_RISING(SPI0_CS_PORT_BASE, SPI0_CS_PIN_MASK); GPIO_TRIGGER_SINGLE_EDGE(SPI0_CS_PORT_BASE, SPI0_CS_PIN_MASK); gpio_register_callback(spiCScallBack, SPI0_CS_PORT, SPI0_CS_PIN); GPIO_ENABLE_INTERRUPT(SPI0_CS_PORT_BASE, SPI0_CS_PIN_MASK); // SPI interface spix_slave_init(SPIDEV); spix_txdma_enable(SPIDEV); spi_register_callback(spiFIFOcallBack); spix_interrupt_enable(SPIDEV, SSI_IM_RXIM_M); // RX FIFO half full nvic_interrupt_enable(NVIC_INT_SSI0); // uDMA SPI0 TX udma_channel_disable(CC2538_SPI0_TX_DMA_CHAN); udma_channel_prio_set_default(CC2538_SPI0_TX_DMA_CHAN); udma_channel_use_primary(CC2538_SPI0_TX_DMA_CHAN); udma_channel_use_single(CC2538_SPI0_TX_DMA_CHAN); udma_channel_mask_clr(CC2538_SPI0_TX_DMA_CHAN); udma_set_channel_dst(CC2538_SPI0_TX_DMA_CHAN, SPI0DR); udma_set_channel_assignment(CC2538_SPI0_TX_DMA_CHAN, UDMA_CH11_SSI0TX); simple_network_set_callback(&rf_rx_handler); //NETSTACK_RADIO.off(); process_start(&decryptProcess, NULL); process_start(&spiProcess, NULL); while (1){ PROCESS_YIELD(); // buffer is not empty, spi is not in use //if ((spiInUse==0) && (spix_busy(SPIDEV)==0) && ((triumviAvailIDX!=triumviFullIDX) || (triumviRXBufFull==1))){ if ((spiInUse==0) && ((triumviAvailIDX!=triumviFullIDX) || (triumviRXBufFull==1))){ GPIO_SET_PIN(TRIUMVI_DATA_READY_PORT_BASE, TRIUMVI_DATA_READY_MASK); if (triumviRXBufFull==1){ resetCnt += 1; if (resetCnt==RESET_THRESHOLD){ watchdog_reboot(); } } #ifdef LED_DEBUG leds_off(LEDS_RED); leds_off(LEDS_GREEN); leds_off(LEDS_BLUE); #endif } // Fail safe, CC2538 missing some SPI commands, reset spi state else if (triumviRXBufFull==1){ spiState = SPI_RESET; process_poll(&spiProcess); #ifdef LED_DEBUG leds_off(LEDS_RED); leds_off(LEDS_GREEN); leds_on(LEDS_BLUE); #endif } } PROCESS_END(); }
PROCESS_THREAD(spiProcess, ev, data) { PROCESS_BEGIN(); uint8_t spi_data_fifo[SPIFIFOSIZE]; uint8_t packetLen; spi_packet_t spi_rx_pkt; uint8_t* dma_src_end_addr; static uint8_t spi_data_ptr = 0; uint8_t proc_idx; while (1){ PROCESS_YIELD(); switch (spiState){ case SPI_RESET: spi_cs_int = 0; spi_rxfifo_halffull = 0; spiInUse = 0; spi_data_ptr = 0; spix_interrupt_enable(SPIDEV, SSI_IM_RXIM_M); spiState = SPI_WAIT; process_poll(&mainProcess); #ifdef LED_DEBUG leds_off(LEDS_RED); leds_on(LEDS_GREEN); leds_on(LEDS_BLUE); #endif break; /* Wait SPI from Edison*/ case SPI_WAIT: #ifdef LED_DEBUG leds_on(LEDS_BLUE); #endif if (spi_rxfifo_halffull==1){ spi_rxfifo_halffull = 0; spi_data_ptr += spix_get_data(SPIDEV, spi_data_fifo+spi_data_ptr); spix_interrupt_enable(SPIDEV, SSI_IM_RXIM_M); spiInUse = 1; } if (spi_cs_int==1){ spi_data_ptr += spix_get_data(SPIDEV, spi_data_fifo+spi_data_ptr); spi_cs_int = 0; spiInUse = 1; proc_idx = 0; while (proc_idx < spi_data_ptr){ proc_idx += spi_packet_parse(&spi_rx_pkt, spi_data_fifo+proc_idx); switch (spi_rx_pkt.cmd){ // write length and data into tx fifo case SPI_MASTER_REQ_DATA: packetLen = triumviRXPackets[triumviFullIDX].length; spix_put_data_single(SPIDEV, packetLen); dma_src_end_addr = triumviRXPackets[triumviFullIDX].payload + packetLen - 1; udma_set_channel_src(CC2538_SPI0_TX_DMA_CHAN, (uint32_t)(dma_src_end_addr)); udma_set_channel_control_word(CC2538_SPI0_TX_DMA_CHAN, (SPI0TX_DMA_FLAG | udma_xfer_size(packetLen))); udma_channel_enable(CC2538_SPI0_TX_DMA_CHAN); GPIO_CLR_PIN(TRIUMVI_DATA_READY_PORT_BASE, TRIUMVI_DATA_READY_MASK); break; // do nothing... case SPI_MASTER_DUMMY: break; // spi transmission is completed, advances pointer case SPI_MASTER_GET_DATA: if ((triumviAvailIDX!=triumviFullIDX) || (triumviRXBufFull==1)){ triumviRXBufFull = 0; if (triumviFullIDX == TRIUMVI_PACKET_BUF_LEN-1) triumviFullIDX = 0; else triumviFullIDX += 1; #ifndef LED_DEBUG leds_off(LEDS_GREEN); #endif } resetCnt = 0; spiInUse = 0; break; case SPI_MASTER_RADIO_ON: NETSTACK_RADIO.on(); spiInUse = 0; break; case SPI_MASTER_RADIO_OFF: NETSTACK_RADIO.off(); spiInUse = 0; break; default: spiInUse = 0; break; } } spi_data_ptr = 0; #ifndef LED_DEBUG leds_off(LEDS_BLUE); #else leds_on(LEDS_RED); leds_off(LEDS_GREEN); leds_on(LEDS_BLUE); #endif } process_poll(&mainProcess); break; default: break; } } PROCESS_END(); }
void ble_ant_enable() { GPIO_SOFTWARE_CONTROL(RADIO_SELECT_PORT, RADIO_SELECT_PIN); GPIO_SET_OUTPUT(RADIO_SELECT_PORT, RADIO_SELECT_PIN); GPIO_CLR_PIN(RADIO_SELECT_PORT, RADIO_SELECT_PIN); }
void ble_ant_enable() { GPIO_CLR_PIN(RADIO_SELECT_PORT_BASE, RADIO_SELECT_PIN_MASK); }
void rf_switch_init() { GPIO_SOFTWARE_CONTROL(RADIO_SELECT_PORT_BASE, RADIO_SELECT_PIN_MASK); GPIO_SET_OUTPUT(RADIO_SELECT_PORT_BASE, RADIO_SELECT_PIN_MASK); GPIO_CLR_PIN(RADIO_SELECT_PORT_BASE, RADIO_SELECT_PIN_MASK); }
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(); }
/*---------------------------------------------------------------------------*/ 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; } } }