short DB_GetLen( mvar *var, int lock, u_char *buf) // length of node
{ short s; // for returns
int sav; // save curr_lock
if ((lock == -1) && (buf == NULL)) // just unlock?
{ if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // unlock it
}
return 0; // exit
}
sav = curr_lock; // save this
s = Copy2local(var); // get local copy
curr_lock = sav; // restore current lock
if (s < 0) // check for error
{ if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return s; // and return
}
s = Get_data(0); // attempt to get it
if (s < 0) // check for error
{ if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return s; // and return
}
if (buf != NULL) // want data?
{ s = mcopy(record->buf, buf, record->len); // copy the data
}
if ((lock != 1) && (curr_lock)) // preserve lock?
{ SemOp( SEM_GLOBAL, -curr_lock); // no - release it
}
return s; // and exit
}
void *Sensor_data(void *arg)
{
while(1)
{
Get_data();
sleep(5); //sleep 5 mins
}
}
short DB_Data(mvar *var, u_char *buf) // get $DATA()
{ short s; // for returns
int i; // a handy int
s = Copy2local(var); // get local copy
if (s < 0)
{ return s; // exit on error
}
systab->vol[volnum-1]->stats.dbdat++; // update stats
s = Get_data(0); // attempt to get it
i = 1; // assume data found
if (s == -ERRM7) // undefined global?
{ i = 0; // yes - no data
if (level == 0) // check for global
{ if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
buf[0] = '0'; // zero to return
buf[1] = '\0'; // null terminated
return 1; // and exit
}
}
else if (s < 0) // if it failed
{ if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return s; // and exit
}
if ((!db_var.slen) && (!i)) // pointing at 1st
{ Index++;
}
if ((i) || (Index > blk[level]->mem->last_idx)) // found or passed end
{ s = Locate_next(); // get next record
if (s == -ERRM7) // any more?
{ if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return itocstring(buf, i); // return result
}
else if (s < 0) // error?
{ if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return s; // and exit
}
} // got next record
if (((db_var.slen < keybuf[0]) && // if smaller key and
(bcmp(&keybuf[1], db_var.key, db_var.slen) == 0)) || // a descendant?
(!db_var.slen))
{ i += 10; // add 10 to result
}
if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return itocstring(buf, i); // return result
}
short DB_QueryD(mvar *var, u_char *buf) // get next key
{ short s; // for returns
// int i; // a handy int
s = Copy2local(var); // get local copy
if (s < 0)
{ return s; // exit on error
}
s = Get_data(0); // try to find that
if ((s < 0) && (s != -ERRM7)) // check for errors
{ if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return s; // and return the error
}
if ((level == 0) && (s == -ERRM7)) // if no such global
{ buf[0] = '\0'; // null terminate ret
if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return -(ERRMLAST+ERRZ55); // and return
}
if ((s < 0) && (db_var.slen)) // If we had a "real"
{ Index--; // <UNDEF> last time
} // back up Index
s = Locate_next(); // point at next
if (s < 0) // not found or error
{ if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
if (s == -ERRM7) // if no more
{ s = -(ERRMLAST+ERRZ55); // say 'at end'
}
return s; // done
}
// for (i = 10; i <= Index; i++) // scan to current
// { chunk = (cstring *) &iidx[idx[i]]; // point at the chunk
// bcopy(&chunk->buf[2], &keybuf[chunk->buf[0]+1],
// chunk->buf[1]); // update the key
// keybuf[0] = chunk->buf[0] + chunk->buf[1]; // and the size
// }
bcopy(&keybuf[1], var->key, (int) keybuf[0]); // copy in the key
var->slen = keybuf[0]; // update the length
s = mcopy(record->buf, buf, record->len); // copy the data
if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return s; // return the count
}
void main(void)
{
int AX;
int AY;
twi_init();
delay_nms(50);
MPU_6050_init();
delay_nms(500);
Usart_init();
//hc05_init();
while(1)
{
delay_nms(50000);
AX=Get_data(ACCEL_XOUT_H)/187.62;
AY=Get_data(ACCEL_YOUT_H)/187.62;
if(AY<86)
{
USART_Transmit('1');
//UCSRB=0X90; //关发送使能
}
else
{
USART_Transmit('0');
}
/*else
{
sent('2');
//UCSRB=0X90; //关发送使能
if(AX<45 || AY<45)
{
UCSRB=0X98; //打开发送使能
}
}*/
}
}
void ComsumeController::getInfoContent()
{
std::string post_command = NativeLauncher::getNWAdress() + "/get_message?type=10";
std::string recv = Get_data(post_command.c_str());
Json* json = Json_create(recv.c_str());
if (json) {
com_text_ext = Json_getString(json, "text", "");
com_uri_ext = Json_getString(json, "apn", "");
com_attend_ext = Json_getString(json, "attention", "");
com_attend_type = Json_getInt(json, "attend_type", 0);
}
return;
}
int DB_SetFlags(mvar *var, int flags) // Set flags
{ int clearit = 0;
int i;
short s;
if (flags < 0)
{ clearit = 1; // setup to clear
flags = -flags; // get flags correct
}
s = Copy2local(var); // get local copy
if (s < 0)
{ return s; // exit on error
}
systab->vol[volnum-1]->stats.dbset++; // update stats
writing = 1; // say we are writing
while (systab->vol[volnum - 1]->writelock) // check for write lock
{ i = sleep(5); // wait a bit
if (partab.jobtab->attention)
{ return -(ERRZLAST+ERRZ51); // for <Control><C>
}
} // end writelock check
Get_GBDs(1); // ensure this many
s = Get_data(0); // try to find that
if ((s < 0) && (s != -ERRM7)) // check for errors
{ if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return (int) s; // return error
}
i = ((int *)record)[1]; // get current flags
if (clearit)
{ i = i & ~flags; // clear flags
}
else
{ i = i | flags; // set flags
}
((int *)record)[1] = i; // set back to GD
if (blk[level]->dirty == (gbd *) 1) // if reserved
{ blk[level]->dirty = blk[level]; // terminate list
Queit(); // que for write
}
SemOp( SEM_GLOBAL, -curr_lock); // release global lock
return i; // return current flags
}
void TPlayer::Refresh_data(CURL* curl)
{
std::vector<TSpolka> notowania =
TGielda::Get_instance().Get_quoatations();
/* if it's first refresh, we need to init company's list */
if (my_companies.size() == 0)
my_companies = Get_data(curl);
std::vector<TSpolka>::iterator it = my_companies.begin();
std::string body;
while (it != my_companies.end())
{
std::vector<TSpolka>::iterator actual_course = find(notowania.begin(),
notowania.end(), *it);
if (actual_course != notowania.end())
{
float diff = actual_course->Get_day_delta() - it->Get_day_delta();
if (diff != 0)
{
char bufor[1024];
sprintf(bufor,
"<span color=\"%s\">%s %.2f%% -> %.2f%%</span>",
Get_color(diff), actual_course->Get_name(),
it->Get_day_delta(), actual_course->Get_day_delta());
body += "\n";
body += bufor;
it->Set_day_delta(actual_course->Get_day_delta());
it->Set_price(actual_course->Get_price());
}
}
else
printf("Nie ma spolki: %s na liscie notowan!\n", it->Get_name());
it++;
}
if (body != "")
{
NotifyNotification* notify = notify_notification_new(
my_name, body.c_str() + 1, NULL);
notify_notification_set_timeout(notify, 10 * 1000);
notify_notification_show(notify, NULL);
g_object_unref(G_OBJECT(notify));
}
}
void EstateController::getEstateInfoContent()
{
std::string post_command = NativeLauncher::getNWAdress() + "/get_message?type=8";
std::string recv = Get_data(post_command.c_str());
Json* json = Json_create(recv.c_str());
if (json) {
std::string text_ext = Json_getString(json, "text", "");
std::string annualincome = Json_getString(json, "annualincome", "");
std::string leisurecost = Json_getString(json, "leisurecost", "");
std::string floorspace = Json_getString(json, "floorspace", "");
std::string buildyear = Json_getString(json, "buildyear", "");
std::string architect = Json_getString(json, "architect", "");
std::string roomsnum = Json_getString(json, "roomsnum", "");
std::string electype = Json_getString(json, "electype", "");
std::string waterheater = Json_getString(json, "waterheater", "");
std::string cookingdevice = Json_getString(json, "cookingdevice", "");
int recommend = Json_getInt(json, "recommend", 0);
}
return;
}
int DB_GetFlags(mvar *var) // Get flags
{ short s; // for returns
int i; // a handy int
s = Copy2local(var); // get local copy
if (s < 0)
{ return s; // exit on error
}
s = Get_data(0); // try to find that
if ((s < 0) && (s != -ERRM7)) // check for errors
{ if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return s; // and return the error
}
i = ((int *) record)[1]; // get the value
if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return i; // return the flags
}
short DB_Get(mvar *var, u_char *buf) // get global data
{ short s; // for returns
s = Copy2local(var); // get local copy
if (s < 0)
{ return s; // exit on error
}
systab->vol[volnum-1]->stats.dbget++; // update stats
s = Get_data(0); // attempt to get it
if (s >= 0) // if worked
{ if (bcmp("$GLOBAL\0", &db_var.name.var_cu[0], 8) == 0) // if ^$G
{ s = itocstring(buf, *(u_int *) record); // block number
}
else
{ s = mcopy(record->buf, buf, record->len); // copy the data
}
}
if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return s; // return the count
}
short DB_Compress(mvar *var, int flags) // Compress global
{ int i;
short s;
int retlevel; // the ACTUAL level
flags &= 15; // clear high bits
s = Copy2local(var); // get local copy
if (s < 0)
{ return s; // exit on error
}
bzero(rekey_blk, MAXREKEY * sizeof(u_int)); // clear that table
bzero(rekey_lvl, MAXREKEY * sizeof(int)); // and that table
bcopy(&db_var, var, sizeof(mvar)); // copy the data back
s = Get_data(flags); // get to level 'flags'
retlevel = level; // save real level
if (!level)
{ return -ERRM7; // give up if nosuch
}
chunk = (cstring *) &iidx[idx[10]]; // point at the first
bcopy(&chunk->buf[1], &var->slen, chunk->buf[1]+1); // save the real key
while (TRUE)
{ bcopy(var, &db_var, sizeof(mvar)); // get next key
writing = 0; // flag we are reading
while (systab->vol[volnum - 1]->writelock) // check for write lock
{ i = sleep(5); // wait a bit
if (partab.jobtab->attention)
{ return -(ERRZLAST+ERRZ51); // for <Control><C>
}
} // end writelock check
if (partab.jobtab->attention)
{ return -(ERRZLAST+ERRZ51); // for <Control><C>
}
s = Get_data(retlevel); // get the block
if ((s == -ERRM7) && (!db_var.slen)) // if first node
{ s = 0; // it exists
}
if (s == -ERRM7) // if key changed
{ if (blk[level]->mem->right_ptr) // if more
{ chunk = (cstring *) &iidx[idx[10]]; // point at the first
bcopy(&chunk->buf[1], &db_var.slen, chunk->buf[1]+1); // save real key
SemOp( SEM_GLOBAL, -curr_lock); // release global lock
continue; // go again
}
SemOp( SEM_GLOBAL, -curr_lock); // release global lock
return retlevel; // all done, exit
}
if (s < 0)
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
return s; // exit on error
}
if (!blk[level]->mem->right_ptr) // if no more
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
if ((retlevel == 2) && (!db_var.slen)) // if only block lvl 2
{ s = Compress1(); // do that
SemOp( SEM_GLOBAL, -curr_lock); // release write lock
if (s < 0)
{ return s; // exit on error
}
}
return retlevel; // all done, exit
}
level++;
s = Get_block(blk[level - 1]->mem->right_ptr);
if (s < 0) // if error
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
return s; // exit on error
}
i = ((blk[level-1]->mem->last_free*2 + 1 - blk[level-1]->mem->last_idx)*2)
+ ((blk[level]->mem->last_free*2 + 1 - blk[level]->mem->last_idx)*2);
if (i < 1024) // if REALLY not enough space (btw: make this a param)
{ chunk = (cstring *) &iidx[idx[10]]; // point at first in RL
bcopy(&chunk->buf[1], &var->slen, chunk->buf[1]+1); // save the real key
SemOp( SEM_GLOBAL, -curr_lock); // release global lock
continue; // go again
}
level = retlevel;
SemOp( SEM_GLOBAL, -curr_lock); // release read lock
s = Compress1(); // do that
SemOp( SEM_GLOBAL, -curr_lock); // release write lock
if (s < 0)
{ return s; // exit on error
}
if (!var->volset) // if done
{ return retlevel;
}
}
}
int main(int argc, char** argv) {
int my_rank; /* My process rank */
int p; /* The number of processes */
double a; /* Left endpoint */
double b; /* Right endpoint */
int n; /* Number of trapezoids */
double h; /* Trapezoid base length */
double local_a; /* Left endpoint my process */
double local_b; /* Right endpoint my process */
int local_n; /* Number of trapezoids for */
/* my calculation */
double area; /* My subarea */
double total = 0; /* Total area */
int source; /* Process sending area */
int dest = 0; /* All messages go to 0 */
int tag = 0;
MPI_Status status;
double start, finish, par_elapsed;
/* Let the system do what it needs to start up MPI */
MPI_Init(&argc, &argv);
/* Get my process rank */
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
/* Find out how many processes are being used */
MPI_Comm_size(MPI_COMM_WORLD, &p);
Get_data(p, my_rank, &a, &b, &n);
MPI_Barrier(MPI_COMM_WORLD);
start = MPI_Wtime();
h = (b-a)/n; /* h is the same for all processes */
local_n = n/p; /* So is the number of trapezoids */
/* Length of each process' interval of
* integration = local_n*h. So my interval
* starts at: */
local_a = a + my_rank*local_n*h;
local_b = local_a + local_n*h;
area = Trap(local_a, local_b, local_n, h);
/* Add up the areas calculated by each process */
if (my_rank == 0) {
total = area;
for (source = 1; source < p; source++) {
MPI_Recv(&area, 1, MPI_DOUBLE, source, tag,
MPI_COMM_WORLD, &status);
total = total + area;
}
} else {
MPI_Send(&area, 1, MPI_DOUBLE, dest,
tag, MPI_COMM_WORLD);
}
finish = MPI_Wtime();
par_elapsed = finish - start;
par_elapsed = Get_max_time(par_elapsed, my_rank, p);
/* Print the result */
if (my_rank == 0) {
printf("With n = %d trapezoids, our estimate\n",
n);
printf("of the area from %f to %f = %23.16e\n",
a, b, total);
printf("Parallel elapsed time = %e seconds\n", par_elapsed);
}
/* Shut down MPI */
MPI_Finalize();
return 0;
} /* main */
short DB_Query(mvar *var, u_char *buf, int dir) // get next key
{ short s; // for returns
int i; // a handy int
s = Copy2local(var); // get local copy
if (s < 0)
{ return s; // exit on error
}
systab->vol[volnum-1]->stats.dbqry++; // update stats
if (dir < 0) // if it's backward
{ s = Get_data(-1); // get the previous
if ((s < 0) && (s != -ERRM7)) // check for errors
{ if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return s; // and return the error
}
if ((level == 0) && (s == -ERRM7)) // if no such global
{ buf[0] = '\0'; // null terminate ret
if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return 0; // and return
}
Index--; // backup the Index
if (Index < 10) // can't happen?
{ panic("DB_Query: Problem with negative direction");
}
chunk = (cstring *) &iidx[idx[Index]]; // point at the chunk
record = (cstring *) &chunk->buf[chunk->buf[1]+4]; // point at the dbc
if ((!chunk->buf[0]) && (!chunk->buf[1]) && // if first node
((partab.jobtab->last_block_flags & GL_TOP_DEFINED) == 0))
{ buf[0] = '\0'; // null terminate ret
if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return 0; // and return
}
} // end backwards
else // it's forward
{ s = Get_data(0); // try to find that
if ((s < 0) && (s != -ERRM7)) // check for errors
{ if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return s; // and return the error
}
if ((level == 0) && (s == -ERRM7)) // if no such global
{ buf[0] = '\0'; // null terminate ret
if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return 0; // and return
}
if ((s < 0) && (!db_var.slen))
{ Index++;
}
if ((Index > blk[level]->mem->last_idx) || (s >= 0)) // want next one
{ s = Locate_next(); // point at next
if (s < 0) // not found or error
{ if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
buf[0] = '\0'; // null terminate ret
if (s == -ERRM7) // undefined?
{ s = 0; // yes - clear it
}
return s; // done
}
}
}
for (i = 10; i <= Index; i++) // scan to current
{ chunk = (cstring *) &iidx[idx[i]]; // point at the chunk
bcopy(&chunk->buf[2], &keybuf[chunk->buf[0]+1],
chunk->buf[1]); // update the key
keybuf[0] = chunk->buf[0] + chunk->buf[1]; // and the size
}
if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
db_var.uci = var->uci; // copy
db_var.volset = var->volset; // original & new
db_var.name.var_qu = var->name.var_qu; // data
db_var.slen = keybuf[0]; // to
bcopy(&keybuf[1], &db_var.key[0], keybuf[0]); // db_var
return UTIL_String_Mvar(&db_var, buf, 9999); // convert and return
}
short DB_Order(mvar *var, u_char *buf, int dir) // get next subscript
{ short s; // for returns
int i; // a handy int
int last_key; // start of last key
s = Copy2local(var); // get local copy
if (s < 0)
{ return s; // exit on error
}
systab->vol[volnum-1]->stats.dbord++; // update stats
last_key = UTIL_Key_Last(&db_var); // get start of last
buf[0] = '\0'; // null terminate ret
if (dir < 0) // if it's backward
{ s = Get_data(-1); // get the previous
if ((s < 0) && (s != -ERRM7)) // check for errors
{ if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return s; // and return the error
}
if ((level == 0) && (s == -ERRM7) && // if no such global
(bcmp(&db_var.name.var_cu[0], "$GLOBAL\0", 8))) // and not ^$G()
{ if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return 0; // and return
}
Index--; // backup the Index
if (Index < 10) // can't happen?
{ panic("DB_Order: Problem with negative direction");
}
chunk = (cstring *) &iidx[idx[Index]]; // point at the chunk
record = (cstring *) &chunk->buf[chunk->buf[1]+4]; // point at the dbc
} // end backwards
else // it's forward
{ db_var.key[db_var.slen++] = 255; // force next key
s = Get_data(0); // try to find that
if (s != -ERRM7) // MUST be undefined
{ if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return (s < 0) ? s : -(ERRMLAST+ERRZ61); // and return the error
}
if ((level == 0) && // if no such global
(bcmp(&db_var.name.var_cu[0], "$GLOBAL\0", 8))) // and not ^$G()
{ if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return 0; // and return
}
if (Index > blk[level]->mem->last_idx) // no more avbl
{ s = Locate_next(); // get next (if there)
if (s < 0) // failed?
{ if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return (s == -ERRM7) ? 0 : s; // done
}
}
} // end forwards
for (i = 10; i <= Index; i++) // scan to current
{ chunk = (cstring *) &iidx[idx[i]]; // point at the chunk
bcopy(&chunk->buf[2], &keybuf[chunk->buf[0]+1],
chunk->buf[1]); // update the key
keybuf[0] = chunk->buf[0] + chunk->buf[1]; // and the size
}
if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
if ((keybuf[0] < (last_key + 1)) ||
(bcmp(&keybuf[1], db_var.key, last_key))) // check for past it
{ return 0; // done
}
i = 0; // clear flag
s = UTIL_Key_Extract(&keybuf[last_key+1], buf, &i); // extract the key
return s; // return result
}
if (s < 0) // failed?
{ return s; // return error
}
Allign_record(); // if not alligned
*( (u_int *) record) = blk[1]->block; // new top level blk
level = 1;
blk[level]->dirty = blk[level]; // hook to self
if (blk[0]->dirty == (gbd *) 1) // if not queued
{ blk[0]->dirty = blk[level]; // hook it
level = 0; // and clear level
}
Queit(); // que to write
return 0; // end of level == 0
}
s = Get_data(this_level); // get the key blk
if (s >= 0) // if found
{ return -(ERRMLAST+ERRZ61); // database problem
}
if (s != -ERRM7) // any other error
{ return s; // give up
}
if (blk[level]->block == ptr_blk)
{ return -(ERRMLAST+ERRZ61); // database problem
}
Index++; // point at insert
// see Get_data()
trailings = Index; // remember for later
if (trailings < 11) // if junk
{ return -(ERRMLAST+ERRZ61); // database stuffed
}
int main(int argc, const char *argv[])
{
#define OPEN 1
#define CLOSE 0
pthread_t show_data,wait_controller;
int err,ret,alive;
FD_ZERO(&wset);
FD_ZERO(&rset);
FD_SET(fd,&wset);
FD_SET(fd,&rset);
ss = fx_serial_start();
fd = client_init(7000,argv[1]);
select(fd+1,&rset,&wset,NULL,NULL);
restart:
/*set keepalive on fd*/
alive = 1;
if(setsockopt(fd,SOL_SOCKET,SO_KEEPALIVE,&alive,sizeof(alive)) != 0)
{
fprintf(stderr,"set socket option error\n");
goto restart;
}
socket_set_keepalive(fd);
ret = connect_retry(fd,(struct sockaddr *)&clientaddr,sizeof(clientaddr));
if(ret == -1)
{
printf("cannot connect to server\n");
exit(1);
}
signal(SIGINT,free_space);
err = pthread_create(&wait_controller,NULL,Control_controller,NULL);
if(err != 0)
{
fprintf(stderr,"cannot create the thread\n");
exit(1);
}
while(1)
{
header__init(&MS.mh);
sensor_info__init(&MS.si);
sensor_t__init(&MS.st);
Get_data();
//test();
sleep(293); //sleep 5 mins
}
//err = pthread_create(&show_data,NULL,Sensor_data,NULL);
//if(err != 0)
// {
// fprintf(stderr,"cannot create the thread\n");
// exit(1);
//}
//pthread_join(show_data, NULL);
pthread_join(wait_controller, NULL);
//while(1) getchar();
return 0;
}
// Sending out data regulary ~ 0,25 sec period
void TIM7_IRQHandler(void) {
if (TIM_GetITStatus(TIM7, TIM_IT_Update) == SET) {
TIM_ClearITPendingBit(TIM7, TIM_IT_Update);
uint8_t received_data;
// Sending out data if client started the system
if(WORK == 1) {
/*Temperature message:
* 1 byte - START
* 1 byte - HEADER
* 4 byte - Length - Client needs this length
* 2 byte - Data
* TOTAL: 8 byte
*/
uint8_t message_temperature[temperature_message_length];
//Sending temperature 1 data
temperature = 0;
temperature = get_temperature(1);
construct_temperature_message(message_temperature,temperature,ID_temp1);
Send_data(message_temperature,temperature_message_length);
//Sending temperature 2 data
temperature = 0;
temperature = get_temperature(2);
//temperature = 0;
construct_temperature_message(message_temperature,temperature,ID_temp2);
Send_data(message_temperature,temperature_message_length);
//Sending temperature 3 data
temperature = 0;
temperature = get_temperature(3);
construct_temperature_message(message_temperature,temperature,ID_temp3);
Send_data(message_temperature,temperature_message_length);
//Sending temperature 4 data
temperature = 0;
temperature = get_temperature(4);
//temperature = 0;
construct_temperature_message(message_temperature,temperature,ID_temp4);
Send_data(message_temperature,temperature_message_length);
//free(message);
/*Fan frequency message:
* 1 byte - START
* 1 byte - HEADER
* 4 byte - Length - Client needs this length
* 1 byte - Data
* TOTAL: 7 byte
*/
uint8_t message_frequency[fan_frequency_message_length];
// Sending frequency of Fan 1
if(Fan_1_frequency == Fan_1_frequency_previous && Fan_1_frequency < 15) {
Fan_1_frequency = 0;
Fan_1_frequency_previous = 0;
}
construct_fan_frequency_message(message_frequency,Fan_1_frequency,ID_freq1);
Send_data(message_frequency,fan_frequency_message_length);
// Sending frequency of Fan 3
if(Fan_3_frequency == Fan_3_frequency_previous && Fan_3_frequency < 15) {
Fan_3_frequency = 0;
Fan_3_frequency_previous = 0;
}
construct_fan_frequency_message(message_frequency,Fan_3_frequency,ID_freq3);
Send_data(message_frequency,fan_frequency_message_length);
/*Fan PWM message:
* 1 byte - START
* 1 byte - HEADER
* 4 byte - Length - Client needs this length
* 1 byte - Data
* TOTAL: 7 byte
*/
uint8_t message_PWM[fan_PWM_message_length];
// Sending PWM of fan 1
construct_fan_PWM_message(message_PWM,Fan_1_PWM,ID_fan_1_PWM);
Send_data(message_PWM,fan_PWM_message_length);
// Sending PWM of fan 3
construct_fan_PWM_message(message_PWM,Fan_3_PWM,ID_fan_3_PWM);
Send_data(message_PWM,fan_PWM_message_length);
}
else {
//If sending out data is not allowed, send halted message continuously
uint8_t message_Halted[halted_message_length];
construct_halt_message(message_Halted);
Send_data(message_Halted,halted_message_length);
}
// Processing received data
while(Get_data(&received_data) == 1){
if(received_data == 0xff){
start_arrived = 1;
header = 0;
}
else if(start_arrived){
header = received_data;
start_arrived = 0;
header_arrived = 1;
}
else if(header_arrived){
length += ((uint32_t)received_data) << (length_byte_count * 8);
length_byte_count++;
if(length_byte_count == 4){
header_arrived = 0;
}
}
else if(length_byte_count == 4){
data[data_byte_count] = received_data;
data_byte_count++;
if(data_byte_count == length){
length_byte_count = 0;
length = 0;
data_byte_count = 0;
Parse_message(header,data);
}
}
}
}
}
int main(int argc, char** argv){
int my_rank;
int p;
float a = 0.0;
float b = 1.0;
int n = 1024;
float h;
float local_a;
float local_b;
int local_n;
float integral;
float total;
int source;
int dest = 0;
int tag = 0;
int f;
MPI_Status status;
float (*functions[2]) (float x);
float Trap(float local_a, float local_b, int local_n, float h, float (*f)(float));
functions[0] = square;
functions[1] = cube;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
MPI_Comm_size(MPI_COMM_WORLD, &p);
if ( my_rank == 0){
printf("Integrate 0. Squared - 1.Cubed\n");
scanf("%d",&f);
for(dest = 1;dest <p; dest++)
MPI_Send( &f, 1, MPI_FLOAT, dest, tag, MPI_COMM_WORLD);
}
else{
MPI_Recv( &f, 1, MPI_FLOAT, 0, tag, MPI_COMM_WORLD, &status);
}
Get_data( &a, &b,&n, my_rank, p);
h = (b-a)/n;
local_n = n/p;
local_a = a + my_rank*local_n*h;
local_b = local_a + local_n*h;
integral = Trap(local_a, local_b, local_n, h, functions[f]);
if( my_rank == 0){
total = integral;
for ( source = 1; source < p; source ++){
MPI_Recv(&integral,1, MPI_FLOAT, source, tag, MPI_COMM_WORLD, &status);
total = total + integral;
}
}
else{
MPI_Send(&integral, 1, MPI_FLOAT,dest, tag, MPI_COMM_WORLD);
}
if (my_rank == 0){
printf("With n == %d trapezoids, our estimate \n",n);
printf("of the integral from %f to %f == %f \n",a,b,total);
}
MPI_Finalize();
return 0;
}
main(int argc, char** argv) {
int my_rank; /* My process rank */
int p; /* The number of processes */
float a; /* Left endpoint */
float b; /* Right endpoint */
int n; /* Number of trapezoids */
float h; /* Trapezoid base length */
float local_a; /* Left endpoint my process */
float local_b; /* Right endpoint my process */
int local_n; /* Number of trapezoids for */
/* my calculation */
float integral; /* Integral over my interval */
float total; /* Total integral */
int source; /* Process sending integral */
int dest = 0; /* All messages go to 0 */
int tag = 0;
MPI_Status status;
void Get_data(float* a_ptr, float* b_ptr,
int* n_ptr, int my_rank, int p);
float Trap(float local_a, float local_b, int local_n,
float h); /* Calculate local integral */
/* Let the system do what it needs to start up MPI */
MPI_Init(&argc, &argv);
/* Get my process rank */
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
/* Find out how many processes are being used */
MPI_Comm_size(MPI_COMM_WORLD, &p);
Get_data(&a, &b, &n, my_rank, p);
h = (b-a)/n; /* h is the same for all processes */
local_n = n/p; /* So is the number of trapezoids */
/* Length of each process' interval of
* integration = local_n*h. So my interval
* starts at: */
local_a = a + my_rank*local_n*h;
local_b = local_a + local_n*h;
integral = Trap(local_a, local_b, local_n, h);
/* Add up the integrals calculated by each process */
if (my_rank == 0) {
total = integral;
for (source = 1; source < p; source++) {
MPI_Recv(&integral, 1, MPI_FLOAT, source, tag,
MPI_COMM_WORLD, &status);
total = total + integral;
}
} else {
MPI_Send(&integral, 1, MPI_FLOAT, dest,
tag, MPI_COMM_WORLD);
}
/* Print the result */
if (my_rank == 0) {
printf("With n = %d trapezoids, our estimate\n",
n);
printf("of the integral from %f to %f = %f\n",
a, b, total);
}
/* Shut down MPI */
MPI_Finalize();
} /* main */
short DB_Kill(mvar *var) // remove sub-tree
{ short s; // for returns
int i; // a handy int
s = Copy2local(var); // get local copy
if (s < 0)
{ return s; // exit on error
}
systab->vol[volnum-1]->stats.dbkil++; // update stats
while (systab->vol[volnum - 1]->writelock) // check for write lock
{ i = sleep(5); // wait a bit
if (partab.jobtab->attention)
{ return -(ERRZLAST+ERRZ51); // for <Control><C>
}
} // end writelock check
s = Get_data(0); // attempt to get it
if (((s == -ERRM7) && (level == 0)) || // if nosuch
((s < 0) && (s != -ERRM7))) // or an error
{ if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
if (s == -ERRM7) // if undefined
{ s = 0; // that is OK
}
return s; // nothing to do
}
if ((s == -ERRM7) && (db_var.slen)) // if undefined
{ if (Index <= blk[level]->mem->last_idx) // and still in block
{ if ((db_var.slen > keybuf[0]) || // found smaller key
(bcmp(&keybuf[1], db_var.key, db_var.slen))) // not a descendant?
{ if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return 0; // nothing to do
}
} // end still in block
else
{ s = Locate_next(); // point at next block
if (!s) // found one
{ if ((db_var.slen > keybuf[0]) || // found smaller key
(bcmp(&keybuf[1], db_var.key, db_var.slen))) // not a descendant?
{ s = -ERRM7; // flag for later
}
}
if (s < 0) // no such or error
{ if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
if (s == -ERRM7)
{ s = 0;
}
return 0; // nothing to do
}
}
}
s = Kill_data(); // do the kill
if (curr_lock) // if locked
{ SemOp( SEM_GLOBAL, -curr_lock); // release global lock
}
return s; // return the result
}
