merging a http request and NTP time update

I have two separate projects taken from the Arduino examples one making a http request and stripping the result. The other gets the time through a NTP time update. Both of these work perfectly fine on their own, when I merge them together the project just sits at this line.

Udp.endPacket();

I have absolutely no idea why this is. This part of a larger project I am working on to turn lights on or off at sunrise sunset time offsets.

Thank you for all advice I am more than a little stuck…

#include <SPI.h>
    #include <Ethernet2.h>
    #include <String.h>
    #include <stdlib.h>
    #include <EthernetUdp2.h>
 
    EthernetClient client;

    const char* server =    "api.sunrise-sunset.org";                  // server's address
    const char* resource =  "/json?lat=53.440&lng=0.200&date=today";   // http resource
    const unsigned long BAUD_RATE = 9600;                              // serial connection speed
    const unsigned long HTTP_TIMEOUT = 10000;                          // max respone time from server
    const size_t MAX_CONTENT_SIZE = 512;  

    unsigned int localPort = 8888;       // local port to listen for UDP packets

    char timeServer[] = "time.nist.gov"; // time.nist.gov NTP server

    const int NTP_PACKET_SIZE = 48; // NTP time stamp is in the first 48 bytes of the message

    byte packetBuffer[ NTP_PACKET_SIZE]; //buffer to hold incoming and outgoing packets

    // A UDP instance to let us send and receive packets over UDP
     EthernetUDP Udp;
    // max size of the HTTP response

    // ARDUINO entry point #1: runs once when you press reset or power the board
    void setup() {
    initSerial();
    initEthernet();
    }

    // ARDUINO entry point #2: runs over and over again forever
    void loop() {
     if (connect(server)) {
     if (sendRequest(server, resource) && skipResponseHeaders()) {
     
       char response[MAX_CONTENT_SIZE]; 
     
      readReponseContent(response, sizeof(response));
      
      String str(response);
      Serial.println(str);
      
    char* field;
    char* sunset;
    char* sunrise;

    field = strtok(response,"{,");

    while (field != NULL)
    {
        field = strtok (NULL, ",}");

        if(field != NULL)
        {
            if(strstr(field, "sunrise") != NULL)
            {
                int length = strlen(field);
               sunrise = new char[length + 1];
               strncpy(sunrise, field, length + 1);         // +1 to copy a terminating null as well
            }
     
            if(strstr(field, "sunset") != NULL)
            {
                int length = strlen(field);
                sunset = new char[length + 1];              
                strncpy(sunset, field, length + 1);         // +1 to copy a terminating null as well
            }
        }
    }

    
    Serial.println("sunrise time is " );
    Serial.println(sunrise);
    Serial.println("sunset time is " );
    Serial.println(sunset);

    free(sunrise);  // do not forget to free the memory if not needed anymore
    free(sunset);   // do not forget to free the memory if not needed anymore
    }
    disconnect();
    }
    
    Serial.println("calling wait routine" );
    wait();
    Serial.println("exiting wait routine" );
    
    //NTP TIME STUFF    
    Serial.println("calling sendNTPpacket" );
    sendNTPpacket(timeServer); // send an NTP packet to a time server
    Serial.println("called sendNTPpacket" );
    
  // 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;
    Serial.print("Seconds since Jan 1 1900 = " );
    Serial.println(secsSince1900);

    // now convert NTP time into everyday time:
    Serial.print("Unix 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:
    Serial.println(epoch);

    // print the hour, minute and second:
    Serial.print("The UTC time is ");       // UTC is the time at Greenwich Meridian (GMT)
    Serial.print((epoch  % 86400L) / 3600); // print the hour (86400 equals secs per day)
    Serial.print(':');
    if ( ((epoch % 3600) / 60) < 10 ) {
      // In the first 10 minutes of each hour, we'll want a leading '0'
      Serial.print('0');
    }
    Serial.print((epoch  % 3600) / 60); // print the minute (3600 equals secs per minute)
    Serial.print(':');
    if ( (epoch % 60) < 10 ) {
      // In the first 10 seconds of each minute, we'll want a leading '0'
      Serial.print('0');
    }
    Serial.println(epoch % 60); // print the second
  }
  // wait ten seconds before asking for the time again
  delay(10000);
      
    /// end NTP TIME STUFF
    }
    
    // send an NTP request to the time server at the given address
