static int prepareListenSocket(){
sockaddr_in service;
u_short port = 27015;
char* ip;
DWORD l_err;
gsockListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (gsockListen == INVALID_SOCKET) {
printErrorMsg(_T("socket() failed with:"), WSAGetLastError(),1,1);
return FALSE;
}
service.sin_family = AF_INET;
service.sin_port = htons(port);
hostent* thisHost;
thisHost = gethostbyname("");
if (thisHost == NULL){
printErrorMsg(_T("gethostbyname() failed with:"), WSAGetLastError(),1,1);
return FALSE;
}
ip = inet_ntoa (*(struct in_addr *)*thisHost->h_addr_list);
service.sin_addr.s_addr = inet_addr(ip);
l_err = bind(gsockListen, (SOCKADDR *) &service, sizeof(SOCKADDR));
if (l_err == SOCKET_ERROR) {
printErrorMsg(_T("bind() failed with:"), WSAGetLastError(),1,1);
return 0;
}
//enable non-blocking mode
u_long l_arg =1;
ioctlsocket(gsockListen, FIONBIO, &l_arg);
l_err = listen(gsockListen, 1);
if (l_err == SOCKET_ERROR) {
printf("listen() failed with error: %d\n", WSAGetLastError() );
destroyNetwork();
return FALSE;
}
l_err = WSAEventSelect(gsockListen,events[0],FD_ACCEPT);
if (l_err == SOCKET_ERROR) {
printf("WSAEventSelect() ,FD_ACCEPT, failed with error: %d\n", WSAGetLastError() );
destroyNetwork();
return FALSE;
}
return TRUE;
}
int _tmain(int argc, _TCHAR* argv[])
{
initCommon();
if (initConfig()==0){
destroyConfig();
return 1;
};
scanPorts();
/*
#define STATUS_OK 0x000
#define STATUS_HARDWARE_NOT_CONNECTED 0x001
#define STATUS_HARDWARE_ON_DIFFERENT_PORT 0x002 //the hardware was detected on a different port
#define STATUS_USER_HARDWARE_SELECTION 0x004
*/
if (resolveConfig() & (STATUS_HARDWARE_NOT_CONNECTED | STATUS_USER_HARDWARE_SELECTION)){
return 1;//error abort
};
initSerialCommunication();
if (initNetwork()==0){
destroyNetwork();
}
test();
closeSerialCommunication();
destroyConfig();
return 0;
}
int initNetwork(){
WORD wVersionRequested;
WSADATA wsaData;
DWORD l_err;
gTerminateNetwork =FALSE;
memset((void *)&events,0,sizeof(WSAEVENT)*SIZE_EVENT_ARRAY);
memset(recBuffer,0,SIZE_REC_BUFFER);
gsockListen= 0;
for (int i=0;i<SIZE_EVENT_ARRAY;i++){
events[i] = WSACreateEvent();
if (events[i] == WSA_INVALID_EVENT){
printErrorMsg(_T("WSACreateEvent failed,"),WSAGetLastError(),1,1);
destroyNetwork();
return FALSE;
}
}
wVersionRequested = MAKEWORD(2, 2);
l_err = WSAStartup(wVersionRequested, &wsaData);
if (l_err != 0) {
printErrorMsg(_T("WSAStartup failed with error:"),l_err,1,1);
destroyNetwork();
return FALSE;
}
if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) {
printErrorMsg(_T("Could not find a usable version of Winsock.dll"),WSAGetLastError(),1,1);
destroyNetwork();
return FALSE;
}
gThread = CreateThread(NULL,(SIZE_T)1024,networkCommWorker,NULL,(DWORD)0,(LPDWORD)&gThreadID);
if (gThread == 0){
printErrorMsg(_T("Internal error:0x4003, networkWorkerThread creation failed,"),GetLastError(),1,0);
destroyNetwork();
return FALSE;
}
return TRUE;
}
keyMdamEx::~keyMdamEx()
{
destroyNetwork();
// Delete the MdamColumn*s.
MdamColumn * current;
MdamColumn * next;
for (current = first_column_;
current != 0;
current = next)
{
current->release(mdamRefListEntrysForStopListsHeap_);
next = current->nextColumn();
delete current;
}
// Release memory for the stop list ref list entires.
// stop_list_.deleteEntries(mdamRefListEntryHeap);
mdamRefListEntrysForStopListsHeap_.releaseHeapMemory();
}
/*! @brief Destructor for the nubot
*/
NUbot::~NUbot()
{
#if DEBUG_NUBOT_VERBOSITY > 0
debug << "NUbot::~NUbot()." << endl;
#endif
#ifdef USE_MOTION
m_motion->kill();
m_platform->kill();
m_platform->msleep(1500);
#endif
destroyThreads();
destroyModules();
destroyNetwork();
destroyBlackboard();
destroyPlatform();
#if DEBUG_NUBOT_VERBOSITY > 0
debug << "NUbot::~NUbot(). Finished!" << endl;
#endif
}
/* private slots */
void NetControlThread::run()
{
Result result;
switch (task.action) {
case GET_ALL_ENTITY_STATE :
result = getAllNetworkList();
break;
case CREATE_ENTITY :
result = createNetwork();
break;
case DEFINE_ENTITY :
result = defineNetwork();
break;
case START_ENTITY :
result = startNetwork();
break;
case DESTROY_ENTITY :
result = destroyNetwork();
break;
case UNDEFINE_ENTITY :
result = undefineNetwork();
break;
case CHANGE_ENTITY_AUTOSTART :
result = changeAutoStartNetwork();
break;
case GET_XML_DESCRIPTION :
result = getVirtNetXMLDesc();
break;
default:
break;
};
// task.srcConnPtr reference will closed in destructor as ptr_ConnPtr
//virConnectClose(*task.srcConnPtr);
result.type = "network";
result.number = number;
result.action = task.action;
emit resultData(result);
}
ExeErrorCode keyMdamEx::buildNetwork(sql_buffer_pool *pool,atp_struct *atp0)
{
destroyNetwork(); // clean out any old network still hanging around
keyMdamGen & mdamGen = (keyMdamGen &)tdbKey_;
// Acquire memory for MdamRefListEntry's.
ExeErrorCode refListEntryHeapErrorCode
= mdamRefListEntryHeap_.acquireHeapMemory(globals_->getDefaultHeap());
if (refListEntryHeapErrorCode != (ExeErrorCode)0)
return refListEntryHeapErrorCode;
// Acquire memory for MdamInterval's.
ExeErrorCode intervalHeapErrorCode
= mdamIntervalHeap_.acquireHeapMemory(globals_->getDefaultHeap());
if (intervalHeapErrorCode != (ExeErrorCode)0)
return intervalHeapErrorCode;
MdamPredIterator predIterator(first_column_,
mdamGen.getMaxDisjunctNumber());
Lng32 disjunct_number;
while ((disjunct_number = predIterator.getNextDisjunctNumber()) >= 0)
{
NABoolean disjunct_number_in_stop_list = stop_lists_built_;
NABoolean empty_disjunct = FALSE;
Lng32 column_number = number_of_key_cols_-1; // $$$ remove later
for (MdamColumn * m = last_column_;
m != 0;
m = m->previousColumn())
{
ex_assert(column_number >= 0,
"keyMdamEx::Mdam -- bad column_number"); // $$$ remove later
disjunct_number_in_stop_list =
m->buildDisjunct(predIterator,
pool,
atp0,
workAtp_,
getGenInfo().getValueAtpIndex(),
disjunct_number,
disjunct_number_in_stop_list,
mdamIntervalHeap_,
mdamRefListEntryHeap_,
mdamRefListEntrysForStopListsHeap_,
dataConvErrorFlag_);
if (m->disjunctIsEmpty())
empty_disjunct = TRUE;
column_number--; // $$$ remove later
} // end for
ex_assert(column_number == -1,
"keyMdamEx::Mdam -- wrong number of columns"); // $$$ remove later
ex_assert(disjunct_number_in_stop_list,
"keyMdamEx::Mdam -- disjunct number not in any stop list");
// if the disjunct is empty for some column (i.e. if some column
// has contradictory predicates for this disjunct), throw the disjunct
// away; otherwise merge it in
if (empty_disjunct)
{
for (MdamColumn * c = first_column_;
c != 0;
c = c->nextColumn())
{
c->tossDisjunct(mdamIntervalHeap_,
mdamRefListEntryHeap_);
}
}
else
{
for (MdamColumn * c = first_column_;
c != 0;
c = c->nextColumn())
{
c->mergeDisjunct(disjunct_number,
mdamIntervalHeap_,
mdamRefListEntryHeap_);
}
}
} // end while
network_built_ = TRUE;
stop_lists_built_ = TRUE;
// for testing... display the network
#if defined ( NA_MDAM_EXECUTOR_DEBUG )
print();
#endif /* NA_MDAM_EXECUTOR_DEBUG */
return (ExeErrorCode)0; // No error.
}
// release tupp storage associated with an Mdam network
void keyMdamEx::release()
{
destroyNetwork();
keyRangeEx::release(); // invoke release() on base class
}
//====================================================================
// Create neural-network according to parameters
//====================================================================
void BPNet::createNetwork( double lr, double mt, const vector<int>& nodeCnt)
{
srand((unsigned)time(NULL));
// destroy existing network
destroyNetwork();
// copy node count vector (number of nodes in each layer)
_nodeCount = nodeCnt;
int numLayers = _nodeCount.size();
if ( numLayers == 0 )
return; // nothing to do if no layers
// create nodes
int numLinks = 0;
for(int i = 0; i < numLayers; ++i)
{
int numNodes = _nodeCount[i];
for(int j = 0; j < numNodes; ++j)
{
// create a new node
BPNode* node = new BPNode(lr, mt);
// add it to the nodes vector
_nodes.push_back(node);
}
// count links while we're at it
if ( i > 0 )
numLinks += _nodeCount[i-1] * numNodes;
}
// set index of first middle node
// (index of last input node + 1)
_firstMiddleNode = _nodeCount[0];
// set index of first output node
// (total number of nodes - number of output nodes)
_firstOutputNode = _nodes.size() - _nodeCount[numLayers-1];
// create links
for (i = 0; i < numLinks; ++i)
{
// create new link
BPLink* link = new BPLink;
// add it to the links vector
_links.push_back(link);
}
// connect layers
int current = 0;
int curLayer = 0;
int nextLayer = _firstMiddleNode;
BPNode* pInNode = NULL;
BPNode* pOutNode = NULL;
BPLink* pLink = NULL;
for (i = 0; i < numLayers-1; ++i)
{
for (int j = 0; j < _nodeCount[i+1]; ++j)
for (int k = 0; k < _nodeCount[i]; ++k)
{
pInNode = _nodes[curLayer+k];
pOutNode = _nodes[nextLayer+j];
pLink = _links[current++];
// connect input node to output node
pLink->connect(pInNode, pOutNode);
}
curLayer = nextLayer;
nextLayer += _nodeCount[i+1];
}
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
BPNet::~BPNet()
{
// cleanup
destroyNetwork();
}
