Esempio n. 1
0
void loop () {
    if (Serial.available())
        handleInput(Serial.read());

    if (tempTimer.poll()) {
      sendTempPacket();
      tempTimer.set(TEMP_INTERVAL);
    }

	unsigned long now = millis();
	cli();
	bool needSendPulse = false;
    if (pulseActivity && (lastPulsePacket + PULSE_INTERVAL < now)) {
    	pulseActivity = false;
    	lastPulsePacket = now;
    	needSendPulse = true;
    }
	sei();
    if (needSendPulse) {
    	sendPulsePacket();
    }

    if (!rf12_recvDone() || rf12_crc != 0)
        return; // nothing to do

    digitalWrite(PIN_LED, HIGH);

    forwardPacket();

    digitalWrite(PIN_LED, LOW);
}
Esempio n. 2
0
// Wait a few milliseconds for proper ACK
byte waitForAck(byte myNodeID) {
   MilliTimer ackTimer;
   while (!ackTimer.poll(ACK_TIME)) {
     if (rf12_recvDone() && rf12_crc == 0 &&
        rf12_hdr == (RF12_HDR_DST | RF12_HDR_CTL | myNodeID))
        return 1;
     }
   return 0;
}
Esempio n. 3
0
		int TalkServiceI::getUserOnlineStatV1(const long userId, const Ice::Current& current){
			MilliTimer tStart;			

			LOG_DEBUG("TalkServiceI::getUserOnlineStat => userId = " << userId);
			int stat = MY_INSTANCE(TalkServer).getUserOnlineStat(userId);

			LOG_TIME("TalkServiceI::getUserOnlineStat|" << tStart.elapsed() );				
			return stat;
		}
Esempio n. 4
0
		vector<int> TalkServiceI::getUsersOnlineStatSeq(const vector<long>& users, const Ice::Current& current){

			MilliTimer tStart;			

			LOG_DEBUG("TalkServiceI::getUsersOnlineStatSeq => size = " << users.size());

			vector<int> intVec = MY_INSTANCE(TalkServer).getLocalUsersOnlineStatSeq(users);

			LOG_TIME("TalkServiceI::getUsersOnlineStatSeq|" << users.size() << "|" << tStart.elapsed() );				
			return intVec;
		}
Esempio n. 5
0
void forwardPacket() {
    // make copies, because rf12_* will change in next rf12_recvDone
    byte hdr = rf12_hdr, len = rf12_len;
    if (config.multi_node) {
        // special case: insert original header (src node ID) as first data byte
        // careful with max-length packets in multi-node mode: drop last byte!
        // this is necessary because we're inserting an extra byte at the front
        if (len >= sizeof buf)
            --len;
        buf[0]= hdr;
    }
    memcpy(buf + config.multi_node, (void*) rf12_data, len);

    // save these for later as well, same reason as above
    byte wantsAck = RF12_WANTS_ACK, ackReply = RF12_ACK_REPLY;
    if (config.acks_enable) {
        // if we're not supposed to send back ACKs, then don't ask for 'em
        wantsAck = false;
        hdr &= ~ RF12_HDR_ACK;
    }

    Serial.print("\n[*]");

    // switch to outgoing group
    rf12_initialize(config.out_node, code2type(config.freq), config.out_group);

    // send our packet, once possible
    while (!rf12_canSend())
        rf12_recvDone();
    rf12_sendStart(hdr, buf, len + config.multi_node, 1);

    if (wantsAck) {
        ackTimer.set(100); // wait up to 100 ms for a valid ack packet
        wantsAck = false;
        while (!wantsAck && !ackTimer.poll())
            wantsAck = rf12_recvDone() && rf12_crc == 0;
    }

    // switch back to incoming group
    rf12_initialize(config.in_node, code2type(config.freq), config.in_group);

    if (wantsAck) {
        // copy ack packet to our temp buffer, same reason as above
        len = rf12_len;
        memcpy(buf, (void*) rf12_data, rf12_len);

        // send ACK packet back, once possible
        while (!rf12_canSend())
            rf12_recvDone();
        rf12_sendStart(ackReply, buf, len, 1);
    }
}
Esempio n. 6
0
		void  Router2TalkServiceI::forwardIq(const std::string& xmppString, const Ice::Current& current)
		{

			MilliTimer  tStart;
			LOG_DEBUG("Router2TalkServiceI::forwordIq ==> begin.");
			int flag = router2talkServerPtr_->forwardIq(xmppString);
			if(flag < 0)
			{
				LOG_ERROR("Router2TalkServiceI::forwardIq ==> return error: "<<flag);
			}


			LOG_DEBUG("Route2TalkServiceI::forwordIq ==> end. use:"<<tStart.elapsed());
		}
