time_t getNtpTime()
{
  while (Udp.parsePacket() > 0) ; // discard any previously received packets
  Serial.println("Transmit NTP Request");
  sendNTPpacket(ntp_server);
  uint32_t beginWait = millis();
  while (millis() - beginWait < 2000) {
    int size = Udp.parsePacket();
    if (size >= NTP_PACKET_SIZE) {
      Serial.println("Receive NTP Response");
      Udp.read(packetBuffer, NTP_PACKET_SIZE);  // read packet into the buffer
      unsigned long secsSince1900;
      unsigned long fracSecs;
      // convert four bytes starting at location 40 to a long integer
      secsSince1900 =  (unsigned long)packetBuffer[40] << 24;
      secsSince1900 |= (unsigned long)packetBuffer[41] << 16;
      secsSince1900 |= (unsigned long)packetBuffer[42] << 8;
      secsSince1900 |= (unsigned long)packetBuffer[43];
      fracSecs =  (unsigned long)packetBuffer[44] << 24;
      fracSecs |= (unsigned long)packetBuffer[45] << 16;
      fracSecs |= (unsigned long)packetBuffer[46] << 8;
      fracSecs |= (unsigned long)packetBuffer[47];
      return ((time_t)(secsSince1900 - 2208988800UL)<<32) + fracSecs;
    }
  }
  Serial.println("No NTP Response :-(");
  return 0; // return 0 if unable to get the time
}
Esempio n. 2
0
/*
 * Perform housekeeping needed to keep ntp time up to date.
 *
 * This essentially involves occasionally re-syncing our
 * time with a time server so our internal clock doesnt
 * drift too far.
 *
 */
