int main()
{
int fd, wd, len;
char buf[ 1024 * EV_SIZE ];
struct inotify_event *ie= NULL;
fd = inotify_init();
if ( fd != -1 )
printf( "fd = %d\n", fd );
else
{
printf( "init failed\n" );
return -1;
}
wd = inotify_add_watch( fd, "./lib/", IN_CREATE | IN_DELETE );
if ( wd != -1 )
printf( "wd = %d\n", wd );
else
{
printf( "addwatch failed\n" );
return -1;
}
while ( len = read( fd, buf, BUFSIZ ) )
{
if ( len )
{
printf( "%d readed\n", len );
do_analysis();
}
else
{
printf( "read failed\n" );
return -1;
}
ie = ( struct inotify_event * ) &buf[0];
if ( ie )
{
printf("wd %d, mask %d, ck %d, len %d, name %s\n",
ie->wd, ie->mask, ie->cookie, ie->len, ie->name);
}
else
printf( "ie null\n");
}
inotify_rm_watch( fd, wd );
close( fd );
return 0;
}
/************************************************************************
* clock_tick_handler() - Analyse data and update display.
* Updates the text layer clock_layer to show current time.
* This function is the handler for tick events and is called every
* second.
*/
static void clock_tick_handler(struct tm *tick_time, TimeUnits units_changed) {
static char s_batt_buffer[16];
static char s_time_buffer[16];
static int dataUpdateCount = 0;
static int lastAlarmState = 0;
if (isManAlarm) {
APP_LOG(APP_LOG_LEVEL_DEBUG,"Manual Alarm - manAlarmTime=%d, manAlarmPeriod=%d",
manAlarmTime,manAlarmPeriod);
if (manAlarmTime < manAlarmPeriod) {
alarmState = ALARM_STATE_MAN_ALARM;
text_layer_set_text(alarm_layer, "** MAN ALARM **");
manAlarmTime += 1;
} else {
isManAlarm = 0;
manAlarmTime = 0;
}
}
if (isMuted) {
APP_LOG(APP_LOG_LEVEL_DEBUG,"Alarms Muted - muteTime=%d",muteTime);
if (muteTime < mutePeriod) {
text_layer_set_text(alarm_layer, "** MUTE **");
muteTime += 1;
} else {
isMuted = 0;
muteTime = 0;
}
}
// Do FFT analysis if we have filled the buffer with data.
if (accDataFull) {
do_analysis();
if (fallActive) check_fall(); // sets fallDetected global variable.
// Check the alarm state, and set the global alarmState variable.
alarm_check();
// If no seizure detected, modify alarmState to reflect potential fall
// detection
if ((alarmState == ALARM_STATE_OK) && (fallDetected==1))
alarmState = ALARM_STATE_FALL;
// Display alarm message on screen.
if (alarmState == ALARM_STATE_OK) {
text_layer_set_text(alarm_layer, "OK");
}
if (alarmState == ALARM_STATE_WARN) {
//vibes_short_pulse();
text_layer_set_text(alarm_layer, "WARNING");
}
if (alarmState == ALARM_STATE_ALARM) {
//vibes_long_pulse();
text_layer_set_text(alarm_layer, "** ALARM **");
}
if (alarmState == ALARM_STATE_FALL) {
//vibes_long_pulse();
text_layer_set_text(alarm_layer, "** FALL **");
}
if (isManAlarm) {
alarmState = ALARM_STATE_MAN_ALARM;
text_layer_set_text(alarm_layer, "** MAN ALARM **");
}
if (isMuted) {
alarmState = ALARM_STATE_MUTE;
text_layer_set_text(alarm_layer, "** MUTE **");
}
// Send data to phone if we have an alarm condition.
// or if alarm state has changed from last time.
if ((alarmState != ALARM_STATE_OK && !isMuted) ||
(alarmState != lastAlarmState)) {
sendSdData();
}
lastAlarmState = alarmState;
}
// See if it is time to send data to the phone.
dataUpdateCount++;
if (dataUpdateCount>=dataUpdatePeriod) {
sendSdData();
dataUpdateCount = 0;
}
// Update the display
text_layer_set_text(text_layer, "OpenSeizureDetector");
if (clock_is_24h_style()) {
strftime(s_time_buffer, sizeof(s_time_buffer), "%H:%M:%S", tick_time);
} else {
strftime(s_time_buffer, sizeof(s_time_buffer), "%I:%M:%S", tick_time);
}
text_layer_set_text(clock_layer, s_time_buffer);
BatteryChargeState charge_state = battery_state_service_peek();
snprintf(s_batt_buffer,sizeof(s_batt_buffer),
"%d%%",
charge_state.charge_percent);
text_layer_set_text(batt_layer, s_batt_buffer);
}
/************************************************************************
* clock_tick_handler() - Analyse data and update display.
* Updates the text layer clock_layer to show current time.
* This function is the handler for tick events.*/
static void clock_tick_handler(struct tm *tick_time, TimeUnits units_changed) {
static char s_time_buffer[16];
static char s_alarm_buffer[64];
static char s_buffer[256];
static int analysisCount=0;
/* Only process data every ANALYSIS_PERIOD seconds */
analysisCount++;
if (analysisCount>=ANALYSIS_PERIOD) {
// Do FFT analysis
if (accDataFull) {
do_analysis();
if (fallActive) check_fall(); // sets fallDetected global variable.
// Check the alarm state, and set the global alarmState variable.
alarm_check();
// If no seizure detected, modify alarmState to reflect potential fall
// detection
if ((alarmState == 0) && (fallDetected==1)) alarmState = 3;
// Display alarm message on screen.
if (alarmState == 0) {
text_layer_set_text(alarm_layer, "OK");
}
if (alarmState == 1) {
//vibes_short_pulse();
text_layer_set_text(alarm_layer, "WARNING");
}
if (alarmState == 2) {
//vibes_long_pulse();
text_layer_set_text(alarm_layer, "** ALARM **");
}
if (alarmState == 3) {
//vibes_long_pulse();
text_layer_set_text(alarm_layer, "** FALL **");
}
// Send data to phone
sendSdData();
}
// Re-set counter.
analysisCount = 0;
}
// Update data display.
//snprintf(s_buffer,sizeof(s_buffer),
// "max=%d, P=%ld\n%d Hz",
// /*latestAccelData.x, latestAccelData.y, latestAccelData.z,*/
// maxVal,specPower,maxFreq
// );
text_layer_set_text(text_layer, "OpenSeizureDetector");
// and update clock display.
if (clock_is_24h_style()) {
strftime(s_time_buffer, sizeof(s_time_buffer), "%H:%M:%S", tick_time);
} else {
strftime(s_time_buffer, sizeof(s_time_buffer), "%I:%M:%S", tick_time);
}
BatteryChargeState charge_state = battery_state_service_peek();
snprintf(s_time_buffer,sizeof(s_time_buffer),
"%s %d%%",
s_time_buffer,
charge_state.charge_percent);
text_layer_set_text(clock_layer, s_time_buffer);
}
void analysis(int playernum, int governor, int apcount)
{
int pnum;
int sector_type = -1; /* -1 does analysis on all types */
int i = 1;
int do_player = -1;
int mode = 1; /* Does top five. 0 does low five */
placetype where; /* Otherwise on specific type */
char *p;
where.level = Dir[playernum - 1][governor].level;
where.snum = Dir[playernum - 1][governor].snum;
where.pnum = Dir[playernum - 1][governor].pnum;
p = args[1];
/*
* Must use 'd' to do an analysis on desert sector to avoid confusion with
* the '-' for the mode type
*/
if (*p == '-') {
++p;
++i;
mode = 0;
}
switch (*p) {
case CHAR_SEA:
sector_type = SEA;
break;
case CHAR_LAND:
sector_type = LAND;
break;
case CHAR_MOUNT:
sector_type = MOUNT;
break;
case CHAR_GAS:
sector_type = GAS;
break;
case CHAR_ICE:
sector_type = ICE;
break;
case CHAR_FOREST:
sector_type = FOREST;
break;
/*
* Duh, can't use '-'
* case CHAR_DESERT:
* sector_type = DESERT;
*
* break;
*/
case 'd':
sector_type = DESERT;
break;
case CHAR_PLATED:
sector_type = PLATED;
break;
case CHAR_WASTED:
sector_type = WASTED;
break;
case CHAR_WORM:
sector_type = WORM;
break;
}
if ((sector_type != -1) && (mode == 1)) {
++i;
}
p = args[i];
if (isdigit((unsigned char)*p)) {
do_player = atoi(p);
if (do_player > Num_races) {
notify(playernum, governor, "No such player #.\n");
return;
}
where.level = Dir[playernum - 1][governor].level;
where.snum = Dir[playernum - 1][governor].snum;
where.pnum = Dir[playernum - 1][governor].pnum;
++i;
}
p = args[i];
if ((i < argn) && (isalpha((unsigned char)*p) || (*p == '/'))) {
where = Getplace(playernum, governor, args[i], 0);
if (where.err) {
return;
}
}
switch (where.level) {
case LEVEL_UNIV:
notify(playernum, governor, "You can only analyze planets.\n");
break;
case LEVEL_PLAN:
do_analysis(playernum,
governor,
do_player,
mode,
sector_type,
(int)where.snum,
(int)where.pnum);
break;
case LEVEL_STAR:
for (pnum = 0; pnum < Stars[where.snum]->numplanets; ++pnum) {
do_analysis(playernum,
governor,
do_player,
mode,
sector_type,
(int)where.snum,
pnum);
}
break;
}
return;
}
ciMethodBlocks::ciMethodBlocks(Arena *arena, ciMethod *meth): _method(meth),
_arena(arena), _num_blocks(0), _code_size(meth->code_size()) {
int block_estimate = _code_size / 8;
_blocks = new(_arena) GrowableArray<ciBlock *>(block_estimate);
int b2bsize = _code_size * sizeof(ciBlock **);
_bci_to_block = (ciBlock **) arena->Amalloc(b2bsize);
Copy::zero_to_words((HeapWord*) _bci_to_block, b2bsize / sizeof(HeapWord));
// create initial block covering the entire method
ciBlock *b = new(arena) ciBlock(_method, _num_blocks++, 0);
_blocks->append(b);
_bci_to_block[0] = b;
// create blocks for exception handlers
if (meth->has_exception_handlers()) {
for(ciExceptionHandlerStream str(meth); !str.is_done(); str.next()) {
ciExceptionHandler* handler = str.handler();
ciBlock *eb = make_block_at(handler->handler_bci());
//
// Several exception handlers can have the same handler_bci:
//
// try {
// if (a.foo(b) < 0) {
// return a.error();
// }
// return CoderResult.UNDERFLOW;
// } finally {
// a.position(b);
// }
//
// The try block above is divided into 2 exception blocks
// separated by 'areturn' bci.
//
int ex_start = handler->start();
int ex_end = handler->limit();
// ensure a block at the start of exception range and start of following code
(void) make_block_at(ex_start);
if (ex_end < _code_size)
(void) make_block_at(ex_end);
if (eb->is_handler()) {
// Extend old handler exception range to cover additional range.
int old_ex_start = eb->ex_start_bci();
int old_ex_end = eb->ex_limit_bci();
if (ex_start > old_ex_start)
ex_start = old_ex_start;
if (ex_end < old_ex_end)
ex_end = old_ex_end;
eb->clear_exception_handler(); // Reset exception information
}
eb->set_exception_range(ex_start, ex_end);
}
}
// scan the bytecodes and identify blocks
do_analysis();
// mark blocks that have exception handlers
if (meth->has_exception_handlers()) {
for(ciExceptionHandlerStream str(meth); !str.is_done(); str.next()) {
ciExceptionHandler* handler = str.handler();
int ex_start = handler->start();
int ex_end = handler->limit();
int bci = ex_start;
while (bci < ex_end) {
ciBlock *b = block_containing(bci);
b->set_has_handler();
bci = b->limit_bci();
}
}
}
}
