/* //used as an example in the program organization doc.
#include <Mega32.h>
#include <eth.c>
#include <STDIO.h>
#include <protocols.c>

//timeout values for each task

#define begin {
#define end }

interrupt [EXT_INT0] void packetin(void)
begin
   PORTC = PORTC ^ 0xf0;
end
   



//static unsigned char macaddr[6]={0x00,0x00,0xde,0xad,0xbe,0xef};
//static unsigned char ipaddr[4]={192,168,1,10};

static unsigned char packetbuffer[751];

static int packetlength;

//**********************************************************
//Entry point and task scheduler loop
void main(void)
begin  
  DDRC = 0xff;
  PORTC = 0xff;
  InitEthernet(macaddr);
 
  //main task scheduler loop
  while(1)
  begin
     // TEST
     packetlength = ReceivePacket(750,packetbuffer);
     //PORTA = PORTA ^ 0xff;
     //delay_ms(1000)      ;
     if( packetlength == 0); //PORTC = 0xf0 ; 
     else
     begin
      PORTC = ~packetlength;
      delay_ms(500);
//         for(i = 0; i <packetlength-1; i++)
//         begin
//            PORTC = ~packetbuffer[i+1];
//            delay_ms(500);
//            PORTC = 0xff;
//            delay_ms(500);
//         end
//       
      //if(~PORTC >= 2) PORTC = 0xa0;
      
      
       
      ARPReply(packetlength,packetbuffer);
      PingResponse(packetlength,packetbuffer);
      
            
      end
     

     //delay_ms(1000);
     PORTC = 0xff;
     //delay_ms(1000);
  end
  
end
                                  
*/

//used as an example in the program organization doc.
#include <Mega32.h>
#include <eth.c>
#include <protocols.c>
#include <taketemp.c>
#include <string.h>

//timeout values for each task

#define begin {
#define end }
// static unsigned char macaddr[6] = {0x00,0x00,0xde,0xad,0xbe,0xef};
// static unsigned char ipaddr[4]  = {192,168,1,10};

unsigned int packetlength;                
unsigned int datalength;
unsigned char didsomething;
unsigned int databegin, offset;
unsigned char found=0;
unsigned char error=0;
unsigned char tempsetpoint,setpoint;
unsigned char setpointoutputindex=3;
unsigned char setpointoutput[3]={'0','7','4'};
unsigned char tempoutput[3]={'0','7','4'};

#define UDP_PORT 1300

static unsigned char packet[750];
//**********************************************************
//Entry point and task scheduler loop
void main(void)
begin
  unsigned long i=0;
  unsigned long j=0;
  unsigned long k=0;
  DDRC = 0xff;
//  PORTC = 0xff;
  InitEthernet(macaddr);
  initTemp();
  DDRB = DDRB | 0x0F;
  temp_desired = 74;
  temp_now = taketemp();
   tempoutput[2] = temp_now % 10; // ex: 83 mod 10  = 3
   tempoutput[1] = (temp_now % 100 - tempoutput[2])/10; // ex: 83 mod 100 = 83-3 = 80 / 10 = 8
   tempoutput[0] = (temp_now - tempoutput[1]*10-tempoutput[2]);
   for(j=0;j<3;j++) tempoutput[j]=tempoutput[j]+0x30;
  //main task scheduler loop
  //PORTC = ~temp_now;

  while(1)
  begin
    j = j+1;
    if (j == 1001) j = 0;
    //Step 1: get new packet.  If there's no new packet, do the usual sampling + PD crap.
    //PORTC = PORTC ^ 0x01;
    //delay_ms(50);
    packetlength = ReceivePacket(750, packet);
    if(packetlength ==0)
    begin 
	   if (j == 1000)
	   begin
		   

			   if (ADCSR.6 == 0) 
			   begin
				   
				   temp_prev = temp_now;
				   temp_now = taketemp();
				   PORTC = convertBin(temp_now);
				   PORTC.7 = PORTB.0;
				   // conversion into character string
				   tempoutput[2] = temp_now % 10; // ex: 83 mod 10  = 3
				   tempoutput[1] = (temp_now % 100 - tempoutput[2])/10; // ex: 83 mod 100 = 83-3 = 80 / 10 = 8
				   tempoutput[0] = temp_now/100;

				   for(k=0;k<3;k++) 
				   begin
				        tempoutput[k]=tempoutput[k]+0x30;
				   end

			   end
			   updateP();
		   
		   
		   
	   end
	 end
    
    
    else
    begin
       
       //PORTC = ~packetlength;
       //delay_ms(100);
       // We got ourselves a packet!  Step one: check if it's ARP.
       didsomething = ARPReply(packetlength,packet);
       // Step two: if didsomething is low (we didn't do something. HA!), check ICMP
       if(didsomething == 0 )
       begin
          didsomething = PingResponse(packetlength,packet);
       end
       // Step three: if didsomething is low... yadda yadda.  Hopefully, it's a TCP packet, since that's all our implementation can regognize.  
       // We throw out all other packets.
       if(didsomething ==0)
       begin
