void BattlegroundRV::StartingEventOpenDoors()
{
// Buff respawn
SpawnBGObject(BG_RV_OBJECT_BUFF_1, 90);
SpawnBGObject(BG_RV_OBJECT_BUFF_2, 90);
// Elevators
DoorOpen(BG_RV_OBJECT_ELEVATOR_1);
DoorOpen(BG_RV_OBJECT_ELEVATOR_2);
setState(BG_RV_STATE_OPEN_FENCES);
setTimer(BG_RV_FIRST_TIMER);
}
int main(void)
{
uint8_t src_packet[128] = {0x05, 0x30, 0x00, 0x00, 0x0A};
uint8_t rcvd_msg[128] = {0};
uint8_t rcvd_payload[128] = {0};
uint8_t rcvd_length;
uint8_t rcvd_payloadLength;
uint8_t rcvd_rssi;
uint8_t Type;
uint16_t Addr;
uint8_t radio_channel;
uint16_t radio_panID;
Type = Type_Light;
Addr = 0x0001;
radio_channel = 18;
radio_panID = 0x00AA;
Initial(Addr, Type, radio_channel, radio_panID);
setTimer(1,RETRANSMIT_PERIOD,UNIT_MS);
while(1){
// Periodically send the msg
if(checkTimer(1)){
RF_Tx(0xFFFF,src_packet,5);
}
// When received some packet
if(RF_Rx(rcvd_msg, &rcvd_length, &rcvd_rssi)){
getPayloadLength(&rcvd_payloadLength, rcvd_msg);
getPayload(rcvd_payload, rcvd_msg, rcvd_payloadLength);
// Check 1)header, 2)sequence number, 3)isACK field
if(rcvd_payload[0]==0x05 && rcvd_payload[1]==0x30 &&
rcvd_payload[2]==src_packet[2] && rcvd_payload[3]==1){
src_packet[2]++;
// Change the payload here
}
}
if(src_packet[2]==0x14)
break;
}
while(1){
if(checkTimer(1)){
setGPIO(1,1);
}
}
}
EXTERN_C gboolean sa_Sensor_mark_start(sa_Sensor_mark* self, GError** error)
{
if (!sa_Sensor_mark_is_active(self)) {
//logt("START MARK");
if (!log_db_log_mark(self->log, "start", error)) // begin mark
return FALSE;
if (!setTimer(self, error))
return FALSE;
}
return TRUE;
}
// ----------------------------------------------------------------------
void
EventInputQueue::push_KeyboardSpecialEventCallback(OSObject* target,
unsigned int eventType,
unsigned int flags,
unsigned int key,
unsigned int flavor,
UInt64 guid,
bool repeat,
AbsoluteTime ts,
OSObject* sender,
void* refcon)
{
IOLockWrapper::ScopedLock lk_eventlock(CommonData::getEventLock());
if (! lk_eventlock) return;
IOLockWrapper::ScopedLock lk(timer_.getlock());
if (! lk) return;
// ------------------------------------------------------------
Params_KeyboardSpecialEventCallback::auto_ptr ptr(Params_KeyboardSpecialEventCallback::alloc(EventType(eventType), Flags(flags), ConsumerKeyCode(key),
flavor, guid, repeat));
if (! ptr) return;
Params_KeyboardSpecialEventCallback& params = *ptr;
// ------------------------------------------------------------
DeviceVendor deviceVendor(0);
DeviceProduct deviceProduct(0);
{
IOLockWrapper::ScopedLock lk_device(ListHookedKeyboard::instance().getListLock());
if (! lk_device) return;
IOHIKeyboard* device = OSDynamicCast(IOHIKeyboard, sender);
if (! device) return;
ListHookedConsumer::Item* item = static_cast<ListHookedConsumer::Item*>(ListHookedConsumer::instance().get_nolock(device));
// ------------------------------------------------------------
CommonData::setcurrent_ts(ts);
deviceVendor = item->getVendor();
deviceProduct = item->getProduct();
}
// ------------------------------------------------------------
// Because we handle the key repeat ourself, drop the key repeat by hardware.
if (repeat) return;
// ------------------------------------------------------------
bool retainFlagStatusTemporaryCount = false;
bool updateWorkspaceData = params.ex_iskeydown;
enqueue_(params, retainFlagStatusTemporaryCount, updateWorkspaceData, deviceVendor, deviceProduct);
setTimer();
}
// ----------------------------------------------------------------------
void EventInputQueue::push_KeyboardSpecialEventCallback(OSObject* target,
unsigned int eventType,
unsigned int flags,
unsigned int key,
unsigned int flavor,
UInt64 guid,
bool repeat,
AbsoluteTime ts,
OSObject* sender,
void* refcon) {
GlobalLock::ScopedLock lk;
if (!lk) return;
Params_KeyboardSpecialEventCallback::log(true, EventType(eventType), Flags(flags), ConsumerKeyCode(key), flavor, guid, repeat);
// ------------------------------------------------------------
Params_KeyboardSpecialEventCallback params(EventType(eventType),
Flags(flags),
ConsumerKeyCode(key),
flavor, guid, repeat);
// ------------------------------------------------------------
IOHIKeyboard* device = OSDynamicCast(IOHIKeyboard, sender);
if (!device) return;
ListHookedConsumer::Item* item = static_cast<ListHookedConsumer::Item*>(ListHookedConsumer::instance().get(device));
if (!item) return;
// ------------------------------------------------------------
// Device Hacks
// Drop events if "Disable an internal keyboard while external keyboards are connected" is enabled.
if (Config::get_essential_config(BRIDGE_ESSENTIAL_CONFIG_INDEX_general_disable_internal_keyboard_if_external_keyboard_exsits)) {
if (item->isInternalDevice() &&
ListHookedKeyboard::instance().isExternalDevicesConnected()) {
return;
}
}
// ------------------------------------------------------------
CommonData::setcurrent_ts(ts);
// ------------------------------------------------------------
// Because we handle the key repeat ourself, drop the key repeat by hardware.
if (repeat) return;
// ------------------------------------------------------------
bool retainFlagStatusTemporaryCount = false;
enqueue_(params, retainFlagStatusTemporaryCount, item->getDeviceIdentifier());
setTimer();
}
int broadcast_fc8300_drv_if_set_channel(struct broadcast_dmb_set_ch_info *udata)
{
signed long frequency = 214714; /*tmm*/
int ret;
#ifndef BBM_I2C_TSIF
fci_irq_disable();
#endif
setTimer();
if(OnAir == 0 || udata == NULL) {
print_log(NULL, "[1seg] broadcast_drv_if_set_channel error [!OnAir]\n");
return ERROR;
}
/* uhf 1segment */
currentSelectedChannel = udata->channel;
if(udata->segment == 13) {
currentBroadCast = UHF_13SEG;
} else {
currentBroadCast = UHF_1SEG;
}
#ifdef CONFIG_LGE_BROADCAST_BRAZIL_FREQ
if(udata->channel<14 || udata->channel>69) {
print_log(NULL, "[1seg] channel information error\n");
return ERROR;
}
frequency = frequencyTable[udata->channel-14];
#else
if(udata->channel<13 || udata->channel>62) {
print_log(NULL, "[1seg] channel information error\n");
return ERROR;
}
frequency = frequencyTable[udata->channel-13];
#endif
/* Scan mode(udata->mode==1) & need lock check */
#ifndef BBM_I2C_TSIF
fci_irq_enable();
#endif
ret = tunerbb_drv_fc8300_set_channel(frequency, udata->mode, udata->subchannel);
//broadcast_fci_ringbuffer_flush();
if(ret)
return ERROR;
print_log(NULL, "[fc8300] channel channel : %d, %d, %d, scan OK\n", udata->channel, udata->mode, udata->subchannel);
return OK;
}
static int renewIP()
{
setTimer(0); /* 取消定时器 */
printf(_(">> 正在获取IP...\n"));
system(dhcpScript);
printf(_(">> 操作结束。\n"));
dhcpMode += 3; /* 标记为已获取，123变为456，5不需再认证*/
if (fillHeader() == -1)
exit(EXIT_FAILURE);
if (dhcpMode == 5)
return switchState(ID_ECHO);
return switchState(ID_START);
}
Clock::Clock(QWidget* parent)
: QWidget(parent), m_timer(0) {
setTimer(Tanglet);
setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
m_update = new QTimer(this);
m_update->setInterval(1000);
connect(m_update, SIGNAL(timeout()), this, SLOT(updateTime()));
QFont f = font();
f.setBold(true);
setFont(f);
}
void LatencyTest::BeginTest()
{
if (State == State_WaitingForButton)
{
// Set color to black and wait a while.
RenderColor = CALIBRATE_BLACK;
State = State_WaitingForSettlePreCalibrationColorBlack;
OVR_DEBUG_LOG(("State_WaitingForButton -> State_WaitingForSettlePreCalibrationColorBlack."));
setTimer(TIME_TO_WAIT_FOR_SETTLE_PRE_CALIBRATION);
}
}
void setKeyListener(char key, ObjectHeader* obj, char cmd) {
static char initialized;
if(!initialized) {
initialized = 1;
setTimer(&keysObj, _MSG_KEYBOARD_TIMER, TIMER_PERIODIC, _MSG_KEYBOARD_TIMER_PERIOD);
}
if(key >= MAX_KEYS)
return;
keys[key].obj = obj;
keys[key].cmd = cmd;
}
int spi_sync()
{
uint32_t timer;
setTimer(&timer);
while(1)
{
if(spi_checkIdle())
return 1;
if (getTimer(timer)>500000) // timeout .5 seconds
return 0;
}
}
void EventInputQueue::push_ScrollWheelEventCallback(OSObject* target,
short deltaAxis1,
short deltaAxis2,
short deltaAxis3,
IOFixed fixedDelta1,
IOFixed fixedDelta2,
IOFixed fixedDelta3,
SInt32 pointDelta1,
SInt32 pointDelta2,
SInt32 pointDelta3,
SInt32 options,
AbsoluteTime ts,
OSObject* sender,
void* refcon) {
GlobalLock::ScopedLock lk;
if (!lk) return;
Params_ScrollWheelEventCallback::log(true,
deltaAxis1,
deltaAxis2,
deltaAxis3,
fixedDelta1,
fixedDelta2,
fixedDelta3,
pointDelta1,
pointDelta2,
pointDelta3,
options);
// ------------------------------------------------------------
Params_ScrollWheelEventCallback params(deltaAxis1, deltaAxis2, deltaAxis3,
fixedDelta1, fixedDelta2, fixedDelta3,
pointDelta1, pointDelta2, pointDelta3,
options);
// ------------------------------------------------------------
IOHIPointing* device = OSDynamicCast(IOHIPointing, sender);
if (!device) return;
ListHookedPointing::Item* item = static_cast<ListHookedPointing::Item*>(ListHookedPointing::instance().get(device));
if (!item) return;
// ------------------------------------------------------------
CommonData::setcurrent_ts(ts);
// ------------------------------------------------------------
bool retainFlagStatusTemporaryCount = Config::get_essential_config(BRIDGE_ESSENTIAL_CONFIG_INDEX_general_lazy_modifiers_with_mouse_event);
enqueue_(params, retainFlagStatusTemporaryCount, item->getDeviceIdentifier());
setTimer();
}
/* ****************************************************************************
*
* utInit - unit test init
*
*/
void utInit(void)
{
#ifdef UT_DEBUG
++noOfInits;
printf("**************** IN utInit (%d inits, %d exits)\n", noOfInits, noOfExits);
#endif
notifierMock = new NotifierMock();
if (notifierMock == NULL)
{
fprintf(stderr, "error allocating NotifierMock: %s\n", strerror(errno));
exit(1);
}
setNotifier(notifierMock);
timerMock = new TimerMock();
if (timerMock == NULL)
{
fprintf(stderr, "error allocating TimerMock: %s\n", strerror(errno));
exit(1);
}
ON_CALL(*timerMock, getCurrentTime()).WillByDefault(Return(1360232700));
setTimer(timerMock);
startTime = getCurrentTime();
statisticsTime = getCurrentTime();
setupDatabase();
#ifdef UT_DEBUG
printf("**************** FROM utInit (%d inits, %d exits)\n", noOfInits, noOfExits);
#endif
//
// URI parameters used for unit testing
// Default mime type for notifications: application/xml
//
uriParams[URI_PARAM_NOTIFY_FORMAT] = "XML";
uriParams[URI_PARAM_PAGINATION_OFFSET] = DEFAULT_PAGINATION_OFFSET;
uriParams[URI_PARAM_PAGINATION_LIMIT] = DEFAULT_PAGINATION_LIMIT;
uriParams[URI_PARAM_PAGINATION_DETAILS] = DEFAULT_PAGINATION_DETAILS;
uriParams[URI_PARAM_NOT_EXIST] = ""; // FIXME P7: we need this to implement "restriction-based" filters
//
// Resetting servicePathVector
//
servicePathVector.clear();
// Init subs cache (this initialization is overriden in test that use csubs)
mongoSubCacheInit();
}
// ATTACK FUNCTIONS =============================================================================== //
void atkTackle(avatar *agent, int targetX, int targetY)
{
float angle;
float trigX, trigY;
angle = atan((targetY - agent->coordY)/(targetX - agent->coordX)) * (-1);
trigX = cos(angle);
trigY = sin(angle);
if(targetX > agent->coordX){
if(trigX < 0)
trigX *= (-1);
} else if(targetX < agent->coordX){
if(trigX > 0)
trigX *= (-1);
}
if(targetY > agent->coordY){
if(trigY < 0)
trigY *= (-1);
} else if(targetY < agent->coordY){
if(trigY > 0)
trigY *= (-1);
}
agent->acX = 0;
agent->acY = 0;
phAddAc(&agent->acX, TACKLE_SPEED*trigX, 1, agent->weight, 1, TACKLE_SPEED);
phAddAc(&agent->acY, TACKLE_SPEED*trigY, 1, agent->weight, 1, TACKLE_SPEED);
setTimer(&agent->timeFlame.time, agent->delay[ATCK_MELEE]);
setTimer(&agent->cantouch.time, agent->delay[ATCK_MELEE]);
agent->timeElement.time = agent->delay[ATCK_MELEE];
return;
}
void App::setTimer()
{
gtkTimer.expires_from_now(boost::posix_time::milliseconds(1));
gtkTimer.async_wait([&](const boost::system::error_code &ec)
{
if (ec) return;
while (gtkMain.events_pending())
gtkMain.iteration(false);
setTimer();
});
}
Mtorz() {
setBackground(osapal[8]);
setBounds(200, 64, 14 * 8 + 12, 4 * 16 + 28);
setTitle("M t . o r z 0");
label1 = new Label(
" orz\n"
" orz orz\n"
" orz orz orz\n"
"orz orz orz orz");
label1->setBounds(20, 8, 12 * 8, 3 * 16);
label1->setBackground(osapal[8]);
add(label1);
setTimer(500);
}
void my_Timer_Interrupt() {
/*TODO:
* Get current time T
* Move everything with waketime before T from TimerQueue to ReadyQueue
* Get next item in TimerQueue
* Reset Timer
*/
PrintState();
ReadyQueue_Lock("Timer Interrupt");
TimerQueue_Lock("Timer Interrupt");
currentTimer = 0;
INT32 time = 0;
time = my_GET_TIME_OF_DAY();
debug(GREY, "Timer Queue, Current Time: %d", time);
debug(YELLOW, "Timer Queue Lock in interrupt");
if (!TimerQueueHead->Next) {
debug(RED, "Bug in Timer Queue\n");
} else {
INT32 currentTime = my_GET_TIME_OF_DAY();
if (TimerQueueHead->Next != NULL) {
debug(GREY, "Timer Queue Item: %d, waketime %d",
TimerQueueHead->Next->PCB->PID,
TimerQueueHead->Next->WakeTime);
} else {
debug(RED, "Timer Item is NULL");
}
while (TimerQueueHead->Next != NULL
&& TimerQueueHead->Next->WakeTime < currentTime) {
//move it to the ready Q
TimerQueueItem * temp = TimerQueue_Pop();
debug(GREEN, "Move PID %d from Timer Q to Ready Q", temp->PCB->PID);
if (temp != NULL) {
ReadyQueue_Add(temp->PCB);
Printer("Ready", temp->PCB->PID, FALSE);
}
}
}
if (TimerQueueHead->Next != NULL) {
//reset Timer
currentTimer = TimerQueueHead->Next->WakeTime;
setTimer(TimerQueueHead->Next->WakeTime - time);
debug(YELLOW, "reset timer to %d", currentTimer,
TimerQueueHead->Next->WakeTime - time);
}
TimerQueue_Unlock("Timer Interrupt");
ReadyQueue_Unlock("Timer Interrupt");
}
void vitalDemage(circle *vital, avatar *enemy)
{
float distance;
distance = sqrt(pow((vital->coordX - enemy->coordX),2) + pow((vital->coordY - enemy->coordY),2));
if((distance < vital->radius + enemy->radius)&&(vital->timeDemage.flag))
{
vital->life-=10;
if(vital->life <= 0)
vital->life = 0;
setTimer(&vital->timeDemage.time, 100);
}
}
void GridFrame::update() {
float tmp = (float)15/19;
currentTetrimono->fall(25);
repaint();
if(!hasLost)
setTimer(1000*tmp/(currentGame->getLevel() + tmp));
else
setTimer(75);
if (currentTetrimono->isOnFloor()) {
if (currentTetrimono->getUpperBound() <= 0) {
hasLost = true;
return;
}
currentGame->scoreManage();
delete currentTetrimono; // on désaloue la mémoire du tétrimono sur le sol
currentTetrimono = new Tetrimono(nextTetrimonoNumber, grid);
int i = rand() % 7;
nextTetrimonoNumber = i;
emit updateNextBlock(i);
}
QWidget::update();
}
uint8_t eeprom_write_byte(uint8_t *index, uint8_t val) {
if (((uint32_t)index) >= sizeof(flash_backing))
return 1;
if (flash_state == STATE_EMPTY)
memcpy(flash_backing, (const void *)&flash_area, sizeof(flash_backing));
flash_backing[(uint32_t)index] = val;
flash_state = STATE_DIRTY;
setTimer(&my_timer, MS2ST(30), eeprom_flush, NULL);
return 0;
}
void CSrvMsgHandler::onLoad(const char* srvName, const unsigned int srvId, unsigned short moduleId)
{
if (!GatewayProxyConfig::config::getConfigValue(CCfg::getValue("GatewayProxyService", "BusinessXmlConfigFile")).isSetConfigValueSuccess())
{
ReleaseErrorLog("set business xml config value error");
stopService();
return;
}
const DBConfig::config& dbCfg = DBConfig::config::getConfigValue(CCfg::getValue("GatewayProxyService", "DbConfigFile"));
if (!dbCfg.isSetConfigValueSuccess())
{
ReleaseErrorLog("set db xml config value error");
stopService();
return;
}
if (!m_redisDbOpt.connectSvr(dbCfg.redis_db_cfg.center_db_ip.c_str(), dbCfg.redis_db_cfg.center_db_port,
dbCfg.redis_db_cfg.center_db_timeout * MillisecondUnit))
{
ReleaseErrorLog("gateway connect center redis service failed, ip = %s, port = %u, time out = %u",
dbCfg.redis_db_cfg.center_db_ip.c_str(), dbCfg.redis_db_cfg.center_db_port, dbCfg.redis_db_cfg.center_db_timeout);
stopService();
return;
}
static const unsigned int gatewayProxySrvId = getSrvId();
m_gatewayProxySrvData.ip = CSocket::toIPInt(CCfg::getValue("NetConnect", "NetIP")); // 外网IP
m_gatewayProxySrvData.port = atoi(CCfg::getValue("NetConnect", "Port"));
m_gatewayProxySrvData.curTimeSecs = time(NULL);
m_gatewayProxySrvData.currentPersons = 0;
int rc = m_redisDbOpt.setHField(GatewayProxyListKey, GatewayProxyListKeyLen,
(const char*)&gatewayProxySrvId, sizeof(gatewayProxySrvId), (const char*)&m_gatewayProxySrvData, sizeof(m_gatewayProxySrvData));
if (rc != 0)
{
ReleaseErrorLog("set gateway proxy service data to redis center service failed, rc = %d", rc);
stopService();
return;
}
m_gameHallId = GatewayProxyConfig::config::getConfigValue().commonCfg.game_hall_id;
// 定时保存数据到redis
unsigned int millisecondUnit = 1000; // 秒转换为毫秒乘值
unsigned int timerId = setTimer(millisecondUnit * atoi(CCfg::getValue("GatewayProxyService", "SaveDataToDBInterval")),
(TimerHandler)&CSrvMsgHandler::saveDataToDb, 0, NULL, (unsigned int)-1);
ReleaseInfoLog("gateway message handler load, service name = %s, id = %d, timer id = %u", srvName, srvId, timerId);
}
DeferredWorkItem* DeferredWorkItemQueue::dequeue(void)
{
// Returns the first item in the queue if it the work item time is >= the current time.
EsifMutexHelper esifMutexHelper(&m_mutex);
esifMutexHelper.lock();
DeferredWorkItem* firstReadyWorkItem = getFirstReadyWorkItemFromQueue();
setTimer();
esifMutexHelper.unlock();
return firstReadyWorkItem;
}
/* ****************************************************************************
*
* getCurrentTime -
*/
TEST(commonGlobals, getCurrentTime)
{
int now;
// 1. No timer
setTimer(NULL);
now = getCurrentTime();
EXPECT_EQ(-1, now);
utInit(); // timer is set up inside utInit
now = getCurrentTime();
EXPECT_TRUE(now != -1);
utExit();
}
static int sendChallengePacket()
{
int nameLen = strlen(userName);
if (startMode%3 == 2) /* 赛尔 */
{
if (sendCount == 0)
{
printf(_(">> 发送密码...\n"));
*(u_int16_t *)(sendPacket+0x0E) = htons(0x0100);
*(u_int16_t *)(sendPacket+0x10) = *(u_int16_t *)(sendPacket+0x14) = htons(nameLen+22);
sendPacket[0x12] = 0x02;
sendPacket[0x13] = capBuf[0x13];
sendPacket[0x16] = 0x04;
sendPacket[0x17] = 16;
memcpy(sendPacket+0x18, checkPass(capBuf[0x13], capBuf+0x18, capBuf[0x17]), 16);
memcpy(sendPacket+0x28, userName, nameLen);
setTimer(timeout);
}
return pcap_sendpacket(hPcap, sendPacket, nameLen+40);
}
if (sendCount == 0)
{
printf(_(">> 发送密码...\n"));
fillMd5Packet(capBuf+0x18);
fillEtherAddr(0x888E0100);
*(u_int16_t *)(sendPacket+0x14) = *(u_int16_t *)(sendPacket+0x10) = htons(nameLen+22);
sendPacket[0x12] = 0x02;
sendPacket[0x13] = capBuf[0x13];
sendPacket[0x16] = 0x04;
sendPacket[0x17] = 16;
memcpy(sendPacket+0x18, checkPass(capBuf[0x13], capBuf+0x18, capBuf[0x17]), 16);
memcpy(sendPacket+0x28, userName, nameLen);
memcpy(sendPacket+0x28+nameLen, fillBuf, fillSize);
setTimer(timeout);
}
return pcap_sendpacket(hPcap, sendPacket, 0x3E8);
}
static int sendIdentityPacket()
{
int nameLen = strlen(userName);
if (startMode%3 == 2) /* 赛尔 */
{
if (sendCount == 0)
{
printf(_(">> 发送用户名...\n"));
*(u_int16_t *)(sendPacket+0x0E) = htons(0x0100);
*(u_int16_t *)(sendPacket+0x10) = *(u_int16_t *)(sendPacket+0x14) = htons(nameLen+30);
sendPacket[0x12] = 0x02;
sendPacket[0x16] = 0x01;
sendPacket[0x17] = 0x01;
fillCernetAddr(sendPacket);
memcpy(sendPacket+0x28, "03.02.05", 8);
memcpy(sendPacket+0x30, userName, nameLen);
setTimer(timeout);
}
sendPacket[0x13] = capBuf[0x13];
return pcap_sendpacket(hPcap, sendPacket, nameLen+48);
}
if (sendCount == 0)
{
printf(_(">> 发送用户名...\n"));
fillEtherAddr(0x888E0100);
nameLen = strlen(userName);
*(u_int16_t *)(sendPacket+0x14) = *(u_int16_t *)(sendPacket+0x10) = htons(nameLen+5);
sendPacket[0x12] = 0x02;
sendPacket[0x13] = capBuf[0x13];
sendPacket[0x16] = 0x01;
memcpy(sendPacket+0x17, userName, nameLen);
memcpy(sendPacket+0x17+nameLen, pkt2, sizeof(pkt2));
memcpy(sendPacket + 0xe7 + nameLen, computeV4(pad, 16), 0x80);
setTimer(timeout);
}
return pcap_sendpacket(hPcap, sendPacket, 545);
}
void rayCrossed_isr()
{
if(INPUT(PIN_B2)&& rayTwo!=1)
{
rayTwo = 1;
if(rayOne == 1)
{
if(checkTimer() == 1)
{
noOfPeople++ ;
number_changed = 1;
}
rayOne = 0;
rayTwo = 0;
}
setTimer();
}
else if(INPUT(PIN_B1)&& rayOne!=1)
{
rayOne = 1;
if(rayTwo == 1)
{
if(checkTimer() == 1)
{
noOfPeople-- ;
number_changed = 1;
}
rayOne = 0;
rayTwo = 0;
}
setTimer();
}
delay_ms(MIN_DELAY_BETWEEN_TWO_INTERRUPTS/2);
//OUTPUT_HIGH(PIN_B7);
delay_ms(MIN_DELAY_BETWEEN_TWO_INTERRUPTS/2);
//OUTPUT_LOW(PIN_B7);
}
// ======================================================================
void
EventInputQueue::fire_timer_callback(OSObject* /*notuse_owner*/, IOTimerEventSource* /*notuse_sender*/)
{
if (! queue_) return;
// IOLOG_DEVEL("EventInputQueue::fire queue_->size = %d\n", static_cast<int>(queue_->size()));
// ------------------------------------------------------------
// handle SimultaneousKeyPresses
do {
Item* front = static_cast<Item*>(queue_->front());
if (! front) return;
// ------------------------------------------------------------
// clear temporary_count_
//
// Don't call FlagStatus::set(key, flags) here.
// If SimultaneousKeyPresses is enabled, keys may be dropped.
// For example, Shift_L+Shift_R to Space is enabled, Shift_L and Shift_R may be dropped.
// If we call FlagStatus::set(key, flags) here, dropped keys are kept as pushed status.
// So, call FlagStatus::set(key, flags) after EventInputQueue.
// ------------------------------------------------------------
if (! front->retainFlagStatusTemporaryCount) {
FlagStatus::globalFlagStatus().set();
}
CommonData::setcurrent_deviceIdentifier(front->deviceIdentifier);
{
Params_KeyboardEventCallBack* params = (front->params).get_Params_KeyboardEventCallBack();
if (params) {
CommonData::setcurrent_keyboardType(params->keyboardType);
}
}
} while (RemapClassManager::remap_simultaneouskeypresses());
// ------------------------------------------------------------
// handle BlockUntilKeyUp
//
// Note:
// We need to handle BlockUntilKeyUp after SimultaneousKeyPresses
// in order to avoid unintended modification by SimultaneousKeyPresses.
bool needToFire = BlockUntilKeyUpHander::doBlockUntilKeyUp();
if (needToFire) {
doFire();
}
setTimer();
}
void rayCrossed_isr()
{
// if(INPUT(PIN_B2)&& rayTwo!=1)
if(INPUT(PIN_B2))
{
rayTwo = 1;
if(rayOne == 1)
{
if(checkTimer() == 1)
{
noOfPeople++ ;
number_changed = 1;
}
rayOne = 0;
rayTwo = 0;
}
setTimer();
}
// else if(INPUT(PIN_B1)&& rayOne!=1)
else if(INPUT(PIN_B1))
{
rayOne = 1;
if(rayTwo == 1)
{
if(checkTimer() == 1)
{
noOfPeople-- ;
number_changed = 1;
}
rayOne = 0;
rayTwo = 0;
}
setTimer();
}
delay_ms(MIN_DELAY_BETWEEN_TWO_INTERRUPTS);
}
void PathGroup::renderCurve(const Color& c) {
Renderer* g = ARK2D::getRenderer();
float ptimer = getTimer();
g->setDrawColor(c);
setTimer(0.0f);
updateCurrent();
float px = getLocation()->getX(); //paths.at(0)->subpaths.at(0)->points.at(0)->getX();
float py = getLocation()->getY();//paths.at(0)->subpaths.at(0)->points.at(0)->getY();
float du = getDuration();
for(float i = 0.05f; i <= du; i += 0.05f)
{
setTimer(i);
updateCurrent();
Vector2<float>* f = getLocation();
g->drawLine(int(px), int(py), int(f->getX()), int(f->getY()));
px = f->getX();
py = f->getY();
}
setTimer(ptimer);
updateCurrent();
}
bool SampleSocketPort::CloseSocket(void)
{
if(m_bOpen && m_bDoDisconnect)
{ //This is where the disconnection really occurs
m_bOpen = false; //If m_bDoDisconnect == true we know this has been called
OnConnectionClosed(); //through the timer, so 'delete this' is safe!
delete this;
}
else if(m_bOpen)
{
m_bDoDisconnect = true; //Just set the timer and the flag so we can
setTimer(DISCONNECT_MS); //disconnect safely, in DISCONNECT_MS
}
return(true);
}