Esempio n. 7
0
		map<long, int> TalkServiceI::getUsersOnlineStatMapV1(const vector<long>& users, const Ice::Current& current){

			LOG_DEBUG("TalkServiceI::getUsersOnlineStatMap => size = " << users.size());
			MilliTimer tStart;			

			vector<int> statVector = MY_INSTANCE(TalkServer).getLocalUsersOnlineStatSeq(users);

			map<long, int> statMap;
			for(size_t i = 0; i < statVector.size(); ++i){
				statMap[users[i]] = statVector[i];
			}

			LOG_TIME("TalkServiceI::getUsersOnlineStatMap|" << users.size() << "|" << tStart.elapsed() );				
			return statMap;
		}
Esempio n. 8
0
	void EndpointServiceProxy::deliverMsg(const long connectionId, const string& msg, long mid, int msgType){
		MilliTimer tStart;
		ReadLock lock(mutex_);
		EndpointServicePrx proxy = getProxy(connectionId);

		if(!proxy){
			LOG_ERROR("EndpointServiceProxy::deliverMsg => get proxy failure : cid = " << connectionId);
			return;
		}

		try{
			proxy->deliverMsg(connectionId, msg);
		}catch(std::exception& e){
			std::cout<<"EndpointServicePrx deliverMsg catch exception ="<<e.what()<<std::endl;
		}catch(...){
			std::cout<<"EndpointServicePrx deliverMsg unknow exception"<<std::endl;
		}
		LOG_TIME("EndpointServicePrx::deliverMsg|" << tStart.elapsed() );
		return;
	}
Esempio n. 9
0
void setup () {
    Serial.begin(57600);
    Serial.print("\n[groupRelay]");
    loadConfig();
    tempTimer.set(TEMP_INTERVAL);
    pinMode(PIN_LED, OUTPUT);
    attachInterrupt(1, pulse, CHANGE);
//    pinMode(PIN_TEMP1, INPUT);
//    pinMode(PIN_TEMP2, INPUT);
//    digitalWrite(PIN_TEMP1, LOW); // disable pullup
//    digitalWrite(PIN_TEMP2, LOW); // disable pullup
}
Esempio n. 10
0
void loop() {
  for (int i = 0; i < NUM_COUNTERS; i++) { // loop through the counters
    // read the counter input pin:
    counterState[i] = digitalRead(counterPin[i]);

    // compare the counterState to its previous state
    if (counterState[i] != lastCounterState[i]) {
      if (counterState[i] == LOW) {
        digitalWrite(LED1, HIGH);
        // if the current state is HIGH then the button
        // wend from off to on:
#ifdef DEBUG_ENABLED
        Serial.print(i);
        Serial.println(" LOW");
#endif

				payload.active_counter = i;
				counterMillis[i] = millis();
				payload.counter_millis = counterMillis[i];
 
        if (counterMillis[i] - lastCounterMillis[i] > 90) {
				// send a packet
				while (!rf12_canSend()) 
					rf12_recvDone();

				// send as broadcast, payload will be encrypted
				rf12_sendStart(0, &payload, sizeof(payload));
				rf12_sendWait(1);
        }
        lastCounterMillis[i] = counterMillis[i];
#ifdef DEBUG_ENABLED
      } else {
        // transision from LOW to HIGH means the pulse is over
        // we're not interested in that
        Serial.print(i);
        Serial.println(" HIGH"); 
#endif
      }
      Serial.println();
    }
    // save the current state as the last state, 
    //for next time through the loop
    lastCounterState[i] = counterState[i];

    if (led1Timer.poll(90)) {
      digitalWrite(LED1, LOW);
    }
  }
  wdt_reset();
  
}