bool gatewayTransportInit() {
_w5100_spi_en(true);
#if defined(MY_GATEWAY_ESP8266)
#if defined(MY_ESP8266_SSID)
// Turn off access point
WiFi.mode (WIFI_STA);
#if defined(MY_ESP8266_HOSTNAME)
WiFi.hostname(MY_ESP8266_HOSTNAME);
#endif
(void)WiFi.begin(MY_ESP8266_SSID, MY_ESP8266_PASSWORD);
#ifdef MY_IP_ADDRESS
WiFi.config(_ethernetGatewayIP, _gatewayIp, _subnetIp);
#endif
while (WiFi.status() != WL_CONNECTED)
{
delay(500);
MY_SERIALDEVICE.print(".");
yield();
}
MY_SERIALDEVICE.print(F("IP: "));
MY_SERIALDEVICE.println(WiFi.localIP());
#endif
#else
#ifdef MY_IP_ADDRESS
Ethernet.begin(_ethernetGatewayMAC, _ethernetGatewayIP);
#else
// Get IP address from DHCP
if (!Ethernet.begin(_ethernetGatewayMAC)) {
MY_SERIALDEVICE.print("DHCP FAILURE...");
_w5100_spi_en(false);
return false;
}
#endif
MY_SERIALDEVICE.print(F("IP: "));
MY_SERIALDEVICE.println(Ethernet.localIP());
// give the Ethernet interface a second to initialize
delay(1000);
#endif
#ifdef MY_USE_UDP
_ethernetServer.begin(_ethernetGatewayPort);
#else
// we have to use pointers due to the constructor of EthernetServer
_ethernetServer.begin();
#endif /* USE_UDP */
_w5100_spi_en(false);
return true;
}
SNMP_API_STAT_CODES SNMPClass::begin(const char *getCommName, const char *setCommName, const char *trapCommName, uint16_t port)
{
//initialize request counter
requestCounter = 1;
_extra_data_size = 0;
_udp_extra_data_packet = false;
// set community name set/get sizes
_setSize = strlen(setCommName);
_getSize = strlen(getCommName);
_trapSize = strlen(trapCommName);
//
// validate get/set community name sizes
if ( _setSize > SNMP_MAX_NAME_LEN + 1 || _getSize > SNMP_MAX_NAME_LEN + 1 || _trapSize > SNMP_MAX_NAME_LEN + 1) {
return SNMP_API_STAT_NAME_TOO_BIG;
}
//
// set community names
_getCommName = getCommName;
_setCommName = setCommName;
_trapCommName = trapCommName;
// validate session port number
if ( port == NULL || port == 0 ) port = SNMP_DEFAULT_PORT;
//
// init UDP socket
Udp.stop();
Udp.begin(port);
return SNMP_API_STAT_SUCCESS;
}
void SyncTime_setup()
{
Udp.begin(LOCALPORT);
setSyncProvider(getNtpTime);
while(timeStatus()== timeNotSet)
; // wait until the time is set by the sync provider
}
/*
* Initialize our ntp client.
*
* We need ntp time in order to have a valid, up-to-date time
* in order to create timestamps for the data we collect. If we dont have
* valid time, then there's no use returning since we cant collect data
* without valid time.
*
* Note, however, that now() will still keep track of time - it will just
* be relative to when we booted.
*/
void initNtpTime() {
Udp.begin(8888);
setSyncProvider(0); // We will take care of synching time ourselves,
// so tell time library there's no external time source
sendTimeRequest(); // send an initial time request to kickstart things
// Wait until our request is completed. Note that this is initialization,
// so if we dont have a good time value, we cant collect data because
// we wont be able to create valid timestamps.
int retryCount = 500;
while (ntpState == WAITING_FOR_RESPONSE) {
delay(500);
serviceNtpTime();
if (--retryCount <=0) {
// We've been trying for a while to get the time. Let's try
// restarting in case the network didnt come up right last time.
retryCount = 500;
startEthernet(); // Let's try restarting the ethernet
restartNtpTime();
}
}
if (bootTime == 0) {
bootTime = now();
}
}
void setup_ntp(){
// setup NTP sync service
Udp.begin(ntp_port);
Serial.println(F("Waiting for NTP sync"));
setSyncInterval(600); // initial one 10 minutes to take care of most of the drift
setSyncProvider(getNtpTime);
}
void setup() {
// start the Ethernet and UDP:
Ethernet.begin(mac,ip);
Udp.begin(localPort);
pinMode(13,OUTPUT);
pinMode(12,OUTPUT);
pinMode(11,OUTPUT);
pinMode(10,OUTPUT);
}
void setup()
{
Serial.begin(9600);
// start the Ethernet and UDP:
Ethernet.begin(mac,ip);
Udp.begin(localPort);
Timer1.initialize(TIMER_PERIOD);
Timer1.attachInterrupt(TimerLoop);
Timer1.stop();
}
bool SetupUdpClient ( void )
{
bool success = false;
#ifdef INTERFACE_ETHERNET
#ifdef ETHERNET_UDPCLIENT
success = (bool)Udp.begin(localPort);
#endif //ETHERNET_UDPCLIENT
#endif // INTERFACE_ETHERNET
return success;
}
/*
* Restart our ntp handler. This is only done as part of restarting the
* network. As such, all we want to do is make sure udp is still working.
* We dont need to issue a time request unless one was already outstanding
* (not likely)
*/
void restartNtpTime() {
Udp.stop();
Udp.begin(8888);
// If we were already waiting for a response, let's re-issue the request
if (ntpState == WAITING_FOR_RESPONSE) {
sendTimeRequest();
}
}
void UdpController::Setup()
{
if (Ethernet.begin(MacAddress) == 0)
{
_traffic->ShowError();
for(;;);
}
Udp.begin(Port);
_traffic->ShowInconclusive();
_lastUpdateMillis = millis();
}
void udpService( )
{
static DhcpState prevState = DhcpStateNone;
// poll() queries the DHCP library for its current state (all possible values
// are shown in the switch statement below). This way, you can find out if a
// lease has been obtained or is in the process of being renewed, without
// blocking your sketch. Therefore, you could display an error message or
// something if a lease cannot be obtained within reasonable time.
// Also, poll() will actually run the DHCP module, just like maintain(), so
// you should call either of these two methods at least once within your
// loop() section, or you risk losing your DHCP lease when it expires!
DhcpState state = EthernetDHCP.poll();
if (prevState != state) {
switch (state) {
case DhcpStateDiscovering:
p("DHCP Discover\n");
break;
case DhcpStateRequesting:
Serial.print("DHCP Request\n");
break;
case DhcpStateRenewing:
Serial.print("DHCP Renew\n");
break;
case DhcpStateLeased: {
Serial.println("DHCP Obtained\n");
// Since we're here, it means that we now have a DHCP lease, so we
// print out some information.
const byte* ipAddr = EthernetDHCP.ipAddress();
const byte* gatewayAddr = EthernetDHCP.gatewayIpAddress();
const byte* dnsAddr = EthernetDHCP.dnsIpAddress();
p(" IP address: %s\n", ip_to_str(ipAddr));
p(" Gateway: %s\n", ip_to_str(gatewayAddr));
p(" DNS: %s\n", ip_to_str(dnsAddr));
if ( ! active ) {
p("Starting NTP handler on port %u\n", localPort ) ;
Udp.begin(localPort);
active = true;
}
break;
}
}
prevState = state;
}
}
SNMP_API_STAT_CODES AgentuinoClass::begin() {
// set community names
_getCommName = "public";
_setCommName = "private";
//
// set community name set/get sizes
_setSize = strlen(_setCommName);
_getSize = strlen(_getCommName);
//
// init UDP socket
Udp.begin(SNMP_DEFAULT_PORT);
//
return SNMP_API_STAT_SUCCESS;
}
// Overload RobotOpenClass::begin to accept an IP address (FWA August 2012)
void RobotOpenClass::begin(uint8_t *local_ip) {
// Setup the initial pointers to the arrays
_packetBufferAccessor = _packetBuffer;
_validPacketAccessor = _validPacket;
_pwmSerialData[0] = 0xFF;
_pwmSerialData[1] = 0x00;
_relaySerialData[0] = 0xFF;
_relaySerialData[1] = 0x00;
for (int i = 2; i <= 11; i++) {
_pwmSerialData[i] = 127;
_relaySerialData[i] = 0;
}
// Start Ethernet, UDP, and Serial
Ethernet.begin(mac,local_ip);
Udp.begin(PORT);
Serial.begin(115200); // This is used to talk to the coprocessor on the RobotOpen shield
}
unsigned long getNtpTime()
{
// We need to call the begin to reset the socket.
// Because localClient.connect() may occupy the same socket.
EthernetUDP theUDP;
theUDP.begin(localPort);
Serial.println("Sending time sync request to NTP server.");
sendNTPpacket(timeServer); // send an NTP packet to a time server
unsigned long startMillis = millis();
int tryCounter = 1;
while( millis() - startMillis < 1000) // wait up to one second for the response
{ // wait to see if a reply is available
if ( theUDP.available() )
{
theUDP.readPacket(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;
// now convert NTP time into Arduino Time format:
// Time starts on Jan 1 1970. In seconds, that's 2208988800:
const unsigned long seventyYears = 2208988800UL;
// subtract seventy years:
unsigned long epoch = secsSince1900 - seventyYears;
Serial.println("Time sync successfully.");
return epoch;
}
Serial.print("No date data available. Try counter: .");
Serial.println(tryCounter++);
delay(100);
}
Serial.println("Time sync failed.");
return 0; // return 0 if unable to get the time
}
void setup() {
// Open serial communications and wait for port to open:
Serial.begin(9600);
ADC_init();
timer0_init();
debug_init(PC3);
debug_init(PC4);
// Initialize the buffer with a capacity for 256 bytes
charBuffer.init(256);
// start the Ethernet connection and the server:
Ethernet.begin(mac, serverIP);
Udp.begin(serverPort);
Serial.println("arduino server is at ");
Serial.println(Ethernet.localIP());
}
void hardwareInit()
{
wdt_enable(WDTO_2S);
// enable internal pull-ups
digitalWrite(pinButtonSwitch, HIGH);
digitalWrite(pinReedSwitch, HIGH);
pinMode(pinLed, OUTPUT);
digitalWrite(pinLed, LOW);
uint8_t macTmp[6];
memcpy(macTmp, mac, 6);
Ethernet.begin(macTmp, ip);
udp.begin(10000);
// delaying in order to properly boot the device
// we really need this time (about 7-10 secs)
bootDelay();
}
SNMP_API_STAT_CODES AgentuinoClass::begin(char *getCommName, char *setCommName, uint16_t port) {
// set community name set/get sizes
_setSize = strlen(setCommName);
_getSize = strlen(getCommName);
//
// validate get/set community name sizes
if (_setSize > SNMP_MAX_NAME_LEN + 1 || _getSize > SNMP_MAX_NAME_LEN + 1) {
return SNMP_API_STAT_NAME_TOO_BIG;
}
//
// set community names
_getCommName = getCommName;
_setCommName = setCommName;
//
// validate session port number
if (port == NULL || port == 0) port = SNMP_DEFAULT_PORT;
//
// init UDP socket
Udp.begin(port);
return SNMP_API_STAT_SUCCESS;
}
roveEthernet_Error roveEthernet_UdpSocketListen(uint16_t port)
{
udpReceiver.begin(port);
return ROVE_ETHERNET_ERROR_SUCCESS;
}
void SyslogClass::setLoghost(uint8_t * server_ip) {
ip_syslogserver = server_ip;
SyslogUdp.begin(8888);
}
void commandInterfaceInit() {
cmdsock.begin(62001);
}
void setup(void)
{
status.reset();
/// Discrete & Analog IO
pinMode(13, OUTPUT); // Arduino on-board LED
pinMode(A0, OUTPUT); // Buzzer
/// Comm. Channels
// UART
Serial.begin(115200); Serial.flush();
Serial.println("Starting up greenOmatic Duemilanove Testbed...");
Serial.print("Program compiled on ");
Serial.print(__DATE__);
Serial.print(" at ");
Serial.println(__TIME__);
Serial.println();
// RF
#ifdef INTERFACE_ASK_RX
pinMode(RF_RX_PIN, INPUT);
vw_set_rx_pin(RF_RX_PIN);
vw_setup(RF_BAUD);
vw_rx_start ();
Serial.print ("ASK RF Receiver configured on PIN ");
Serial.print (RF_RX_PIN);
Serial.print (" @ ");
Serial.print (RF_BAUD, DEC);
Serial.println(" baud.");
#endif //INTERFACE_ASK_RX
// Ethernet
#ifdef INTERFACE_ETHERNET
Serial.print("Starting Ethernet... ");
#ifdef ETHERNET_DYNAMIC_IP
int eth_stat = Ethernet.begin(mac);
if (0 == eth_stat)
{
Serial.println(" Problem starting ethernet !");
status.ethernet_valid = status.ERROR;
}
else
{
Serial.print("Ethernet started, IP = ");
Serial.println( Ethernet.localIP() );
status.ethernet_valid = status.VALID;
}
#else
Ethernet.begin(mac, IPaddr);
Serial.print("Ethernet started, IP = ");
Serial.println( Ethernet.localIP() );
status.ethernet_valid = status.VALID;
#endif //ETHERNET_DYNAMIC_IP
#ifdef ETHERNET_WEBSERVER
server.begin();
#endif //ETHERNET_WEBSERVER
#ifdef ETHERNET_UDPCLIENT
Udp.begin(localPort);
#endif //ETHERNET_UDPCLIENT
#endif
/// Peripherals
// I2C RTC
#ifdef PERIPHERAL_RTCC
Wire.begin();
rtc.begin();
if (rtc.isrunning())
{
status.time_valid = status.VALID;
GetDatetimeString(rtc.now());
Serial.print("RTCC configured on I2C. Time is currently ");
Serial.println(currentTime);
#ifdef ETHERNET_UDPCLIENT
//TODO: Get NTP Time
#else
// Compare RTC time to this programs compile time
DateTime rtcTime = rtc.now();
DateTime compileTime(F(__DATE__), F(__TIME__));
// If the compile-time is later (more recent) than the current RTC time, update the RTC
if (compileTime.secondstime() > rtcTime.secondstime())
{
Serial.println("Program compile-time is later than RTC time; updating RTC.");
rtc.adjust( DateTime(F(__DATE__), F(__TIME__)) );
}
#endif //ETHERNET_UDPCLIENT
}
else
{
status.time_valid = status.ERROR;
// TODO, can we narrow this down further like with the DS1307RTC library?
}
#endif
Serial.println("\nInitialization complete!\n\n");
}
// --------------------------------------------------- Initialize UDP ------------------------------------------------------------
void init_UDP()
{
Ethernet.begin(mac, ip);
Udp.begin(localPort);
}