//*****************************************************************************
//
//! 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 CC3000_UsynchCallback(long lEventType, char * data, unsigned char length)
{
if (lEventType == HCI_EVNT_WLAN_ASYNC_SIMPLE_CONFIG_DONE)
{
ulSmartConfigFinished = 1;
}
if (lEventType == HCI_EVNT_WLAN_UNSOL_INIT)
{
setCC3000MachineState(CC3000_INIT);
}
if (lEventType == HCI_EVNT_WLAN_UNSOL_CONNECT)
{
ulCC3000Connected = 1;
setCC3000MachineState(CC3000_ASSOC);
}
if (lEventType == HCI_EVNT_WLAN_UNSOL_DISCONNECT)
{
ulCC3000Connected = 0;
//restartMSP430();
unsetCC3000MachineState(CC3000_ASSOC);
}
if (lEventType == HCI_EVNT_WLAN_UNSOL_DHCP)
{
setCC3000MachineState(CC3000_IP_ALLOC);
}
// This Event is gengerated when the TCP connection is Half closed
if (lEventType == HCI_EVNT_BSD_TCP_CLOSE_WAIT)
{
sd[data[0]] = 1;
CheckSocket = 1;
}
}
void CC3000_UsynchCallback(long lEventType, char * data, unsigned char length)
{
if (lEventType == HCI_EVNT_WLAN_ASYNC_SIMPLE_CONFIG_DONE)
{
ulSmartConfigFinished = 1;
}
if (lEventType == HCI_EVNT_WLAN_UNSOL_INIT)
{
setCC3000MachineState(CC3000_INIT);
}
if (lEventType == HCI_EVNT_WLAN_UNSOL_CONNECT)
{
setCC3000MachineState(CC3000_ASSOC);
}
if (lEventType == HCI_EVNT_WLAN_UNSOL_DISCONNECT)
{
if(currentCC3000State() & CC3000_SERVER_INIT)
{
// We're waiting for a client to connect. However,
// because we just received the disconnect event, we're stuck
// because of the blocking nature of accept. We restart the MSP430
// so the CC3000 will wait to associate again.
// terminalPrint("Restarting MSP430...\r\n");
restartMSP430();
}
unsetCC3000MachineState(CC3000_ASSOC);
}
if (lEventType == HCI_EVNT_WLAN_UNSOL_DHCP)
{
setCC3000MachineState(CC3000_IP_ALLOC);
}
}
//*****************************************************************************************************************************
//*****************************************************************************************************************************
//*****************************************************************************************************************************
void waitForConnection(void)
{
setup_data_packet_header();
//RESET ADC and DMA:
refresh_ADC();
ADC_STATE = HALTED;
//RESET DMA STATE.
refresh_DMA();
DMA_STATE = HALTED;
if(currentCC3000State() & CC3000_SERVER_INIT) // Check whether the server functionality is successfully initialized
{
while(1) // Begin waiting for client and handle the connection
{
hci_unsolicited_event_handler();
addrlen = sizeof(clientaddr);
// accept blocks until we receive a connection
while ( (clientDescriptor == -1) || (clientDescriptor == -2) )
{
clientDescriptor = accept(serverSocket, (sockaddr *) &clientaddr, &addrlen);
}
hci_unsolicited_event_handler();
if(clientDescriptor >= 0) // Connection Accepted, Wait for data exchange
{
setCC3000MachineState(CC3000_CLIENT_CONNECTED);
unsolicicted_events_timer_disable();
//**********************
// Important Function. Manages incoming Message aswell as initiating outgoing message.
incomingPacketManager();
//**********************
}
else if(clientDescriptor == SOCKET_INACTIVE_ERR)
{
clientDescriptor = -1;
// Reinitialize the server
shutdownServer();
initServer();
}
if(bytesRecvd < 0){check_socket_connection();} //If the recieve function goes inactive, shuts down. This checks for that case
hci_unsolicited_event_handler();
}
}
}
//*****************************************************************************
//
//! Initialize Connection Server
//!
//! \param none
//!
//! \return none
//!
//! \brief Waits for a connection where we will
//
//*****************************************************************************
void initServer(void)
{
char portStr[12];
memset(portStr,0,sizeof(portStr));
// Open Server Socket
serverSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (serverSocket == -1)
{
serverError(SERV_ERR_SOCKET);
wlan_stop();
while(1)
{
__no_operation();
}
}
// Open port
int port = SERVER_PORT;
serverSocketAddr.sa_family = AF_INET;
// Set the Port Number
serverSocketAddr.sa_data[0] = (port & 0xFF00)>> 8;
serverSocketAddr.sa_data[1] = (port & 0x00FF);
memset (&serverSocketAddr.sa_data[2], 0, 4);
if (bind(serverSocket, &serverSocketAddr, sizeof(sockaddr)) != 0)
{
serverError(SERV_ERR_BIND);
return;
}
// Start Listening
if (listen (serverSocket, 1) != 0)
{
serverError(SERV_ERR_LISTEN);
return;
}
setCC3000MachineState(CC3000_SERVER_INIT);
itoa(port, portStr, DECIMAL_BASE);
}
//*****************************************************************************
//
//! 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);
}
