//********************************************************************************
// Event handler when there is data to be read
//********************************************************************************
static void read_cb(struct bufferevent *bev, void *ctx)
{
// Get input buffer
struct evbuffer *input = bufferevent_get_input(bev);
ev_uint32_t record_len = evbuffer_get_length(input);
// Setup buffer to get data
char* record = (char*) malloc(record_len);
if (record == NULL)
return;
// Obtain data
evbuffer_remove(input, record, record_len);
// Store in structure
printf("Received: %s.\n", record);
if(strncmp(record, "restore", strlen("restore")) == 0)
{
// Restore command received; send information back
char fakeGroup[] = "fake:u1|Image uploaded#u2|Approved montage#$";
struct evbuffer *output = bufferevent_get_output(bev);
/* Copy all the data from the input buffer to the output buffer. */
evbuffer_add(output, fakeGroup, sizeof(fakeGroup));
//evbuffer_add(output, theGroup->userInfoString, sizeof(theGroup->userInfoString);
}
else if(strncmp(record, "store", strlen("store")) == 0)
{
theGroup = parseMsg(record+strlen("store:"));
// Print what we received
printf("Group name: %s (length=%d)\n", theGroup->name, strlen(theGroup->name));
printf("Group info: %s (length=%d)\n", theGroup->userInfoString, strlen(theGroup->userInfoString));
}
}
void processMsg( const char * msg,
const size_t len )
{
#ifdef HAVE_LIBZ
if ( M_comp_level >= 0 )
{
M_decomp.decompress( msg, len, Z_SYNC_FLUSH );
char * out;
int size;
M_decomp.getOutput( out, size );
if ( size > 0 )
{
parseMsg( out, size );
}
}
else
#endif
{
parseMsg( msg, len );
}
}
void Starter::decideAlgorithm(){
printf("\nIn decideAlgorithm() of Node\n");
communication com;
int serfd;
int clifd = com.OpenListener(serfd,LISTEN_PORT2);
//char buffer[4095]={'\0',};
int intbuf;
com.readFromSocket(clifd,&intbuf,sizeof(int));
printf("recvd: %d\n",intbuf);
puts("Getting ID to IP map\n");
//assigining memory to mapIDtoIP
mapIDtoIP = new char*[NumNodes];
for(int i = 0; i < NumNodes; ++i){
mapIDtoIP[i] = new char[MAXLENGTH_IP_ADDR];
}
char recvdMsg[4096] = {'\0',};
strcpy(mapIDtoIP[0],"hello");
com.readFromSocket(clifd,recvdMsg,4095);
string recvdStr = recvdMsg;
vector<string> recvdValues;
string delimiter = ":";
parseMsg(recvdStr,delimiter,recvdValues);
for(int i=0;i<NumNodes;i++){
strcpy(mapIDtoIP[i],recvdValues[i].c_str());
printf("%d\t%s\n",i,mapIDtoIP[i]);
}
com.readFromSocket(clifd,CS_FileName,25);
printf("File Name of Critical section resource is %s\n",CS_FileName);
shutdown(clifd,2);
com.closeSocket(clifd);
com.closeSocket(serfd);
int algo = intbuf;
if(algo == 1){
Algorithm1();
}else if(algo == 2){
Algorithm2();
}else
printf("Invalid input\n");
}
void QTermDataHandler::update(/*QTimerEvent *event*/)
{
QByteArray msg;
if (compass->getMessage(msg, QByteArray("$DWXX")))
{
double lat = 0.0, lng = 0.0;
lng = msg[18] + double(msg[19])/60.0 + double(msg[20])/3600.0;
lat = msg[22] + double(msg[23])/60.0 + double(msg[24])/3600.0;
qDebug() << QString("Got location message, lat: %1, lng: %2").arg(lat).arg(lng);
QGeoCoordinate loc(lat, lng);
GasInfoItem item;
item.location = loc;
item.ch = HOSTID;
bLocationValid = true;
emit(newData(item));
}
if (compass->getMessage(msg, QByteArray("$TXXX")))
{
parseMsg(msg.mid(18), msg.mid(11, 3));
qDebug() << msg.mid(18);
}
int power = compass->getRFPower();
if (power == 1)
{
emit(compassOK(true));
}
else if (power == 0)
{
emit(compassOK(false));
}
while(compass->getMessage(msg, QByteArray("$FKXX")));
{
//simply dump the FKXX
;
}
}
/*
* send a message to controller when a node starts on a amachine.
*/
void Starter::registerAtController(char controllerIP[15],int port){
//communication
communication com;
int sockfd = com.connectToServer(controllerIP,port);
int z;
char buf[128]={'\0',};
z = gethostname(buf,sizeof buf);
if ( z == -1 ) {
fprintf(stderr, "%s: gethostname(2)\n",
strerror(errno));
exit(1);
}
int sd = 999;
printf("\nContacted Controller, sent my hostname:%s\n",buf);
com.writeToSocket(sockfd,buf,128);
com.readFromSocket(sockfd,&id,sizeof(int));
int qsize,nsize;
com.readFromSocket(sockfd,&qsize,sizeof(int));
com.readFromSocket(sockfd,&nsize,sizeof(int));
//int size;
//com.readFromSocket(sockfd,&size,sizeof(int));
printf("Received ID: %d, Qsize: %d, NumNodes: %d\n",id,qsize,nsize);
NumNodes = nsize;
quorumSize = qsize;
Quorum = new int*[nsize];
for(int i = 0; i < nsize; ++i)
Quorum[i] = new int[qsize];
for (int i = 0; i < nsize; ++i) {
for (int j = 0; j < qsize; ++j) {
Quorum[i][j] = 0;
}
}
puts("Getting quorum table\n");
char recvdMsg[4096] = {'\0',};
com.readFromSocket(sockfd,recvdMsg,4095);
string recvdStr = recvdMsg;
vector<string> recvdValues;
string delimiter = ":";
parseMsg(recvdStr,delimiter,recvdValues);
/*
for (int i=0; i<recvdValues.size();i++)
{
cout<<recvdValues[i]<<endl; //<-- extract values from this vector and push into the attay in 123 line
}*/
for(int i=0; i<nsize;i++)
{
for(int j=0; j<qsize;j++)
{
//cout<<"Here"<<endl;
Quorum[i][j] = atoi(recvdValues[i*qsize+j].c_str());
//cout<<"Here1"<<endl;
}
}
for(int i=0;i<nsize;i++){
for(int j=0;j<qsize;j++){
printf("%d\t",Quorum[i][j]);
}
printf("\n");
}
shutdown(sockfd,2);
int k = com.closeSocket(sockfd);
if (k < 0) {
printf("\nError in Closing");
exit(0);
}else
printf("Node disconnected from Controller\n");
}
/******************************************************************
* Main-function
*/
int main(void) {
/**************************************
* Set the clock to run at 80 MHz
*/
SysCtlClockSet(SYSCTL_SYSDIV_2_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN);
/**************************************
* Enable the floating-point-unit
*/
FPUEnable();
// We also want Lazystacking, so enable that too
FPULazyStackingEnable();
// We also want to put numbers close to zero to zero
FPUFlushToZeroModeSet(FPU_FLUSH_TO_ZERO_EN);
/**************************************
* Init variables
*/
uint16_t mapData[MAP_DATA_SIZE];
uint8_t stepDir = 0;
/**************************************
* Init peripherals used
*/
bluetooth_init();
init_stepper(); // Init the GPIOs used for the stepper and loading LED
InitI2C1(); // Init the communication with the lidar-unit through I2C
InitPWM();
setupTimers();
/**************************************
* State 2
*/
// Disable the timers that are used
disableTimer(TIMER1_BASE);
disableTimer(TIMER2_BASE);
// Enable all interrupts
IntMasterEnable();
/**************************************
* State 3
*/
// Indicate we should start with a scan regardless of what other things we have already got
// from UART-interrupt
// This means setting the appropriate bit in the status vector
stat_vec |= TAKE_MEAS;
/**************************************
* State 4
*/
// Contains main-loop where decisions should be made
for ( ; ; ) {
/**********************************
* Decision tree
*/
// Highest priority case first
// Check both interrupts at each iteration in the loop
if ( int_vec & UART_INT ) {
// Reset the indication
int_vec &= ~UART_INT;
// Remove drive-stop flag to enable movement
stat_vec &= ~DRIVE_STOP;
// Init data array
uint8_t dataArr[MAX_UART_MSG_SIZE];
// Collect the message
if ( readUARTMessage(dataArr, MAX_UART_MSG_SIZE) < SUCCESS ) {
// If we have recieved more data than fits in the vector we should simply
// go in here again and grab data
int_vec |= UART_INT;
}
// We have gathered a message
// and now need to determine what the message is
parseMsg(dataArr, MAX_UART_MSG_SIZE);
}
// Checking drive (movement) interrupt
if ( int_vec & TIMER2_INT ) {
int_vec &= ~TIMER2_INT;
// Disable TIMER2
disableTimer(TIMER2_BASE);
// Set drive-stop in status vector
stat_vec |= DRIVE_STOP;
}
// Checking measure interrupt
if ( int_vec & TIMER1_INT ) {
int_vec &= ~TIMER1_INT;
// Disable TIMER1
disableTimer(TIMER1_BASE);
// Take reading from LIDAR
mapData[stepCount++] = readLidar();
SysCtlDelay(2000);
// Take step
// Note: We need to take double meas at randvillkor (100) !!!!!
if ( stepCount > 0 && stepCount < 100 ) {
stepDir = 1;
}
else if ( stepCount >= 100 && stepCount < 200) {
stepDir = 0;
}
else {
stepDir = 1;
stepCount = 0;
// Reset busy-flag
stat_vec &= ~TAKE_MEAS;
}
step = takeStep(step, stepDir);
// Request reading from LIDAR
reqLidarMeas();
if ( stat_vec & TAKE_MEAS ) {
// Restart TIMER1
enableTimer(TIMER1_BASE, (SYSCLOCK / MEASUREMENT_DELAY));
}
else {
sendUARTDataVector(mapData, MAP_DATA_SIZE);
stat_vec &= ~BUSY;
}
}
// Check the drive_stop flag, which always should be set unless we should move
if ( stat_vec & DRIVE_STOP ) {
// Stop all movement
SetPWMLevel(0,0);
halt();
// MAKE SURE all drive-flags are not set
stat_vec &= ~(DRIVE_F | DRIVE_L | DRIVE_R | DRIVE_LL | BUSY);
}
// Should we drive?
else if ( stat_vec & DRIVE ) {
// Remove drive flag
stat_vec &= ~DRIVE;
// Increase PWM
increase_PWM(0,MAX_FORWARD_SPEED,0,MAX_FORWARD_SPEED);
if ( stat_vec & DRIVE_F ) {
enableTimer(TIMER2_BASE, DRIVE_FORWARD_TIME);
}
else if ( stat_vec & DRIVE_LL ) {
enableTimer(TIMER2_BASE, DRIVE_TURN_180_TIME);
}
else {
enableTimer(TIMER2_BASE, DRIVE_TURN_TIME);
}
}
if ( !(stat_vec & BUSY) ) {
// Tasks
switch ( stat_vec ) {
case ((uint8_t)DRIVE_F) :
// Call drive function
go_forward();
// Set the drive flag & BUSY
stat_vec |= DRIVE | BUSY;
break;
case ((uint8_t)DRIVE_L) :
// Call drive-left function
go_left();
// Set the drive flag
stat_vec |= DRIVE | BUSY;
break;
case ((uint8_t)DRIVE_R) :
// Call drive-right function
go_right();
// Set the drive flag
stat_vec |= DRIVE | BUSY;
break;
case ((uint8_t)DRIVE_LL) :
// Call turn 180-degrees function
go_back();
// Set the drive flag
stat_vec |= DRIVE | BUSY;
break;
case ((uint8_t)TAKE_MEAS) :
// Request reading from LIDAR
reqLidarMeas();
// Start TIMER1
enableTimer(TIMER1_BASE, (SYSCLOCK / MEASUREMENT_DELAY)); // if sysclock = 1 s, 1/120 = 8.3 ms
// We are busy
stat_vec |= BUSY;
break;
default:
break;
}
}
}
}
AdsModelRecord(const uint256& ahash, const int64_t atime, const std::string& msg):
hash(ahash), time(atime)
{
parseMsg(msg);
}