void serviceNtpTime() {
  
	switch (ntpState) {
		case NTP_IN_SYNC :   
			// Check to see if we need to re-sync
			if ((ntpLastSyncTime + SYNC_INTERVAL) < now()) {
				sendTimeRequest();
			}
			break;
		case WAITING_FOR_RESPONSE :
			// See if we've received a response to a sync request yet
			if ( Udp.parsePacket() ) {
				ntpLastSyncTime = parseNtpPacket();
				setTime(ntpLastSyncTime);
				ntpState = NTP_IN_SYNC;
				Serial.print("Updated time: ");
				Serial.println(now());
			} else if ((lastNtpRequestTime + MAX_WAIT_INTERVAL) < now()) {
				// We've been waiting a while now and we're probably not going
				// to get a response, so let's try the next server in the list
				Serial.println("No ntp response");
				sendTimeRequest();
			}
			break;
	}
  
}
Esempio n. 3
0
int readUdp( char * buf, int size )
{
  if ( ! active ) return 0 ;
  int count = Udp.parsePacket() ;
  if ( count ) Udp.read( buf, size ) ;
  return count ;
}
Esempio n. 4
0
void AgentuinoClass::listen(void) {
    // if bytes are available in receive buffer
    // and pointer to a function (delegate function)
    // isn't null, trigger the function
    Udp.parsePacket();
    if (Udp.available() && _callback != NULL) (*_callback)();
}
void loop() {
  // if there's data available, read a packet
  int packetSize = Udp.parsePacket();
  char Size[4];
  if(packetSize)
  {
    if(packetSize == 4)
    {
      IPAddress remote = Udp.remoteIP();
    
      // read the packet into packetBufffer
      Udp.read(packetBuffer,UDP_TX_PACKET_MAX_SIZE);
      char Command[4];
      for(int nCom = 0; nCom < 4; nCom++)
        {
        Command[nCom] = packetBuffer[nCom];
        }
            
      if (Command[0] == 't')
      {
        digitalWrite(13, HIGH);
      }
      else if (Command[0] == 'r')
      {
        digitalWrite(12, HIGH);
      }
      else if (Command[0] == 'e')
      {
        digitalWrite(10, HIGH);
      }   
      else if (Command[0] == 'w')
      {
        analogWrite(11, 65);
      }      
      else
      {
        digitalWrite(13, LOW);
        digitalWrite(12, LOW);
        analogWrite(11, 0);
      }

      // send a reply, to the IP address and port that sent us the packet we received
      itoa(packetSize, Size, 10);
      Udp.beginPacket(Udp.remoteIP(), Udp.remotePort());
      Udp.write(ReplyBuffer);
      Udp.write(packetBuffer);
      Udp.write(Size);
      Udp.endPacket();
    delay(1000);
    }
    else
    {
      Udp.beginPacket(Udp.remoteIP(), Udp.remotePort());
      Udp.write("NOPE");
      Udp.endPacket();
    }
  }
}
Esempio n. 6
0
// This function's purpose is to receive data and prepare it for parsing
void RobotOpenClass::handleData() {
	_packetBufferSize = Udp.parsePacket();
    
    // If there's data, read the packet in
    if (_packetBufferSize > 0) {
		_remotePort = Udp.remotePort();
		_remoteIp = Udp.remoteIP();
		Udp.read(_packetBufferAccessor, 256);
		parsePacket();	// Data is all set, time to parse through it
    }
}
Esempio n. 7
0
void udpToUart()
{
  int packetSize = Udp.parsePacket();
  if(packetSize)
  {
    // read the packet into packetBufffer
    Udp.read(udpBuffer,MAX_HDLC_FRAME_SIZE);
    Serial.write(HDLC_SS_BYTE);
    Serial.write(udpBuffer, packetSize);
    Serial.write(0x12);
    Serial.write(0x34);
    Serial.write(HDLC_SS_BYTE);
  }
}
roveEthernet_Error roveEthernet_GetUdpMsg(roveIP* senderIP, void* buffer, size_t bufferSize)
{
  int packetSize = udpReceiver.parsePacket(); 
  
  if (packetSize > 0) //if there is a packet available
  {
    udpReceiver.read((char*)buffer, bufferSize);
    *senderIP = udpReceiver.remoteIP();
    return ROVE_ETHERNET_ERROR_SUCCESS;
  }
  else
  {
    return ROVE_ETHERNET_ERROR_WOULD_BLOCK;
  }
}
void UdpController::Loop()
{
    unsigned long currentMillis = millis();
    int packetSize = Udp.parsePacket();

    if (packetSize && packetSize == 3)
    {
        Udp.read(Buffer, UDP_TX_PACKET_MAX_SIZE);

        if (Buffer[0] == 0x28 && Buffer[1] == 0x06)
        {
            _traffic->SetMode((LightMode)Buffer[2]);
            _lastUpdateMillis = currentMillis;
        }
    }

    if ((currentMillis - _lastUpdateMillis) > UpdateIntervalMillis)
    {
        _traffic->ShowInconclusive();
    }
}
Esempio n. 10
0
boolean SNMPClass::listen(void)
{
  // if bytes are available in receive buffer
  // and pointer to a function (delegate function)
  // isn't null, trigger the function
  
  if(Udp.parsePacket() > 1024){
    _udp_extra_data_packet = true;
  }else{
    _udp_extra_data_packet = false;
  }
  
  if (Udp.available()){
    if(_callback != NULL){
      (*_callback)();
    }else{
      return true;
    }
  }
  
  return false;
}
Esempio n. 11
0
unsigned long getNtpTime()
{
  sendNTPpacket(timeServer); // send an NTP packet to a time server

    // wait to see if a reply is available
  delay(1000);  
  if ( Udp.parsePacket() ) {  
    // We've received a packet, read the data from it
    Udp.read(packetBuffer,NTP_PACKET_SIZE);  // read the packet into the buffer

    //the timestamp starts at byte 40 of the received packet and is four bytes,
    // or two words, long. First, esxtract the two words:

    unsigned long highWord = word(packetBuffer[40], packetBuffer[41]);
    unsigned long lowWord = word(packetBuffer[42], packetBuffer[43]);  
    // combine the four bytes (two words) into a long integer
    // this is NTP time (seconds since Jan 1 1900):
    unsigned long secsSince1900 = highWord << 16 | lowWord;  
    #ifdef LOGGING
    Serial.print("Seconds since Jan 1 1900 = " );
    Serial.println(secsSince1900);               
    #endif

    // now convert NTP time into everyday time:
    // Unix time starts on Jan 1 1970. In seconds, that's 2208988800:
    const unsigned long seventyYears = 2208988800UL;     
    // subtract seventy years:
    unsigned long epoch = secsSince1900 - seventyYears;  
    // print Unix time:
    #ifdef LOGGING
    Serial.print(UNIX_TIME);
    Serial.println(epoch);                               
    #endif
    return epoch;
  }
   
  return 0; // return 0 if unable to get the time
}
void commandInterfaceTick() {
  int packetSize = cmdsock.parsePacket();
  if(cmdsock.available()) {
    
    // read the packet into packetBufffer
    cmdsock.read(udpPacketBuffer, PACKET_SIZE);

    if(memcmp("INGV\0", udpPacketBuffer, 5) != 0) {
      return;
    }

    bool reboot = false;
    unsigned long unixTimeM = getUNIXTime();
    unsigned long uptime = getUNIXTime() - getBootTime();
    byte macaddress[6] = { 0 };
    getMACAddress(macaddress);
    uint32_t probeSpeed = getProbeSpeedStatistic();
    uint32_t freeramkb = freeMemory();
    float latency = 0;
    if(udpPacketBuffer[5] == PKTTYPE_GETINFO) {
      latency = tcpLatency();
    }

    float longitude = 0;
    float latitude = 0;

    switch(udpPacketBuffer[5]) {
      case PKTTYPE_DISCOVERY:
        // Reply to discovery
        udpPacketBuffer[5] = PKTTYPE_DISCOVERY_REPLY;

        memcpy(udpPacketBuffer + 6, macaddress, 6);
        
        memcpy(udpPacketBuffer + 12, getVersionAsString().c_str(), 4);
        memcpy(udpPacketBuffer + 16, "uno", 3);
        break;
      case PKYTYPE_PING:
        // Reply to ping
        udpPacketBuffer[5] = PKYTYPE_PONG;
        break;
      case PKTTYPE_SENDGPS:
        // Get coords
        udpPacketBuffer[5] = PKTTYPE_OK;

        memcpy(&latitude, udpPacketBuffer + 12, 4);
        memcpy(&longitude, udpPacketBuffer + 16, 4);
        reverse4bytes((byte*)&latitude);
        reverse4bytes((byte*)&longitude);
        
        break;
      case PKTTYPE_REBOOT:
        // Reboot
        // Reply with OK
        udpPacketBuffer[5] = PKTTYPE_OK;
        reboot = true;
        break;
      case PKTTYPE_GETINFO:
        udpPacketBuffer[5] = PKTTYPE_GETINFO_REPLY;

        memcpy(udpPacketBuffer + 6, macaddress, 6);
        memcpy(udpPacketBuffer + 28, &uptime, 4);
        memcpy(udpPacketBuffer + 32, &unixTimeM, 4);
        memcpy(udpPacketBuffer + 36, VERSION, 4);
        memcpy(udpPacketBuffer + 40, &freeramkb, 4);
        memcpy(udpPacketBuffer + 44, &latency, 4);
        memcpy(udpPacketBuffer + 53, "uno", 3);
        memcpy(udpPacketBuffer + 57, "MMA7361", 7);
        memcpy(udpPacketBuffer + 65, &probeSpeed, 4);

        break;
#ifdef RESET_ENABLED
      case PKTTYPE_RESET:
        initEEPROM();
        reboot = true;
        break;
#endif
      default:
        // Unknown packet or invalid command
        return;
    }

    if(longitude != 0 && latitude != 0) {
      setLongitude(longitude);
      setLatitude(latitude);
    }

    cmdsock.beginPacket(cmdsock.remoteIP(), cmdsock.remotePort());
    cmdsock.write(udpPacketBuffer, PACKET_SIZE);
    cmdsock.endPacket();
    cmdsock.flush();

    if(reboot) {
      soft_restart();
    }
  }
}
bool gatewayTransportSend(MyMessage &message)
{
	bool ret = true;
	char *_ethernetMsg = protocolFormat(message);

    setIndication(INDICATION_GW_TX);

	_w5100_spi_en(true);
	#if defined(MY_CONTROLLER_IP_ADDRESS)
		#if defined(MY_USE_UDP)
			_ethernetServer.beginPacket(_ethernetControllerIP, MY_PORT);
			_ethernetServer.write(_ethernetMsg, strlen(_ethernetMsg));
			// returns 1 if the packet was sent successfully
			ret = _ethernetServer.endPacket();
		#else
			EthernetClient client;
			#if defined(MY_CONTROLLER_URL_ADDRESS)
	                	if (client.connected() || client.connect(MY_CONTROLLER_URL_ADDRESS, MY_PORT)) {
	        	#else
	                	if (client.connected() || client.connect(_ethernetControllerIP, MY_PORT)) {
	        	#endif
	                	client.write(_ethernetMsg, strlen(_ethernetMsg));
	                }
	                else {
	                	// connecting to the server failed!
	                	ret = false;
	                }
		#endif
	#else
		// Send message to connected clients
		#if defined(MY_GATEWAY_ESP8266)
			for (uint8_t i = 0; i < ARRAY_SIZE(clients); i++)
			{
				if (clients[i] && clients[i].connected())
				{
					clients[i].write((uint8_t*)_ethernetMsg, strlen(_ethernetMsg));
				}
			}
		#else
			_ethernetServer.write(_ethernetMsg);
		#endif
	#endif
	_w5100_spi_en(false);
	return ret;

}


#if defined(MY_GATEWAY_ESP8266)
	bool _readFromClient(uint8_t i) {
		while (clients[i].connected() && clients[i].available()) {
			char inChar = clients[i].read();
			if (inputString[i].idx < MY_GATEWAY_MAX_RECEIVE_LENGTH - 1) {
				// if newline then command is complete
				if (inChar == '\n' || inChar == '\r') {
					// Add string terminator and prepare for the next message
					inputString[i].string[inputString[i].idx] = 0;
					debug(PSTR("Client %d: %s\n"), i, inputString[i].string);
					inputString[i].idx = 0;
					if (protocolParse(_ethernetMsg, inputString[i].string)) {
						return true;
					}

				} else {
					// add it to the inputString:
					inputString[i].string[inputString[i].idx++] = inChar;
				}
			} else {
				// Incoming message too long. Throw away
				debug(PSTR("Client %d: Message too long\n"), i);
				inputString[i].idx = 0;
				// Finished with this client's message. Next loop() we'll see if there's more to read.
				break;
			}
		}
		return false;
	}
#else
	bool _readFromClient() {
		while (client.connected() && client.available()) {
			char inChar = client.read();
			if (inputString.idx < MY_GATEWAY_MAX_RECEIVE_LENGTH - 1) {
				// if newline then command is complete
				if (inChar == '\n' || inChar == '\r') {
					// Add string terminator and prepare for the next message
					inputString.string[inputString.idx] = 0;
					debug(PSTR("Eth: %s\n"), inputString.string);
					inputString.idx = 0;
					if (protocolParse(_ethernetMsg, inputString.string)) {
						return true;
					}

				} else {
					// add it to the inputString:
					inputString.string[inputString.idx++] = inChar;
				}
			} else {
				// Incoming message too long. Throw away
				debug(PSTR("Eth: Message too long\n"));
				inputString.idx = 0;
				// Finished with this client's message. Next loop() we'll see if there's more to read.
				break;
			}
		}
		return false;
	}
#endif


bool gatewayTransportAvailable()
{
	_w5100_spi_en(true);
	#if !defined(MY_IP_ADDRESS) && defined(MY_GATEWAY_W5100)
		// renew IP address using DHCP
		gatewayTransportRenewIP();
	#endif

	#ifdef MY_USE_UDP

		int packet_size = _ethernetServer.parsePacket();

		if (packet_size) {
			//debug(PSTR("UDP packet available. Size:%d\n"), packet_size);
            setIndication(INDICATION_GW_RX);
			#if defined(MY_GATEWAY_ESP8266)
				_ethernetServer.read(inputString[0].string, MY_GATEWAY_MAX_RECEIVE_LENGTH);
				inputString[0].string[packet_size] = 0;
				debug(PSTR("UDP packet received: %s\n"), inputString[0].string);
				return protocolParse(_ethernetMsg, inputString[0].string);
			#else
				_ethernetServer.read(inputString.string, MY_GATEWAY_MAX_RECEIVE_LENGTH);
				inputString.string[packet_size] = 0;
				debug(PSTR("UDP packet received: %s\n"), inputString.string);
				_w5100_spi_en(false);
				return protocolParse(_ethernetMsg, inputString.string);
			#endif
		}
	#else
		#if defined(MY_GATEWAY_ESP8266)
			// ESP8266: Go over list of clients and stop any that are no longer connected.
			// If the server has a new client connection it will be assigned to a free slot.
			bool allSlotsOccupied = true;
			for (uint8_t i = 0; i < ARRAY_SIZE(clients); i++) {
				if (!clients[i].connected()) {
					if (clientsConnected[i]) {
						debug(PSTR("Client %d disconnected\n"), i);
						clients[i].stop();
					}
					//check if there are any new clients
					if (_ethernetServer.hasClient()) {
						clients[i] = _ethernetServer.available();
						inputString[i].idx = 0;
						debug(PSTR("Client %d connected\n"), i);
						gatewayTransportSend(buildGw(_msg, I_GATEWAY_READY).set("Gateway startup complete."));
						if (presentation)
							presentation();
					}
				}
				bool connected = clients[i].connected();
				clientsConnected[i] = connected;
				allSlotsOccupied &= connected;
			}
			if (allSlotsOccupied && _ethernetServer.hasClient()) {
				//no free/disconnected spot so reject
				debug(PSTR("No free slot available\n"));
				EthernetClient c = _ethernetServer.available();
				c.stop();
			}
				// Loop over clients connect and read available data
			for (uint8_t i = 0; i < ARRAY_SIZE(clients); i++) {
				if (_readFromClient(i)) {
                    setIndication(INDICATION_GW_RX);
					_w5100_spi_en(false);
					return true;
				}
			}
		#else
			// W5100/ENC module does not have hasClient-method. We can only serve one client at the time.
			EthernetClient newclient = _ethernetServer.available();
			// if a new client connects make sure to dispose any previous existing sockets
			if (newclient) {
				if (client != newclient) {
					client.stop();
					client = newclient;
					debug(PSTR("Eth: connect\n"));
					_w5100_spi_en(false);
					gatewayTransportSend(buildGw(_msg, I_GATEWAY_READY).set("Gateway startup complete."));
					_w5100_spi_en(true);
					if (presentation)
						presentation();
				}
			}
			if (client) {
				if (!client.connected()) {
					debug(PSTR("Eth: disconnect\n"));
					client.stop();
				} else {
					if (_readFromClient()) {
                        setIndication(INDICATION_GW_RX);
						_w5100_spi_en(false);
						return true;
					}
				}
			}
		#endif
	#endif
	_w5100_spi_en(false);
	return false;
}
Esempio n. 14
0
void loop() {

    if ((unsigned long) (millis() - previousEth) >= interval_ethernet) { //entra a cada 50ms
        previousEth = millis();
        if(count_eth == 0) { //espera completar um ciclo de todas as funções chamadas
            int packetSize = Udp.parsePacket();
            count_eth = 2;
            Serial.println("entrou eth");
            received = 0;
            if (packetSize) {
                set_debug(PC3);

#ifdef debug
                Serial.println("entrou eth RX ");
                Serial.print("Received packet of size ");
                Serial.println(packetSize);
                Serial.print("From ");
                IPAddress remote = Udp.remoteIP();
                for (int i =0; i < 4; i++)
                {
                    Serial.print(remote[i], DEC);
                    if (i < 3)
                    {
                        Serial.print(".");
                    }
                }
                Serial.print(", port ");
                Serial.println(Udp.remotePort());

                Serial.println("Contents:");
                Serial.println(packetBuffer);
#endif
                received = Udp.read();
                charBuffer.put(received);

#ifdef debug
                Serial.println("\rchar recebido:");
                Serial.write(received);
#endif

                /////////////////////////////
                clear_debug(PC3);
            }
        } else {
            count_eth--;
            Serial.println("entrou eth NADA");
            if (charBuffer.getSize() > 5) charBuffer.clear();
            if( charBuffer.getSize() > 0 )
                received = charBuffer.get();
            Serial.println("received:");
            Serial.println(received);

        }
    }
#ifdef debug
    Serial.println("client disconnected");
#endif
    /****************FIM ROTINA ETHERNET ***************************************************/


    if ((unsigned long) (millis() - previousADC) >= interval_adc) { //entra a cada 60ms
        previousADC = millis();
        set_debug(PC4);
        if (count_adc == 0) {
            count_adc = 1;
            /*testa obstaculo IR*/
            Serial.println("entrou adc OBSTACULO ");

            IR_obstaculo = 0;
            IR_obstaculo = verificaObstaculoIR();
#ifdef debug
            Serial.println("distancia_ir");
            Serial.println(IR_obstaculo);
            Serial.println("\r");
#endif
            if (IR_obstaculo > IR_OBSTACLE_THRESHOLD)
                obstacle_flag = 0;
            else if (IR_obstaculo > IR_OBSTACLE_THRESHOLD
                    && IR_obstaculo < IR_OBSTACLE_UPPER_THRESHOLD)
                obstacle_flag = 1;
            else if (IR_obstaculo <= IR_OBSTACLE_THRESHOLD)
                obstacle_flag = 2;
            clear_debug(PC4);
        } else {
            count_adc=0;
            Serial.println("entrou adc NADA ");

        }
    }

    /***************** FIM ROTINA ADC********************************/

    if ((unsigned long) (millis() - previousMotores) >= interval_motores) { //entra a cada 100ms
        previousMotores = millis();

        if (ciclosClock_motor == 2) { //duas bordas de subida depois de acionar o motor (200ms depois de acionar o motor)
            Serial.println("motor stop ");
            stopMove();
            ciclosClock_motor = 0;
        }
        if (count_motor == 0) {
            Serial.println("motor ANDA ");

            if (obstacle_flag == 0 || obstacle_flag == 1) {
                count_motor = 1;
                /*move motores*/
                switch (received) {
                case 'u':
                    goForward(obstacle_flag);
                    break;
                case 'd':
                    goBack(obstacle_flag);
                    break;
                case 'l':
                    goLeft(obstacle_flag);
                    break;
                case 'r':
                    goRight(obstacle_flag);
                    break;
                default:
                    received = 0;
                    stopMove();
                    break;
                }
            } else {
                if (received == 'd') {
                    goBack(WITH_CARE);
                } else {
                    stopMove();
                }
            }
        } else {
            ciclosClock_motor++;
            count_motor = 0;
            Serial.println("ciclosClock_motor++ ");
        }

    }
    // _delay_ms(500);
}