//           PORTC = didsomething <<1;
//           PORTC = PORTC | ((packet[IP_HEADER_START+IP_PROTOCOL_OFFSET] != 6)<<2);
//           PORTC = PORTC | ((packet[TCP_HEADER_START+TCP_DEST_PORT_OFFSET] != HTTP_SOURCE_PORT_HIGH) <<3);
//           PORTC = PORTC | ((packet[TCP_HEADER_START+TCP_DEST_PORT_OFFSET+ 1] != HTTP_SOURCE_PORT_LOW)<<4);
//           PORTC = ~PORTC;
//           delay_ms(5000);
//           PORTC = ~(packet[TCP_HEADER_START+TCP_DEST_PORT_OFFSET]);
//           delay_ms(5000);
//           PORTC = ~(packet[TCP_HEADER_START+TCP_DEST_PORT_OFFSET]+1);
//           delay_ms(5000);
       end
       
       if(didsomething ==0)
       begin
          //check to see if it's UDP
          if(packet[IP_HEADER_START+IP_PROTOCOL_OFFSET] == UDP_PROTOCOL && packet[UDP_HEADER_START+UDP_DEST_PORT_OFFSET] == 0x06 && packet[UDP_HEADER_START+UDP_DEST_PORT_OFFSET+1] == 0x40)
          begin
             datalength = packet[UDP_HEADER_START+UDP_LENGTH_OFFSET+1] - UDP_HEADER_LENGTH;
             //PORTC = ~datalength;      
             //delay_ms(5000);
             i =0;
             found = 0;
             error = 0;
             while(!found && i<datalength)
             begin
                if(packet[UDP_HEADER_START+UDP_HEADER_LENGTH+i]=='s')
                begin
                   found = 1;
                end
                i++;
             end
             if(!found) i = 0;
             while(!found && i<datalength)
             begin
                if(packet[UDP_HEADER_START+UDP_HEADER_LENGTH+i]=='g')
                begin
                   found = 2;
                end
                i++;
             end
             
             // we found an s, incremented one, so we are now at some equals sign or something.  Test that it's an equals sign and display FF if it isnt
             if(found == 1)
             begin
                if(packet[UDP_HEADER_START+UDP_HEADER_LENGTH+i]!= '=')
                begin
                   error=1;
                end
                else
                begin
                   //increment to start of digit
                   i++;
                   tempsetpoint = 0;
                   setpointoutputindex=0;
                   while(packet[UDP_HEADER_START+UDP_HEADER_LENGTH+i]>=0x30 && packet[UDP_HEADER_START+UDP_HEADER_LENGTH+i]<=0x39)
                   begin
                      setpointoutput[setpointoutputindex] = packet[UDP_HEADER_START+UDP_HEADER_LENGTH+i]; 
                      tempsetpoint = tempsetpoint * 10 + (packet[UDP_HEADER_START+UDP_HEADER_LENGTH+i]-0x30);
                      i++;
                      setpointoutputindex++;
                   end
                   temp_desired = tempsetpoint;
                   updateP();
                   UDPReply(packet, setpointoutput,setpointoutputindex,tempoutput,3,error);
                end
             end
             else if (found == 2)
             begin
                
                   //increment to start of digit
                   UDPReply(packet, setpointoutput,setpointoutputindex,tempoutput,3,error);
                   
                   
                
             end
             else UDPReply(packet,setpointoutput,setpointoutputindex,tempoutput,3,1);
             
                
          end
       end    
        
        
        
          
//        // Final check: is the packet TCP?
//        if(didsomething ==0 && packet[IP_HEADER_START+IP_PROTOCOL_OFFSET] == 6 && packet[TCP_HEADER_START+TCP_DEST_PORT_OFFSET] == HTTP_SOURCE_PORT_HIGH && packet[TCP_HEADER_START+TCP_DEST_PORT_OFFSET+ 1] == HTTP_SOURCE_PORT_LOW)
//        begin
// 
//           //First, check if it's a syn, and synack
//           if(packet[TCP_HEADER_START+TCP_CONTROL_BITS_OFFSET] && (1<< TCP_CONTROL_BITS_SYN))
//           begin
//              //PORTC = 0xaa;
//              //delay_ms(1000);
//              //received SYN.  Respond with synack:
//              SynAckBuild(packetlength,packet);
//           end
//           
//           // gather the data length from the incoming packet: IP length field - IP header length - TCP header length = Data length.
//           // also figure out the start of the data field : IP header length + Ethernet Length + TCP header length = data_start
//           datalength = (((int)(packet[IP_HEADER_START+IP_TOTAL_LENGTH_OFFSET])) << 8 ) | (packet[IP_HEADER_START+IP_TOTAL_LENGTH_OFFSET] & 0xff) - 20 - (((int)(packet[IP_HEADER_START+20+TCP_DATA_OFFSET_OFFSET]>>4))*4); 
//           databegin =  14 + 20 + (((int)(packet[IP_HEADER_START+20+TCP_DATA_OFFSET_OFFSET]>>4))*4);
//           
//           if(datalength == 0)
//           begin
//              //datalength is 0: has to be an ack of some sort.
//              //check FINACK
//              if(packet[TCP_HEADER_START+TCP_CONTROL_BITS_OFFSET] & (1<TCP_CONTROL_BITS_FIN))
//              begin
//                  NoDataAckBuild(packet);
//              end
//           end
//           else // it's some sort of HTTP stuff.
//           begin
//              // check that the incoming packet is not a GET
//              if(strncmpf( &packet[databegin],"GET ",4) != 0)
//              begin
//                 // It's some goofy method. Send error screen.
//                 PORTC = 0x0F;
//                 delay_ms(4000);
//                 // TO DOOOOO
//              end
//              // method is a GET.  check to see if a command (POST) has been issued and reissue the webpage. 
//              else
//              begin
//                 PORTC = 0xFF;
//                 delay_ms(5000);
//                 // set new setpoint
//                 //DecodeSetPoint(packet);
//                 // print webpage
//                // offset = PrintWebPage(packet,error);
//                 NoDataAckBuild(packet);
//                 DataAckBuild(packet,offset);
//                 
//              end
//                 //PORTC = 0xaa;
//                 //delay_ms(4000);
//           end    
// 
//           
//        end
     end

  end
end