/**
* Check all active event objects. If an event is detected, notify the
* associated waiting Java thread.
*/
void check_events()
{
int i;
for(i = 0; i < eventCnt; i++)
{
NXTEvent *event = events[i];
NXTEvent *sync = event->sync;
// Is this event being waited on, and has the event check period expired?
if (sync->state != 0 && (--event->updateCnt <= 0) && get_monitor_count(&(sync->_super.sync)) == 0)
{
// Check to see if we have anything of interest
int changed = ((*(eventCheckers[event->typ]))(event->filter) | event->userEvents | event->eventData) & event->filter;
event->eventData |= changed;
// notify the user thread
if (changed && (sync->state == WAITING))
{
// Don't notify this thread again.
sync->state |= SET;
monitor_notify_unchecked(&sync->_super, 1);
schedule_request(REQUEST_SWITCH_THREAD);
}
// Reste the check period counter
event->updateCnt = event->updatePeriod;
}
}
}
boolean debug_event(int event, Object *exception, const Thread *thread, const MethodRecord *method, byte *pc, int frame)
{
// Inform the debug thread (if any) that there has been a debug event.
// return false if no debug thread is waiting.
switch(debugEventOptions[event])
{
case DBG_EVENT_DISABLE:
return false;
case DBG_EVENT_IGNORE:
return true;
default:
break;
}
// Check that we have a debugger attached and that it is ready to go...
if (!debug || get_monitor_count((&(debug->_super.sync))) != 0 ||
debugThread->state != CONDVAR_WAITING || (Debug *)debugThread->waitingOn != debug)
return false;
// Setup the state
debug->typ = event;
debug->exception = ptr2ref(exception);
debug->thread = ptr2ref(thread);
debug->pc = (pc ? pc - get_binary_base() : 0);
debug->method = (method ? method - get_method_table(get_class_record(0)) : 0);
debug->frame = frame;
// Suspend all threads (except current)
suspend_thread(null);
// Make sure current thread is also suspended
suspend_thread(currentThread);
// Allow the debug thread to run
resume_thread(debugThread);
monitor_notify_unchecked(&debug->_super, 1);
return true;
}
/**
* set and/or clear events.
*/
int change_event(NXTEvent *event, JINT set, JINT clear)
{
event->userEvents &= ~clear;
event->userEvents |= set;
// deliver event now if it matches the filter and someone is waiting
set &= event->filter;
if (set && event->sync->state == WAITING && get_monitor_count(&(event->sync->_super.sync)) == 0)
{
event->eventData |= set;
event->sync->state |= SET;
monitor_notify_unchecked(&event->sync->_super, 1);
schedule_request(REQUEST_SWITCH_THREAD);
}
return event->userEvents;
}
boolean debug_event(int event, Throwable *exception, const Thread *thread,
const int method, const int pc, const int method2, const int pc2)
{
if (!debug)
return false;
// Check whether the event occured on a system thread. Events on system threads are disabled.
if (is_system(thread))
return false;
// Inform the debug thread (if any) that there has been a debug event.
// return false if no debug thread is waiting.
switch (debugEventOptions[event])
{
case DBG_EVENT_DISABLE:
return false;
case DBG_EVENT_IGNORE:
return true;
default:
break;
}
// Check that we have a debugger attached and that it is ready to go...
if (get_monitor_count((&(debug->_super.sync))) != 0
|| debugThread->state != CONDVAR_WAITING
|| (Debug *) debugThread->waitingOn != debug)
return false;
// Setup the state
debug->typ = event;
debug->exception = ptr2ref(exception);
debug->thread = ptr2ref(thread);
debug->pc = pc;
debug->method = method;
debug->method2 = method2;
debug->pc2 = pc2;
// Suspend all threads (except current)
suspend_thread(null);
// Make sure current thread is also suspended
if (!is_system(currentThread))
suspend_thread(currentThread);
// Allow the debug thread to run
debugThread->flags &= ~THREAD_DAEMON;
resume_thread(debugThread);
monitor_notify_unchecked(&debug->_super, 1);
return true;
}
void poll_inputs()
{
short changed = 0;
short button_state = 0;
short i;
short *pOldValue = old_sensor_values;
sensor_t *pSensor = &sensors[0];
char packet_available;
throttle_count--;
if( throttle_count == 0){
throttle_count = throttle;
// If we're not polling or someone already has the monitor
// return.
if (!poller || get_monitor_count((&(poller->_super))) != 0)
return;
// We do not have a thread that we can use to grab
// the monitor but that's OK because we are atomic
// anyway.
// Check the sensor canonical values.
for (i = 1<<SENSOR_POS; i<(1<<BUTTON_POS); i <<= 1, pOldValue++, pSensor++)
{
if (*pOldValue != pSensor->value) {
changed |= i;
*pOldValue = pSensor->value;
}
}
// Check the button status
read_buttons (0x3000, &button_state);
button_state <<= BUTTON_POS; // Shift into poll position
changed |= button_state ^ old_button_state;
old_button_state = button_state;
// Check serial status
check_for_data ( &packet_available, null);
if (packet_available) {
changed |= 1 << SERIAL_RECEIVED_POS;
}
// Only wake threads up if things have changed since
// we last looked.
if (changed)
{
// Or in the latest changes. Some threads may not have
// responded to earlier changes yet so we can't
// just overwrite them.
short jword = 0;
store_word((byte*)(&jword), 2, changed);
poller->changed |= jword;
#if DEBUG_POLL
jword = get_word((byte*)&poller->changed, 2);
printf("Poller: poller->changed = 0x%1X\n", jword);
#endif
// poller.notifyAll()
monitor_notify_unchecked(&poller->_super, 1);
}
}
}
