void cc3000_init(tWlanCB sWlanCB)
{
WlanInterruptDisable();
UCB2CTL1 = UCSWRST; // Reset UCB2
UCB2CTL0 = UCMSB | UCMST | UCSYNC | UCMODE_0;
UCB2CTL1 = UCSWRST | UCSSEL__SMCLK;
UCB2BRW = 2;
UCB2IE = 0;
PXSEL(CC3000_PORT) &= ~(CC3000_CS | CC3000_EN);
PXSEL(CC3000_PORT) |= CC3000_MOSI | CC3000_MISO | CC3000_SCK;
PXDIR(CC3000_PORT) |= CC3000_MOSI | CC3000_SCK | CC3000_CS | CC3000_EN;
PXDS(CC3000_PORT) |= CC3000_MOSI | CC3000_SCK | CC3000_CS | CC3000_EN;
PXDIR(CC3000_PORT) &= ~CC3000_MISO;
PXREN(CC3000_PORT) |= CC3000_MISO;
PXOUT(CC3000_PORT) |= CC3000_CS;
PXOUT(CC3000_PORT) &= ~CC3000_EN;
PXSEL(CC3000_INT_PORT) &= ~CC3000_INT;
PXDIR(CC3000_INT_PORT) &= ~CC3000_INT;
PXREN(CC3000_INT_PORT) |= CC3000_INT;
PXOUT(CC3000_INT_PORT) |= CC3000_INT;
PXIES(CC3000_INT_PORT) |= CC3000_INT;
PXIFG(CC3000_INT_PORT) &= ~CC3000_INT;
UCB2CTL1 &= ~UCSWRST;
wlan_init(sWlanCB, sendPatch, sendPatch, sendPatch, ReadWlanInterruptPin, WlanInterruptEnable, WlanInterruptDisable, WriteWlanPin);
}
void CC3000_Init(void) {
SPIInterruptsEnabled = 0;
#ifdef TEENSY3
pinMode(WLAN_IRQ, INPUT_PULLUP);
#else
pinMode(WLAN_IRQ, INPUT);
#endif
attachInterrupt(WLAN_IRQ_INTNUM, CC3000InterruptHandler, FALLING);
pinMode(WLAN_EN, OUTPUT);
digitalWrite(WLAN_EN, LOW); // make sure it's off until we're ready
pinMode(WLAN_CS, OUTPUT);
Set_CC3000_CS_NotActive(); // turn off CS until we're ready
wlan_init( CC3000_AsyncCallback,
SendFirmwarePatch,
SendDriverPatch,
SendBootloaderPatch,
ReadWlanInterruptPin,
WlanInterruptEnable,
WlanInterruptDisable,
WriteWlanEnablePin);
wlan_start(0);
}
int main() {
printf("Hello, CC3000!\r\n");
board_init();
/* Initialise the module */
printf("Initializing...\r\n");
init_spi();
printf("init\r\n");
wlan_init(CC3000_UsynchCallback, sendWLFWPatch, sendDriverPatch,
sendBootLoaderPatch, ReadWlanInterruptPin, WlanInterruptEnable,
WlanInterruptDisable, WriteWlanPin);
printf("start\r\n");
wlan_start(0);
printf("ioctl\n\r");
while(1) {
// myled = 1;
// wait(0.2);
// myled = 0;
// wait(0.2);
}
}
//*****************************************************************************
//
//! initDriver
//!
//! @param None
//!
//! @return none
//!
//! @brief The function initializes a CC3000 device and triggers it to
//! start operation
//
//*****************************************************************************
int
initDriver(void)
{
// Init GPIO's
pio_init();
//Init Spi
init_spi();
DispatcherUARTConfigure();
// WLAN On API Implementation
wlan_init( CC3000_UsynchCallback, sendWLFWPatch, sendDriverPatch, sendBootLoaderPatch, ReadWlanInterruptPin, WlanInterruptEnable, WlanInterruptDisable, WriteWlanPin);
// Trigger a WLAN device
wlan_start(0);
// Turn on the LED 5 to indicate that we are active and initiated WLAN successfully
turnLedOn(5);
// Mask out all non-required events from CC3000
wlan_set_event_mask(HCI_EVNT_WLAN_KEEPALIVE|HCI_EVNT_WLAN_UNSOL_INIT|HCI_EVNT_WLAN_ASYNC_PING_REPORT);
// Generate the event to CLI: send a version string
{
char cc3000IP[50];
char *ccPtr;
unsigned short ccLen;
DispatcherUartSendPacket((unsigned char*)pucUARTExampleAppString, sizeof(pucUARTExampleAppString));
ccPtr = &cc3000IP[0];
ccLen = my_itoa(PALTFORM_VERSION, ccPtr);
ccPtr += ccLen;
*ccPtr++ = '.';
ccLen = my_itoa(APPLICATION_VERSION, ccPtr);
ccPtr += ccLen;
*ccPtr++ = '.';
ccLen = my_itoa(SPI_VERSION_NUMBER, ccPtr);
ccPtr += ccLen;
*ccPtr++ = '.';
ccLen = my_itoa(DRIVER_VERSION_NUMBER, ccPtr);
ccPtr += ccLen;
*ccPtr++ = '\f';
*ccPtr++ = '\r';
*ccPtr++ = '\0';
DispatcherUartSendPacket((unsigned char*)cc3000IP, strlen(cc3000IP));
}
wakeup_timer_init();
ucStopSmartConfig = 0;
return(0);
}
//*****************************************************************************
//
//! initDriver
//!
//! \param None
//!
//! \return none
//!
//! \brief The function initializes a CC3000 device and triggers it to start operation
//
//*****************************************************************************
int
initDriver(void)
{
pio_init(); // Init GPIO's
init_spi();
wlan_init( CC3000_UsynchCallback, sendWLFWPatch, sendDriverPatch, sendBootLoaderPatch, ReadWlanInterruptPin, WlanInterruptEnable, WlanInterruptDisable, WriteWlanPin);
wlan_start(0);
if (IP_ALLOC_METHOD == USE_STATIC_IP){// The DHCP setting shave been removed.
pucSubnetMask[0] = 0xFF;// Subnet mask is assumed to be 255.255.255.0
pucSubnetMask[1] = 0xFF;
pucSubnetMask[2] = 0xFF;
pucSubnetMask[3] = 0x0;
pucIP_Addr[0] = STATIC_IP_OCT1; // CC3000's IP
pucIP_Addr[1] = STATIC_IP_OCT2;
pucIP_Addr[2] = STATIC_IP_OCT3;
pucIP_Addr[3] = STATIC_IP_OCT4;
pucIP_DefaultGWAddr[0] = STATIC_IP_OCT1;// Default Gateway/Router IP
pucIP_DefaultGWAddr[1] = STATIC_IP_OCT2;
pucIP_DefaultGWAddr[2] = STATIC_IP_OCT3;
pucIP_DefaultGWAddr[3] = 1;
pucDNS[0] = STATIC_IP_OCT1;// We assume the router is also a DNS server
pucDNS[1] = STATIC_IP_OCT2;
pucDNS[2] = STATIC_IP_OCT3;
pucDNS[3] = 1;
netapp_dhcp((unsigned long *)pucIP_Addr, (unsigned long *)pucSubnetMask,
(unsigned long *)pucIP_DefaultGWAddr, (unsigned long *)pucDNS);
// reset the CC3000 to apply Static Setting
wlan_stop();
__delay_cycles(6000000);
wlan_start(0);
}
// Mask out all non-required events from CC3000
wlan_set_event_mask(HCI_EVNT_WLAN_KEEPALIVE|HCI_EVNT_WLAN_ASYNC_PING_REPORT);
unsolicicted_events_timer_init();
// CC3000 has been initialized
setCC3000MachineState(CC3000_INIT);
return(0);
}
void hw_net_initialize (void)
{
CC3000_START;
SpiInit(4e6);
hw_wait_us(10);
wlan_init(CC3000_UsynchCallback, NULL, NULL, NULL, ReadWlanInterruptPin,
WlanInterruptEnable, WlanInterruptDisable, WriteWlanPin);
wlan_start(0);
int r = wlan_ioctl_set_connection_policy(0, 0, 0);
if (r != 0) {
TM_DEBUG("Fail setting policy %i", r);
}
r = wlan_ioctl_set_scan_params(10000, 100, 100, 5, 0x7FF, -100, 0, 205, wifi_intervals);
if (r != 0) {
TM_DEBUG("Fail setting scan params %i", r);
}
r = wlan_ioctl_set_connection_policy(0, true, true);
if (r != 0) {
TM_DEBUG("Fail setting connection policy %i", r);
}
wlan_stop();
hw_wait_ms(10);
wlan_start(0);
// tm_sleep_ms(100);
// TM_COMMAND('w',"setting event mask\n");
wlan_set_event_mask(HCI_EVNT_WLAN_KEEPALIVE|HCI_EVNT_WLAN_UNSOL_INIT|HCI_EVNT_WLAN_ASYNC_PING_REPORT);
// TM_COMMAND('w',"done setting event mask\n");
unsigned long aucDHCP = 14400;
unsigned long aucARP = 3600;
unsigned long aucKeepalive = 10;
unsigned long aucInactivity = 0;
if (netapp_timeout_values(&aucDHCP, &aucARP, &aucKeepalive, &aucInactivity) != 0) {
TM_DEBUG("Error setting inactivity timeout!");
}
unsigned char version[2];
if (nvmem_read_sp_version(version)) {
TM_ERR("Failed to read CC3000 firmware version.");
}
memcpy(hw_cc_ver, version, 2);
CC3000_END;
}
irom static app_action_t application_function_wlan_mode(const string_t *src, string_t *dst)
{
if(parse_string(1, src, dst) != parse_ok)
{
string_cat(dst, "wlan-mode: supply mode: client or ap\n");
return(app_action_error);
}
if(string_match(dst, "client"))
{
string_clear(dst);
config.wlan_mode = config_wlan_mode_client;
if(!wlan_init())
{
string_cat(dst, "wlan-mode: invalid mode\n");
return(app_action_error);
}
return(app_action_disconnect);
}
if(string_match(dst, "ap"))
{
string_clear(dst);
config.wlan_mode = config_wlan_mode_ap;
if(!wlan_init())
{
string_cat(dst, "wlan-mode: invalid mode\n");
return(app_action_error);
}
return(app_action_disconnect);
}
string_cat(dst, ": invalid wlan mode\n");
return(app_action_error);
}
signed int
init_wifiDriver(void)
{
signed char ret;
//
// Init GPIO's
//
if(!wifi_SPI_gpio_init_Done)
{
return -1; //error
}
//
//initialize SPI bus.
//
// Must be done to establish SimpleLink between microcontroller and cc3000.
// all cc3000 api will work only after successful SPI initialization /enabling SimpleLink .
// All CC3000 api() {except wlan_init()api } wait for SimpleLinkWaitEvent(HCI_Cmd_Name, &retval).
//
ret=init_spi();
if(ret)
{
return -2;
}
//
// Register various callback with HostDriver framework for
// 1. processing not masked asynchronous Event.
// 2. msp430 bsp functions for cc3000 interrupt pin and wlan_Enable pin
//
wlan_init( CC3000_AsyncEventCallback, sendWLFWPatch, sendDriverPatch, sendBootLoaderPatch, ReadWlanInterruptPin, WlanInterruptEnable, WlanInterruptDisable, WriteWlanPin);
//
// Starts the CC3000 Wifi chip to become enabled for wifi operations.
//blocks till wifi chip doesnt get UP.
//
wlan_start(0);
//
// Mask out all non-required asynchronous events from CC3000
//
ret= wlan_set_event_mask( HCI_EVNT_WLAN_KEEPALIVE | HCI_EVNT_WLAN_UNSOL_INIT | HCI_EVNT_WLAN_ASYNC_PING_REPORT);
if(ret){
return -3;
}
return(0);
}
/*------------------------------------------------------------------------
Spider_begin
Initial Spider L3,
return 0, Initial success.
-----------------------------------------------------------------------*/
int Spider_begin(void){
// Initial Arduino hardware interface connect with CC3000.
CC3000_Init();
// Initial callback functions to wlan api.
wlan_init( Spider_AsyncCallback, SendFirmwarePatch, SendDriverPatch, SendBootloaderPatch,
ReadWlanInterruptPin, WlanInterruptEnable, WlanInterruptDisable, WriteWlanPin);
// Starting CC3000
wlan_start(0);
// Set CC3000 event masking, right now without ping report.
wlan_set_event_mask(HCI_EVNT_WLAN_KEEPALIVE|HCI_EVNT_WLAN_UNSOL_INIT|HCI_EVNT_WLAN_ASYNC_PING_REPORT);
//Initial success.
HW_Initialed = 1;
return 0;
}
void cc3000_initialise(JsVar *wlanObj) {
jsvObjectSetChild(jsiGetParser()->root, CC3000_OBJ_NAME, wlanObj);
cc3000_spi_open();
wlan_init(cc3000_usynch_callback,
sendNoPatch/*sendWLFWPatch*/,
sendNoPatch/*sendDriverPatch*/,
sendNoPatch/*sendBootLoaderPatch*/,
cc3000_read_irq_pin, cc3000_irq_enable, cc3000_irq_disable, cc3000_write_en_pin);
wlan_start(0/* No patches */);
// Mask out all non-required events from CC3000
wlan_set_event_mask(
HCI_EVNT_WLAN_KEEPALIVE |
HCI_EVNT_WLAN_UNSOL_INIT);
// TODO: check return value !=0
wlan_ioctl_set_connection_policy(0, 0, 0); // don't auto-connect
wlan_ioctl_del_profile(255); // delete stored eeprom data
//*****************************************************************************
//
//! initDriver
//!
//! \param[in] cRequestPatch 0 to load with EEPROM patches
//! and 1 to load with no patches
//!
//! \return none
//!
//! \brief The function initializes a CC3000 device
//! and triggers it to start operation
//
//*****************************************************************************
static int initDriver(unsigned short cRequestPatch)
{
// WLAN On API Implementation
wlan_init(CC3000_UsynchCallback, sendWLFWPatch, sendDriverPatch, sendBootLoaderPatch,
ReadWlanInterruptPin, SpiResumeSpi, SpiPauseSpi, WriteWlanPin);
// Trigger a WLAN device
wlan_start(cRequestPatch);
wlan_smart_config_set_prefix((char*)aucCC3000_prefix);
wlan_ioctl_set_connection_policy(0, 0, 0);
wlan_ioctl_del_profile(255);
// Mask out all non-required events from CC3000
wlan_set_event_mask(HCI_EVNT_WLAN_KEEPALIVE|
HCI_EVNT_WLAN_UNSOL_INIT|
HCI_EVNT_WLAN_ASYNC_PING_REPORT);
//unsolicicted_events_timer_init();
systick_sleep(100);
return(0);
}
int wm_wlan_init()
{
static char init_done;
struct partition_entry *p;
short history = 0;
struct partition_entry *f1, *f2;
if (init_done)
return WM_SUCCESS;
int ret = part_init();
if (ret != WM_SUCCESS) {
init_e("wm_wlan_init: could not read partition table");
return ret;
}
f1 = part_get_layout_by_id(FC_COMP_WLAN_FW, &history);
f2 = part_get_layout_by_id(FC_COMP_WLAN_FW, &history);
if (f1 && f2)
p = part_get_active_partition(f1, f2);
else if (!f1 && f2)
p = f2;
else if (!f2 && f1)
p = f1;
else
return -WLAN_ERROR_FW_NOT_DETECTED;
flash_desc_t fl;
part_to_flash_desc(p, &fl);
/* Initialize wlan */
ret = wlan_init(&fl);
if (ret != WM_SUCCESS)
return ret;
init_done = 1;
return WM_SUCCESS;
}
/// \classmethod \constructor(spi, pin_cs, pin_en, pin_irq)
/// Initialise the CC3000 using the given SPI bus and pins and return a CC3k object.
//
// Note: pins were originally hard-coded to:
// PYBv1.0: init(pyb.SPI(2), pyb.Pin.board.Y5, pyb.Pin.board.Y4, pyb.Pin.board.Y3)
// [SPI on Y position; Y6=B13=SCK, Y7=B14=MISO, Y8=B15=MOSI]
//
// STM32F4DISC: init(pyb.SPI(2), pyb.Pin.cpu.A15, pyb.Pin.cpu.B10, pyb.Pin.cpu.B11)
STATIC mp_obj_t cc3k_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
// check arguments
mp_arg_check_num(n_args, n_kw, 4, 4, false);
// set the pins to use
SpiInit(
spi_get_handle(args[0]),
pin_find(args[1]),
pin_find(args[2]),
pin_find(args[3])
);
// initialize and start the module
wlan_init(cc3k_callback, NULL, NULL, NULL,
ReadWlanInterruptPin, SpiResumeSpi, SpiPauseSpi, WriteWlanPin);
if (wlan_start(0) != 0) {
nlr_raise(mp_obj_new_exception_msg(
&mp_type_OSError, "Failed to init wlan module"));
}
// set connection policy. this should be called explicitly by the user
// wlan_ioctl_set_connection_policy(0, 0, 0);
// Mask out all non-required events from the CC3000
wlan_set_event_mask(HCI_EVNT_WLAN_KEEPALIVE|
HCI_EVNT_WLAN_UNSOL_INIT|
HCI_EVNT_WLAN_ASYNC_PING_REPORT|
HCI_EVNT_WLAN_ASYNC_SIMPLE_CONFIG_DONE);
cc3k_obj_t *cc3k = m_new_obj(cc3k_obj_t);
cc3k->base.type = (mp_obj_type_t*)&mod_network_nic_type_cc3k;
// register with network module
mod_network_register_nic(cc3k);
return cc3k;
}
static mp_obj_t mod_wlan_init()
{
/* Initialize WLAN module */
wlan_init(sWlanCallback, NULL, NULL, NULL,
ReadWlanInterruptPin, SpiResumeSpi, SpiPauseSpi, WriteWlanPin);
/* Start WLAN module */
if (wlan_start(0) != 0) {
nlr_raise(mp_obj_new_exception_msg(
&mp_type_OSError, "Failed to init wlan module"));
}
/* Set connection policy */
// wlan_ioctl_set_connection_policy(0, 0, 0);
/* Mask out all non-required events from the CC3000 */
wlan_set_event_mask(HCI_EVNT_WLAN_KEEPALIVE|
HCI_EVNT_WLAN_UNSOL_INIT|
HCI_EVNT_WLAN_ASYNC_PING_REPORT|
HCI_EVNT_WLAN_ASYNC_SIMPLE_CONFIG_DONE);
return mp_const_none;
}
//*****************************************************************************
//
//! initDriver
//!
//! \param[in] cRequestPatch 0 to load with EEPROM patches and 1 to load with no patches
//!
//! \return none
//!
//! \brief The function initializes a CC3000 device and triggers it to start operation
//
//*****************************************************************************
int
initDriver(unsigned short cRequestPatch)
{
//
// Init GPIO's
//
pio_init();
//
//init all layers
//
init_spi();
//
// WLAN On API Implementation
//
wlan_init( CC3000_UsynchCallback, sendWLFWPatch, sendDriverPatch, sendBootLoaderPatch, ReadWlanInterruptPin, WlanInterruptEnable, WlanInterruptDisable, WriteWlanPin);
//
// Trigger a WLAN device
//
wlan_start(cRequestPatch);
wlan_smart_config_set_prefix(aucCC3000_prefix);
// Turn on the LED 5 to indicate that we are active and initiated WLAN successfully
turnLedOn(5);
//
// Mask out all non-required events from CC3000
//
wlan_set_event_mask(HCI_EVNT_WLAN_KEEPALIVE|HCI_EVNT_WLAN_UNSOL_INIT|HCI_EVNT_WLAN_ASYNC_PING_REPORT);
unsolicicted_events_timer_init();
return(0);
}
//*****************************************************************************
//
//! initDriver
//!
//! @param None
//!
//! @return none
//!
//! @brief The function initializes a CC3000 device and triggers it to start
//! operation
//
//*****************************************************************************
int
initDriver(void)
{
// Init GPIO's
pio_init();
// Init Spi
init_spi();
// Enable processor interrupts
MAP_IntMasterEnable();
// WLAN On API Implementation
wlan_init( CC3000_UsynchCallback, sendWLFWPatch, sendDriverPatch,
sendBootLoaderPatch, ReadWlanInterruptPin, WlanInterruptEnable,
WlanInterruptDisable, WriteWlanPin);
// Trigger a WLAN device
wlan_start(0);
// Turn on the LED 1 (RED) to indicate that we are active and initiated WLAN successfully
turnLedOn(1);
// Mask out all non-required events from CC3000
wlan_set_event_mask(HCI_EVNT_WLAN_KEEPALIVE|HCI_EVNT_WLAN_UNSOL_INIT
|HCI_EVNT_WLAN_ASYNC_PING_REPORT);
DispatcherUARTConfigure(SysCtlClockGet());
SysCtlDelay(1000000);
// Generate teh event to CLI: send a version string
{
char cc3000IP[50];
char *ccPtr;
unsigned short ccLen;
DispatcherUartSendPacket((unsigned char*)pucUARTExampleAppString,
sizeof(pucUARTExampleAppString));
ccPtr = &cc3000IP[0];
ccLen = itoa(PALTFORM_VERSION, ccPtr);
ccPtr += ccLen;
*ccPtr++ = '.';
ccLen = itoa(APPLICATION_VERSION, ccPtr);
ccPtr += ccLen;
*ccPtr++ = '.';
ccLen = itoa(SPI_VERSION_NUMBER, ccPtr);
ccPtr += ccLen;
*ccPtr++ = '.';
ccLen = itoa(DRIVER_VERSION_NUMBER, ccPtr);
ccPtr += ccLen;
*ccPtr++ = '\f';
*ccPtr++ = '\r';
*ccPtr++ = '\0';
DispatcherUartSendPacket((unsigned char*)cc3000IP, strlen(cc3000IP));
}
ucStopSmartConfig = 0;
// Configure SysTick to occur X times per second, to use as a time
// reference. Enable SysTick to generate interrupts.
InitSysTick();
return(0);
}
static void command_task(struct ETSEventTag *event)
{
switch(event->sig)
{
case(command_task_reset):
{
reset();
break;
}
case(command_task_uart_bridge):
{
background_task_bridge_uart();
stat_update_uart++;
break;
}
case(command_task_init_i2c_sensors):
{
if(i2c_sensors_init())
dispatch_post_command(command_task_init_i2c_sensors);
break;
}
case(command_task_periodic_i2c_sensors):
{
i2c_sensors_periodic();
break;
}
case(command_task_init_displays):
{
uint32_t now = system_get_time();
display_init();
stat_display_init_time_us = system_get_time() - now;
break;
}
case(command_task_received_command):
{
app_action_t action;
if(lwip_if_received_tcp(&command_socket))
stat_update_command_tcp++;
if(lwip_if_received_udp(&command_socket))
stat_update_command_udp++;
if(lwip_if_send_buffer_locked(&command_socket))
{
stat_cmd_send_buffer_overflow++;
string_clear(&command_socket_receive_buffer);
lwip_if_receive_buffer_unlock(&command_socket);
break;
}
string_clear(&command_socket_send_buffer);
action = application_content(&command_socket_receive_buffer, &command_socket_send_buffer);
string_clear(&command_socket_receive_buffer);
lwip_if_receive_buffer_unlock(&command_socket);
if(action == app_action_empty)
{
string_clear(&command_socket_send_buffer);
string_append(&command_socket_send_buffer, "> empty command\n");
}
if(action == app_action_disconnect)
{
string_clear(&command_socket_send_buffer);
string_append(&command_socket_send_buffer, "> disconnect\n");
}
if(action == app_action_reset)
{
string_clear(&command_socket_send_buffer);
string_append(&command_socket_send_buffer, "> reset\n");
}
if(!lwip_if_send(&command_socket))
log("lwip send failed\n");
if(action == app_action_disconnect)
lwip_if_close(&command_socket);
/*
* === ugly workaround ===
*
* For tcp connections we can use the "sent" callback to make sure all
* of our data has been sent before rebooting. For udp there is no such
* callback and waiting for it to happen does not work (need a return to
* SDK code to achieve it). So lwip_if_reboot will take care for it itself
* when possible (tcp), otherwise (udp) it will return false here and the
* application needs to finish the operation via a task call.
*/
if(action == app_action_reset)
if(!lwip_if_reboot(&command_socket))
dispatch_post_command(command_task_reset);
break;
}
case(command_task_display_update):
{
stat_update_display++;
if(display_periodic())
dispatch_post_command(command_task_display_update);
break;
}
case(command_task_fallback_wlan):
{
config_wlan_mode_t wlan_mode;
unsigned int wlan_mode_int;
if(config_get_uint("wlan.mode", &wlan_mode_int, -1, -1))
wlan_mode = (config_wlan_mode_t)wlan_mode_int;
else
wlan_mode = config_wlan_mode_client;
if(wlan_mode == config_wlan_mode_client)
{
wlan_mode_int = config_wlan_mode_ap;
config_open_write();
config_set_uint("wlan.mode", wlan_mode_int, -1, -1);
config_close_write();
config_get_uint("wlan.mode", &wlan_mode_int, -1, -1);
wlan_init();
}
break;
}
case(command_task_update_time):
{
time_periodic();
break;
}
case(command_task_run_sequencer):
{
sequencer_run();
break;
}
case(command_task_alert_association):
{
if((assoc_alert.io >= 0) && (assoc_alert.pin >= 0))
io_trigger_pin((string_t *)0, assoc_alert.io, assoc_alert.pin, io_trigger_on);
break;
}
case(command_task_alert_disassociation):
{
if((assoc_alert.io >= 0) && (assoc_alert.pin >= 0))
io_trigger_pin((string_t *)0, assoc_alert.io, assoc_alert.pin, io_trigger_off);
break;
}
case(command_task_alert_status):
{
if((trigger_alert.io >= 0) && (trigger_alert.pin >= 0))
io_trigger_pin((string_t *)0, trigger_alert.io, trigger_alert.pin, io_trigger_on);
break;
}
}
}
void SPARK_WLAN_Setup(void (*presence_announcement_callback)(void))
{
announce_presence = presence_announcement_callback;
/* Initialize CC3000's CS, EN and INT pins to their default states */
CC3000_WIFI_Init();
/* Configure & initialize CC3000 SPI_DMA Interface */
CC3000_SPI_DMA_Init();
/* WLAN On API Implementation */
wlan_init(WLAN_Async_Callback, WLAN_Firmware_Patch, WLAN_Driver_Patch, WLAN_BootLoader_Patch,
CC3000_Read_Interrupt_Pin, CC3000_Interrupt_Enable, CC3000_Interrupt_Disable, CC3000_Write_Enable_Pin);
Delay(100);
/* Trigger a WLAN device */
wlan_start(0);
SPARK_LED_FADE = 0;
SPARK_WLAN_STARTED = 1;
/* Mask out all non-required events from CC3000 */
wlan_set_event_mask(HCI_EVNT_WLAN_KEEPALIVE | HCI_EVNT_WLAN_UNSOL_INIT | HCI_EVNT_WLAN_ASYNC_PING_REPORT);
if(NVMEM_SPARK_Reset_SysFlag == 0x0001 || nvmem_read(NVMEM_SPARK_FILE_ID, NVMEM_SPARK_FILE_SIZE, 0, NVMEM_Spark_File_Data) != NVMEM_SPARK_FILE_SIZE)
{
/* Delete all previously stored wlan profiles */
wlan_ioctl_del_profile(255);
/* Create new entry for Spark File in CC3000 EEPROM */
nvmem_create_entry(NVMEM_SPARK_FILE_ID, NVMEM_SPARK_FILE_SIZE);
memset(NVMEM_Spark_File_Data,0, arraySize(NVMEM_Spark_File_Data));
nvmem_write(NVMEM_SPARK_FILE_ID, NVMEM_SPARK_FILE_SIZE, 0, NVMEM_Spark_File_Data);
NVMEM_SPARK_Reset_SysFlag = 0x0000;
Save_SystemFlags();
}
if(WLAN_MANUAL_CONNECT == 0)
{
if(NVMEM_Spark_File_Data[WLAN_PROFILE_FILE_OFFSET] == 0)
{
WLAN_SMART_CONFIG_START = 1;
}
else if(NVMEM_Spark_File_Data[WLAN_POLICY_FILE_OFFSET] == 0)
{
wlan_ioctl_set_connection_policy(DISABLE, DISABLE, ENABLE);
NVMEM_Spark_File_Data[WLAN_POLICY_FILE_OFFSET] = 1;
nvmem_write(NVMEM_SPARK_FILE_ID, 1, WLAN_POLICY_FILE_OFFSET, &NVMEM_Spark_File_Data[WLAN_POLICY_FILE_OFFSET]);
}
}
if((WLAN_MANUAL_CONNECT > 0) || !WLAN_SMART_CONFIG_START)
{
LED_SetRGBColor(RGB_COLOR_GREEN);
LED_On(LED_RGB);
}
nvmem_read_sp_version(patchVer);
if (patchVer[1] == 24)//19 for old patch
{
/* Latest Patch Available after flashing "cc3000-patch-programmer.bin" */
}
Clear_NetApp_Dhcp();
Set_NetApp_Timeout();
}
BOOL cc3000_setup(BOOL patchReq, uint8_t connectPolicy, const char* deviceName) {
printf("BEGIN CC3000 Setup (patchReq: %d, connectPolicy: %d, deviceName: %s)\n", patchReq, connectPolicy, deviceName);
_cc3000_pingReportNum = 0;
_cc3000_irqEnabled = FALSE;
memset(&_cc3000_status, 0, sizeof(_cc3000_status));
memset(&_cc3000_pingReport, 0, sizeof(_cc3000_pingReport));
for (int i = 0; i < MAX_SOCKETS; i++) {
_cc3000_sockets[i].closed = FALSE;
}
_cc3000_inIrq = FALSE;
wlan_init(
_cc3000_asyncCallback,
_cc3000_sendFWPatches,
_cc3000_sendDriverPatches,
_cc3000_sendBootLoaderPatches,
_cc3000_readWlanInterruptPin,
_cc3000_wlanInterruptEnable,
_cc3000_wlanInterruptDisable,
_cc3000_writeWlanPin
);
wlan_start(patchReq);
uint8_t firmwareMajor, firmwareMinor;
if (_cc3000_getFirmwareVersion(&firmwareMajor, &firmwareMinor)) {
printf("CC3000 firmware: %d.%d\n", firmwareMajor, firmwareMinor);
} else {
printf("failed to get firmware\n");
return FALSE;
}
// Check if we should erase previous stored connection details
// (most likely written with data from the SmartConfig app)
int connectToOpenAPs = (connectPolicy & CC3000_CONNECT_POLICY_OPEN_AP) ? 1 : 0;
int useFastConnect = (connectPolicy & CC3000_CONNECT_POLICY_FAST) ? 1 : 0;
int useProfiles = (connectPolicy & CC3000_CONNECT_POLICY_PROFILES) ? 1 : 0;
wlan_ioctl_set_connection_policy(connectToOpenAPs, useFastConnect, useProfiles);
if (connectToOpenAPs == 0 && useFastConnect == 0 && useProfiles == 0) {
// Delete previous profiles from memory
wlan_ioctl_del_profile(255);
}
if (wlan_set_event_mask(HCI_EVNT_WLAN_UNSOL_INIT |
//HCI_EVNT_WLAN_ASYNC_PING_REPORT |// we want ping reports
//HCI_EVNT_BSD_TCP_CLOSE_WAIT |
//HCI_EVNT_WLAN_TX_COMPLETE |
HCI_EVNT_WLAN_KEEPALIVE) != CC3000_SUCCESS) {
printf("WLAN Set Event Mask FAIL\n");
return FALSE;
}
// Wait for re-connection if we're using SmartConfig data
if (connectPolicy & CC3000_CONNECT_POLICY_SMART_CONFIG) {
// Wait for a connection
uint32_t timeout = 0;
while (!_cc3000_status.isConnected) {
_cc3000_irqPoll();
if (timeout > WLAN_CONNECT_TIMEOUT) {
return FALSE;
}
timeout += 10;
delay_ms(10);
}
delay_ms(1000);
if (_cc3000_status.hasDHCP) {
mdnsAdvertiser(1, (char*) deviceName, strlen(deviceName));
}
}
printf("END CC3000 Setup\n");
return TRUE;
}
/**
* @brief Configure SPI for MCU to CC3000
*
* @return True if SPI initialization completed successfully. False otherwise.
*/
bool SFE_CC3000::init()
{
/* Check if CC3000 SPI is already initialized */
if (is_initialized_) {
return true;
}
/* Determine available interrupt pins on supported microcontrollers */
#if defined(__AVR_ATmega8__) || defined(__AVR_ATmega168__) || \
defined(__AVR_ATmega328P__) || defined (__AVR_ATmega328__)
switch (g_int_pin) {
case 2:
g_int_num = 0;
break;
case 3:
g_int_num = 1;
break;
default:
Serial.println("ERROR: Interrupt line not attached to pin 2 or 3");
return false;
}
#elif defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2561__) || \
defined(__AVR_ATmega2560__) || defined(__AVR_ATmega1280__)
switch (g_int_pin) {
case 2:
g_int_num = 0;
break;
case 3:
g_int_num = 1;
break;
case 18:
g_int_num = 5;
break;
case 19:
g_int_num = 4;
break;
case 20:
g_int_num = 3;
break;
case 21:
g_int_num = 2;
break;
default:
Serial.println("ERROR: Interrupt not pin 2, 3, 18, 19, 20, or 21");
return false;
}
#elif defined(__AVR_ATmega32U4__)
switch (g_int_pin) {
case 3:
g_int_num = 0;
break;
case 2:
g_int_num = 1;
break;
case 0:
g_int_num = 2;
break;
case 1:
g_int_num = 3;
break;
case 7:
g_int_num = 4;
break;
default:
Serial.println("ERROR: Interrupt not pin 0, 1, 2, 3, or 7");
return false;
}
#else
Serial.println("ERROR: Microcontroller not supported");
return false;
#endif
/* Initialize interrupt, CS, and enable pins */
/* Digital pins can be used as INPUT */
pinMode(g_int_pin, INPUT);
pinMode(g_en_pin, OUTPUT);
pinMode(g_cs_pin, OUTPUT);
digitalWrite(g_en_pin, LOW);
/* Set up SPI, save default SPI parameters */
SPI.begin();
//SPI.setDataMode(SPI_MODE1);
//SPI.setBitOrder(MSBFIRST);
//SPI.setClockDivider(SPI_CLK_DIV);
/* De-assert CS */
digitalWrite(g_cs_pin, HIGH);
/* Initialize CC3000 library - provide callback definitions */
wlan_init( cc3000AsyncCallback,
sendFirmwarePatch,
sendDriverPatch,
sendBootLoaderPatch,
readWlanInterruptPin,
enableWlanInterrupt,
disableWlanInterrupt,
writeWlanPin);
/* CC3000 needs a delay before starting WLAN or it gets stuck sometimes */
delay(100);
/* Start CC3000 - asserts enable pin and blocks until init is complete */
wlan_start(0);
/* Mask out non-required events */
wlan_set_event_mask(HCI_EVNT_WLAN_KEEPALIVE | HCI_EVNT_WLAN_UNSOL_INIT);
is_initialized_ = true;
return true;
}
//*****************************************************************************
//
//! initDriver
//!
//! \param None
//!
//! \return none
//!
//! \brief The function initializes a CC3000 device and triggers it to start operation
//
//*****************************************************************************
int
initDriver(void)
{
// Init GPIO's
pio_init();
// Init SPI
init_spi();
DispatcherUARTConfigure();
// Globally enable interrupts
__enable_interrupt();
//
// WLAN On API Implementation
//
wlan_init( CC3000_UsynchCallback, sendWLFWPatch, sendDriverPatch, sendBootLoaderPatch, ReadWlanInterruptPin, WlanInterruptEnable, WlanInterruptDisable, WriteWlanPin);
//
// Trigger a WLAN device
//
wlan_start(0);
//
// Mask out all non-required events from CC3000
//
wlan_set_event_mask(HCI_EVNT_WLAN_KEEPALIVE|HCI_EVNT_WLAN_ASYNC_PING_REPORT|HCI_EVNT_WLAN_UNSOL_INIT);
// Generate event to CLI: send a version string
char cc3000IP[50];
char *ccPtr;
unsigned short ccLen;
DispatcherUartSendPacket((unsigned char*)pucUARTExampleAppString, sizeof(pucUARTExampleAppString));
ccPtr = &cc3000IP[0];
ccLen = itoa(PALTFORM_VERSION, ccPtr);
ccPtr += ccLen;
*ccPtr++ = '.';
ccLen = itoa(APPLICATION_VERSION, ccPtr);
ccPtr += ccLen;
*ccPtr++ = '.';
ccLen = itoa(SPI_VERSION_NUMBER, ccPtr);
ccPtr += ccLen;
*ccPtr++ = '.';
ccLen = itoa(DRIVER_VERSION_NUMBER, ccPtr);
ccPtr += ccLen;
*ccPtr++ = '\r';
*ccPtr++ = '\n';
*ccPtr++ = '\0';
ccLen = strlen(cc3000IP);
DispatcherUartSendPacket((unsigned char*)cc3000IP, strlen(cc3000IP));
// CC3000 has been initialized
setCC3000MachineState(CC3000_INIT);
unsigned long aucDHCP, aucARP, aucKeepalive, aucInactivity;
aucDHCP = 14400;
aucARP = 3600;
aucKeepalive = 10;
aucInactivity = 50;
if(netapp_timeout_values(&(aucDHCP), &(aucARP), &(aucKeepalive), &(aucInactivity)) != 0)
{
while(1);
}
return(0);
}
/*
* @brief Initialization is used to configure all of the registers of the microcontroller
* Steps:
* 1) Initialize CC3000
* 2) Set MUX Select_A to LOW, so we can send the Kill command from Atmega TX line
* (C0 input on MUX)
* 3) Set Mode to Safety Mode
* 4) Set MUX Select A to HIGH, so we get into Autonomous mode by default
* (C1 input on MUX)
*/
inline void Initialization (void)
{
#ifdef WATCHDOG_ENABLED
wdt_enable(WDTO_8S); // WDTO_8S means set the watchdog to 8 seconds.
#endif
//Turn on the Power LED to identify that the device is on.
// [UNUSED] DDRC |= (1 << DDC7); //STATUS LED
//Set up the LEDs for WLAN_ON and DHCP:
DDRC |= (1 << DDC6); //WLAN_INIT LED
DDRC |= (1 << DDC7); //DHCP_Complete LED. This will turn on and very slowly blink
DDRB |= (1 << DDB7); // MUX Select line, setting as output.
DDRE |= (1 << DDE2); // DDRF set outbound for Safe Mode LED
DDRD |= (1 << DDD6); // DDRF set outbound for Manual Mode LED
DDRD |= (1 << DDD4); // DDRF set outbound for Auto Mode LED
PORTF |= (1 << PF0); // Extra GPIO Pin
PORTF |= (1 << PF1); // Extra GPIO Pin
#ifndef SKIP_BOOT
DDRB |= (1 << DDB4);
DDRD |= (1 << DDD7);
DDRD |= (1 << DDD6);
PORTB |= (1 << PB4);
_delay_ms(200);
PORTD |= (1 << PD7);
_delay_ms(200);
PORTD |= (1 << PD6);
_delay_ms(200);
PORTB &= ~(1 << PB4);
_delay_ms(200);
PORTD &= ~(1 << PD7);
_delay_ms(200);
PORTD &= ~(1 << PD6);
#endif
_delay_ms(500);
PORTF &= ~(1 << PF0);
PORTF &= ~(1 << PF1);
// #ifdef ENERGY_ANALYSIS_ENABLED
// //Enable Timer/Counter0 Interrupt on compare match of OCR0A:
// TIMSK0 = (1 << OCIE0A);
// //Set the Output Compare Register for the timer to compare against:
// OCR0A = Energy_Analysis_Interval;
// //Configure the ADC to have the reference pin be AREF on pin 21, and make sure everything is set to defaults:
// ADMUX = 0x00;
// //Enable the Analog to Digital Conversion (ADC):
// ADCSRA = (1 << ADEN); //25 Clock cycles to initialize.
// #endif
#ifdef CC3000_ENABLED
//Enable the CC3000, and setup the SPI configurations.
init_spi();
//Set up the CC3000 API for communication.
wlan_init(CC3000_Unsynch_Call_Back,
Send_WLFW_Patch,
Send_Driver_Patch,
Send_Boot_Loader_Patch,
Read_WLAN_Interrupt_Pin,
WLAN_Interrupt_Enable,
WLAN_Interrupt_Disable,
Write_WLAN_Pin);
PORTB |= (1 << PB6); //Set the WLAN_INIT LED on.
sei();
//Enable the CC3000, and wait for initialization process to finish.
wlan_start(0);
wlan_set_event_mask(HCI_EVNT_WLAN_KEEPALIVE|HCI_EVNT_WLAN_UNSOL_INIT|HCI_EVNT_WLAN_ASYNC_PING_REPORT);
//Make sure we disconnect from any previous routers before we connect to a new one to prevent confusion on the device.
wlan_disconnect();
wlan_connect(WLAN_SEC_UNSEC, ROUTER_SSID, SSID_LENGTH, NULL, NULL, 0);
while(!DHCP_Complete)
{
_delay_ms(1000);
}
#ifdef WATCHDOG_ENABLED
wdt_reset();
#endif
//Bind a socket to receive data:
//sockaddr Mission_Control_Address;
memset((char *) &Mission_Control_Address, 0, sizeof(Mission_Control_Address));
Mission_Control_Address.sa_family = AF_INET;
//The Source Port:
Mission_Control_Address.sa_data[0] = (char)HEX_PORT_1; //(char)0x09;
Mission_Control_Address.sa_data[1] = (char)HEX_PORT_2; //(char)0x56;
//Configure the socket to not time out to keep the connection active.
//--------------------------------------------------------------------
unsigned long aucDHCP = 14400;
unsigned long aucARP = 3600;
unsigned long aucKeepalive = 10;
unsigned long aucInactivity = 0;
netapp_timeout_values(&aucDHCP, &aucARP, &aucKeepalive, &aucInactivity);
//TODO:
//Should check the CC3000's profiles. In the case that there are no profiles found, then
//inform the PC system, or use an LED.
//Open a UDP socket that grabs datagram:
Socket_Handle = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
switch(Socket_Handle)
{
case -1: //Error
//Flag somehow.
break;
default: //Success
//Set the socket configuration for blocking (since it is the only thing that is allowed).
switch( bind(Socket_Handle, &Mission_Control_Address, sizeof(sockaddr)))
{
case -1:
//Flag as ERROR.
break;
default:
//Flag as good.
break;
}
break;
}
#endif
// NEED TO SETUP A QUICK REMOVAL FLAG FOR THIS CODE TO TEST THE CC3000.
// #ifdef MOTOR_CONTROL_FLAG
// Set up our Motor Controller Selection lines and the output for the RS232 lines:
// DDRD |= (1 << DDD3) | (1 << DDD4) | (1 << DDD5);
DDRD |= (1 << DDD3) | (1 << DDD5);
// Initialize the UART (RS-232 communications) for the motor controller interface:
// Set the Baud rate to 115200 bits/s. ((System Oscillator clock frequency / (2 * BAUD) ) - 1)
// NOTE: The value may not be correct, according to the data sheet (pg. 213).
// With the value 16, the error is 2.1% (lower than 8, being -3.5%).
// This comes from util/setbaud.h
UBRR1H = UBRRH_VALUE; /*Set baud rate*/
UBRR1L = UBRRL_VALUE; /*Set baud rate*/
//Defined in util/setbaud.h:
#if USE_2X
UCSR1A |= (1 << U2X1); //Double the baud rate for asynchronous communication.
#else
UCSR1A &= ~(1 << U2X1);
#endif
// Set to no parity and in Asynchronous mode.
// 1 Stop bit.
// 1 Start bit.
// Set to 8-bit data.
UCSR1C |= (1 << UCSZ11) | (1 << UCSZ10);
//Enable the Rx and Tx lines.
UCSR1B |= (1 << TXEN1);
#ifdef TWI_ENABLED
//Set the SCL frequency to 200 KHz. From the equation: f(SCL) = F_CPU/(16 + (2*TWBR) * (4^TWPS))
TWBR = 12;
DDRB |= (1 << DDB4); //Setup PortB4 as the TWI error LED.
#endif //End TWI_ENABLED
_delay_ms(1000); //Wait for one second for the RoboteQs to finish booting.
Set_Mode(SAFETY_MODE); // Set to Safe Mode to send Kill Command to Roboteq's
Set_Mode(AUTONOMOUS_MODE);
#ifdef ROUTER_WATCHDOG_ENABLED
Count = 0; //Clear the Count variable out.
TCNT1 = 0; //Clear the TCNT register.
TCCR1B = (1 << CS12) | (1 << CS10); //Set the prescaler for 1024.
TIMSK1 = (1 << OCIE1A); //Enable output compare for 1A.
OCR1A = 39063; //Set the system to interrupt every 5 seconds.
//OCR1A = (Multiplier) * (F_CPU) / (Prescaler)
//39063 = (5) * (8000000) / (1024)
#endif
}
/*JSON{ "type":"staticmethod",
"class" : "WLAN", "name" : "init",
"generate" : "jswrap_wlan_init",
"description" : "",
"params" : [ ]
}*/
void jswrap_wlan_init() {
SpiInit();
wlan_init(CC3000_UsynchCallback, sendWLFWPatch, sendDriverPatch, sendBootLoaderPatch, ReadWlanInterruptPin, WlanInterruptEnable, WlanInterruptDisable, WriteWlanPin);
}