unsigned long sendNTPpacket(char* address)
{
  // set all bytes in the buffer to 0
  
  Serial.println("Start SendNTPpacket");
  
  memset(packetBuffer, 0, NTP_PACKET_SIZE);
  // Initialize values needed to form NTP request
  // (see URL above for details on the packets)
  packetBuffer[0] = 0b11100011;   // LI, Version, Mode
  packetBuffer[1] = 0;     // Stratum, or type of clock
  
  Serial.println("middle SendNTPpacket");
  packetBuffer[2] = 6;     // Polling Interval
  packetBuffer[3] = 0xEC;  // Peer Clock Precision
  // 8 bytes of zero for Root Delay & Root Dispersion
  packetBuffer[12]  = 49;
  packetBuffer[13]  = 0x4E;
  packetBuffer[14]  = 49;
  packetBuffer[15]  = 52;

  Serial.println("all info for packet data SendNTPpacket");
  // all NTP fields have been given values, now
  // you can send a packet requesting a timestamp:

  Serial.println("begin packet SendNTPpacket");
  Udp.beginPacket(address, 123); //NTP requests are to port 123

  Serial.println("write SendNTPpacket");
  Udp.write(packetBuffer, NTP_PACKET_SIZE);
  Serial.println("end packet SendNTPpacket");
  Udp.endPacket();

  Serial.println("End SendNTPpacket");
}
    
    // Initialize Serial port
    void initSerial() {
     Serial.begin(BAUD_RATE);
     while (!Serial) {
     ;  // wait for serial port to initialize
    }
    Serial.println("Serial ready");
    }
    // Initialize Ethernet library
    void initEthernet() {
     byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
     byte ip[] = { 192,168,0,202 };

     if (!Ethernet.begin(mac)) {
      Serial.println("Failed to configure Ethernet");
      return;
      }
      Serial.println("Ethernet ready");
      delay(1000);
      }
      // Open connection to the HTTP server
      bool connect(const char* hostName) {
       Serial.print("Connect to ");
       Serial.println(hostName);

       bool ok = client.connect(hostName, 80);

       Serial.println(ok ? "Connected" : "Connection Failed!");
       return ok;
      }
      // Send the HTTP GET request to the server
      bool sendRequest(const char* host, const char* resource) {
       Serial.print("GET ");
       Serial.println(resource);
        client.print("GET ");
        client.print(resource);
        client.println(" HTTP/1.1");
        client.print("Host: ");
        client.println(server);
        client.println("Connection: close");
        client.println();
        return true;
       }
       // Skip HTTP headers so that we are at the beginning of the response's body
       bool skipResponseHeaders() {
        // HTTP headers end with an empty line
       char endOfHeaders[] = "\r\n\r\n";
       client.setTimeout(HTTP_TIMEOUT);
      bool ok = client.find(endOfHeaders);
       if (!ok) {
       Serial.println("No response or invalid response!");
       }
       return ok;
      }
     void disconnect() {
      Serial.println("Disconnect");
      client.stop();
     }
     // Pause for a 1 minute
     void wait() {
      Serial.println("Wait 60 seconds");
      delay(60000);
     }
     
     // Read the body of the response from the HTTP server
void readReponseContent(char* content, size_t maxSize) {
  size_t length = client.readBytes(content, maxSize);
}

I don't see a Udp.begin(localPort) call.

Thank you SurferTim yes I had missed that, I looked and just couldn't see thanks onto the next part of it!! :confused: :o