API tools faq
paste
Advertisement
Guest User

ethernet

a guest
Jan 19th, 2014
182
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 12.79 KB | None | 0 0
raw download clone embed print report
  1. #include <LiquidCrystal.h>
  2. #include <TimerOne.h>
  3. #include <util.h>
  4. #include <EthernetUdp.h>
  5. #include <EthernetServer.h>
  6. #include <EthernetClient.h>
  7. #include <Ethernet.h>
  8. #include <Dns.h>
  9. #include <Dhcp.h>
  10. #include <SPI.h>
  11. #include <OneWire.h>
  12. #include <stdlib.h>
  13.  
  14.  
  15.  
  16. byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
  17. IPAddress defaultIp(192,168,1,177);
  18. IPAddress timeServer(217,31,205,226);
  19. const int NTP_PACKET_SIZE= 48;
  20. byte packetBuffer[ NTP_PACKET_SIZE];
  21. unsigned int localPort = 80;                // local port to listen for UDP packets
  22.  
  23. byte addr[8];
  24. byte ow_dev_count=0;
  25.  
  26. float temps[9];                                 //načtené teploty
  27. byte rele[]={30, 31, 32, 33, 34, 35, 36, 37};
  28. //bool relePointer[]={false, false, false, false, false, false, false, false};
  29. byte kotel = 38;
  30. float user_temps[9][5];                         //uživatelem nastavené teploty
  31. float default_temps[9];                         //výchozí teploty
  32. int startTime[9][5];                           //zde se uchovávají časy, kdy mají být dané teploty aktivní
  33. int endTime[9][5];
  34. int intTime;
  35. int hour;
  36. int minute;
  37. int second;
  38. int httpCounter=0;
  39. int checkTempCounter=0;
  40. int maintainEthernet=0;
  41. char getRequest[100];
  42. bool owMeasure = true;
  43.  
  44. OneWire senzory[8]={OneWire(42),OneWire(43),OneWire(44),OneWire(45),OneWire(46),OneWire(47),OneWire(48),OneWire(49)};
  45.  
  46. LiquidCrystal lcd(22,23,24,25,26,27);
  47.  
  48. // Initialize the Ethernet server library
  49. // with the IP address and port you want to use
  50. // (port 80 is default for HTTP):
  51. EthernetServer server(80);
  52. EthernetClient client;
  53. EthernetUDP Udp;
  54.  
  55.  
  56.  
  57.  
  58. void setup() {
  59.  // Open serial communications and wait for port to open:
  60.   Serial.begin(9600);
  61.  
  62.   Timer1.initialize(1000000);
  63.   Timer1.attachInterrupt(interrupt);
  64.  
  65.   lcd.begin(16,2);
  66.   lcd.clear();
  67.   lcd.noCursor();
  68.  
  69.  
  70.   pinMode(kotel,OUTPUT);
  71.   digitalWrite(kotel,LOW);
  72.   for(int i=0;i<=7;i++)
  73.   {
  74.       pinMode(rele[i],OUTPUT);
  75.       digitalWrite(rele[i],LOW);
  76.   }
  77.  
  78.   // start the Ethernet connection and the server:
  79.   if (Ethernet.begin(mac) == 0) {
  80.     Serial.println("Failed to configure Ethernet using DHCP");
  81.     // no point in carrying on, so do nothing forevermore:
  82.     Ethernet.begin(mac,defaultIp);
  83.   }
  84.  
  85.   printIpAddress();
  86.  
  87.   server.begin();
  88.   Serial.print("server is at ");
  89.   Serial.println(Ethernet.localIP());
  90.   Udp.begin(localPort);
  91.  
  92.   initVariables();
  93.  
  94.   ow_dev_count = countDev();  
  95.   Serial.print(ow_dev_count, DEC);
  96.   Serial.println(" Devices found.");
  97.   getTime();
  98.  
  99. }
  100.  
  101.  
  102. void loop() {
  103.     client = server.available();
  104.   if (client) {
  105.     Serial.println("new client");
  106.     // an http request ends with a blank line
  107.     boolean currentLineIsBlank = true;
  108.     httpCounter=0;
  109.     while (client.connected()) {
  110.       if (client.available()) {
  111.         char c = client.read();  
  112.         //Serial.write(c);
  113.         //Serial.write(c);
  114.         if(httpCounter<80)
  115.         {
  116.             getRequest[httpCounter] = c;
  117.             httpCounter++;
  118.         }
  119.         // if you've gotten to the end of the line (received a newline
  120.         // character) and the line is blank, the http request has ended,
  121.         // so you can send a reply
  122.         if (c == '\n' && currentLineIsBlank) {
  123.           // send a standard http response header
  124.            
  125.            
  126.             printWeb();
  127.             break;
  128.  
  129.         }
  130.         if (c == '\n') {
  131.           // you're starting a new line
  132.           currentLineIsBlank = true;
  133.         }
  134.         else if (c != '\r') {
  135.           // you've gotten a character on the current line
  136.           currentLineIsBlank = false;
  137.         }
  138.       }
  139.     }
  140.     // give the web browser time to receive the data
  141.     delay(1);
  142.     // close the connection:
  143.     client.stop();
  144.     Serial.println("client disconnected");
  145.   }
  146. }
  147.  
  148. int countDev()
  149. {
  150.     byte i=0;
  151.     int devCount=0;
  152.     for(i=0;i<=7;i++)
  153.     {
  154.         if(senzory[i].search(addr)==true)
  155.         {
  156.             Serial.println("Device found.");
  157.             devCount++;
  158.             senzory[i].reset_search();
  159.         }
  160.         else
  161.         {
  162.             break;
  163.         }
  164.     }
  165.     return devCount;
  166. }
  167.  
  168.  
  169. void initVariables()
  170. {
  171.     int i,j = 0;
  172.    
  173.     for(i=0;i<=7;i++)
  174.     {
  175.         temps[i] = 85.0;
  176.         default_temps[i] = 18.0;
  177.         for(j=0;j<=5;j++)
  178.         {
  179.             user_temps[i][j] = 15;
  180.             startTime[i][j] = -100;
  181.             endTime[i][j] = -100;
  182.         }
  183.     }
  184.     user_temps[0][0]=15;
  185.     startTime[0][0]=-100;
  186.     startTime[0][1]=-100;
  187.     default_temps[0]=18;
  188. }
  189.  
  190.  
  191. void printWeb()
  192. {
  193.     short int room_num;
  194.     short int temp_num;
  195.     char req_temp[6];
  196.     char req_time[6];
  197.  
  198.     if(isdigit(getRequest[5])==1)
  199.     {
  200.         room_num = getRequest[5]- '0';
  201.         if(getRequest[7]=='t')
  202.         {
  203.             if(isdigit(getRequest[8]==1))
  204.             {
  205.                 temp_num = getRequest[8]- '0';
  206.             }
  207.             for(int i=0;i<=3;i++)
  208.             {
  209.                 req_temp[i] = getRequest[10+i];
  210.             }
  211.             user_temps[room_num][temp_num] = atof(req_temp);
  212.             for(int i=0;i<=3;i++)
  213.             {
  214.                 req_time[i]=getRequest[15+i];
  215.             }
  216.             req_time[4] = '/n';
  217.             startTime[room_num][temp_num]=atoi(req_time);
  218.             Serial.println(startTime[room_num][temp_num],DEC);
  219.             for(int i=0;i<=3;i++)
  220.             {
  221.                 req_time[i]=getRequest[20+i];
  222.             }
  223.             req_time[4] = '/n';
  224.             endTime[room_num][temp_num]=atoi(req_time);
  225.  
  226.         }
  227.         if(getRequest[7]=='d')
  228.         {
  229.             for(int i=0;i<=3;i++)
  230.             {
  231.                 req_temp[i] = getRequest[9+i];
  232.                 default_temps[room_num] = atof(req_temp);
  233.             }
  234.         }
  235.    
  236.  
  237.  
  238.     printHeader();
  239.     client.println("<body>");
  240.     client.println("<table align=\"center\" bordercolor=\"black\" border=\"2px\">");
  241.     client.println("<tr><td>Nastavená teplota</td><td>Startovací čas</td><td>Koncový čas</td></tr>");
  242.  
  243.     for(int i=0;i<=5;i++)
  244.     {
  245.         client.print("<tr><td>");
  246.         client.print(user_temps[room_num][i]);
  247.         client.print(" °C</td><td>");
  248.         client.print(startTime[room_num][i],DEC);
  249.         client.print("</td><td>");
  250.         client.print(endTime[room_num][i],DEC);
  251.         client.println("</td></tr>");
  252.     }
  253.     client.println("</table>");
  254.     client.println("<div align=\"center\">");
  255.     client.print("<h1>Místnost č. ");
  256.     client.println(room_num,DEC);
  257.     client.println("</h1>");
  258.     client.print("<h1>Výchozí teplota: ");
  259.     client.print(default_temps[room_num]);
  260.     client.println("°C</h1>");
  261.     client.print("<h1> Naměřená teplota: ");
  262.     client.print(temps[room_num]);
  263.     client.println(" °C</h1>");
  264.     client.print("<h1>");
  265.     client.print("Timestamp: ");
  266.     client.print(hour,DEC);
  267.     client.print(":");
  268.     if(minute<10)
  269.     {
  270.         client.print("0");
  271.     }
  272.     client.print(minute,DEC);
  273.     client.print(":");
  274.     if(second<10)
  275.     {
  276.         client.print("0");
  277.     }
  278.     client.print(second,DEC);
  279.     client.println("<h1>");
  280.     client.println("</div>");
  281.     client.println("</body>");
  282.     client.println("</html>");
  283.     }  
  284.  
  285.     if(getRequest[5]==' ')
  286.     {
  287.         printHeader();
  288.         client.println("<body>");
  289.         client.print("Počet Nalezených senzorů: ");
  290.         client.println(ow_dev_count,DEC);
  291.         client.println("</body>");
  292.         client.println("</html>");
  293.     }
  294.  
  295.         if(getRequest[5]=='s')
  296.     {
  297.         ow_dev_count=countDev();
  298.         printHeader();
  299.         client.println("<body>");
  300.         client.print("Počet Nalezených senzorů: ");
  301.         client.println(ow_dev_count,DEC);
  302.         client.println("</body>");
  303.         client.println("</html>");
  304.     }
  305.            
  306. }
  307.  
  308.  
  309. void printHeader()
  310. {
  311.     client.println("HTTP/1.1 200 OK");
  312.     client.println("Content-Type: text/html");
  313.     client.println("Connection: close");  // the connection will be closed after completion of the response
  314.     client.println();
  315.     client.println("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML4.01//EN\">");
  316.     client.println("<html>");
  317.     client.println("<head>");
  318.     client.print("<meta http-equiv=\"content-type\" content=\"text/html; charset=utf-8\">");
  319.     client.println("</head>");
  320. }
  321.  
  322.  
  323. unsigned long sendNTPpacket(IPAddress& address)
  324. {
  325.   memset(packetBuffer, 0, NTP_PACKET_SIZE);
  326.   packetBuffer[0] = 0b11100011;
  327.   packetBuffer[1] = 0;
  328.   packetBuffer[2] = 6;  
  329.   packetBuffer[3] = 0xEC;
  330.   packetBuffer[12]  = 49;
  331.   packetBuffer[13]  = 0x4E;
  332.   packetBuffer[14]  = 49;
  333.   packetBuffer[15]  = 52;  
  334.   Udp.beginPacket(address, 123);
  335.   Udp.write(packetBuffer,NTP_PACKET_SIZE);
  336.   Udp.endPacket();
  337. }
  338.  
  339.  
  340. void getTime()
  341. {
  342.   Serial.println("NTP_Time");
  343.   sendNTPpacket(timeServer);
  344.   delay(1000);  
  345.   if ( Udp.parsePacket() ) {  
  346. Udp.read(packetBuffer,NTP_PACKET_SIZE);  // read the packet into the buffer
  347.        
  348.         //the timestamp starts at byte 40 of the received packet and is four bytes,
  349.         // or two words, long. First, esxtract the two words:
  350.        
  351.         unsigned long highWord = word(packetBuffer[40], packetBuffer[41]);
  352.         unsigned long lowWord = word(packetBuffer[42], packetBuffer[43]);  
  353.         // combine the four bytes (two words) into a long integer
  354.         // this is NTP time (seconds since Jan 1 1900):
  355.         unsigned long secsSince1900 = highWord << 16 | lowWord;  
  356.         Serial.print("Seconds since Jan 1 1900 = " );
  357.         Serial.println(secsSince1900);               
  358.        
  359.         // now convert NTP time into everyday time:
  360.         Serial.print("Unix time = ");
  361.         // Unix time starts on Jan 1 1970. In seconds, that's 2208988800:
  362.         const unsigned long seventyYears = 2208988800UL;     
  363.         // subtract seventy years:
  364.         unsigned long epoch = secsSince1900 - seventyYears;  
  365.         // print Unix time:
  366.         Serial.println(epoch);                               
  367.        
  368.         // print the hour, minute and second:
  369.         Serial.print("The UTC time is ");       // UTC is the time at Greenwich Meridian (GMT)
  370.         hour = ((epoch   % 86400L) / 3600) + 2;
  371.         Serial.print(hour, DEC);    // print the hour (86400 equals secs per day)
  372.         minute = (epoch % 3600) / 60;
  373.         Serial.print(':'); 
  374.         if ( minute < 10 ) {
  375.             // In the first 10 minutes of each hour, we'll want a leading '0'
  376.             Serial.print('0');
  377.         }
  378.         Serial.print(minute, DEC); // print the minute (3600 equals secs per minute)
  379.         second = epoch % 60;
  380.         Serial.print(':');
  381.         if ( second < 10 ) {
  382.             // In the first 10 seconds of each minute, we'll want a leading '0'
  383.             Serial.print('0');
  384.         }
  385.         Serial.println(second, DEC); // print the second
  386.     }
  387. }
  388.  
  389.  
  390. void interrupt()
  391. {
  392.     second++;
  393.     checkTempCounter++;
  394.     maintainEthernet++;
  395.     if(second>=60)
  396.                   {
  397.                    minute++;
  398.                    second = 0;
  399.                   }
  400.     if(minute>=60)
  401.                   {
  402.                    hour++;
  403.                    minute = 0;
  404.                   }
  405.     if(hour>=24)
  406.                 {
  407.                  hour = 0;
  408.                 }
  409.  
  410.     if(checkTempCounter>=10)
  411.     {
  412.         checkTempCounter=0;
  413.         checkTemp();
  414.     }
  415.  
  416.     if(maintainEthernet>=600)
  417.     {
  418.         maintainEthernet = 0;
  419.         getTime();
  420.         if(Ethernet.maintain()==2)
  421.         {
  422.             printIpAddress();
  423.         }
  424.     }
  425.  
  426.     timeToInteger();
  427.  
  428.     if(owMeasure==true)
  429.     {
  430.         convertTemp();
  431.         owMeasure=false;
  432.     }
  433.     else
  434.     {
  435.         readTemp();
  436.         owMeasure=true;
  437.     }
  438. }
  439.  
  440. void convertTemp()
  441. {
  442.     for(int i=0;i<ow_dev_count;i++)
  443.     {
  444.         if(senzory[i].reset()==1)
  445.         {
  446.             senzory[i].write(0xCC,0);
  447.             senzory[i].write(0x44,0);
  448.         }
  449.     }
  450. }
  451.  
  452. void readTemp()
  453. {
  454.     int intTemp;
  455.     float floatTemp;
  456.    
  457.     for(int i=0;i<ow_dev_count;i++)
  458.     {
  459.         if(senzory[i].reset()==1)
  460.         {
  461.             senzory[i].write(0xCC,0);
  462.             senzory[i].write(0xBE,0);
  463.             intTemp = senzory[i].read();
  464.             intTemp = (senzory[i].read() <<8 ) + intTemp;
  465.             if((intTemp & 0x800)==0x800)
  466.             {
  467.                 intTemp=~intTemp;
  468.                 intTemp++;
  469.                 intTemp = intTemp * -1;
  470.             }
  471.             floatTemp = intTemp;
  472.             floatTemp = floatTemp * 0.0625;
  473.             temps[i] = floatTemp;
  474.         }
  475.     }
  476. }
  477.  
  478.  
  479. void timeToInteger()                       //funkce, která konvertuje čas na hodnotu typu integer
  480. {                                          //např čas 16:25 je zkonvertován na 1625
  481. int lhour;
  482. int lmin;
  483.  
  484.     lhour = hour;
  485.     lmin = minute;
  486.     lhour = lhour*100;
  487.     lhour = lhour + minute;
  488.     intTime = lhour;
  489. }
  490.  
  491.  
  492.  
  493.  
  494. void checkTemp()
  495. {
  496.  
  497.  short int i,j;
  498.  short int default_temp_flag=0;
  499.  
  500.  for(i=0;i<ow_dev_count;i++)
  501.  {
  502.     default_temp_flag=0;
  503.     for(j=0;j<=5;j++)
  504.     {
  505.         if(startTime[i][j]>=0 && endTime[i][j]>=0)
  506.         {
  507.             if((intTime>=startTime[i][j]) && (intTime<=endTime[i][j]))
  508.             {
  509.                 default_temp_flag=1;
  510.                 if(temps[i]>user_temps[i][j]+0.2)
  511.                 {                                                                                    
  512.                     digitalWrite(rele[i],LOW);
  513.                 }
  514.                 if(temps[i]<user_temps[i][j]-0.2)
  515.                 {
  516.                     digitalWrite(rele[i],HIGH);
  517.                     digitalWrite(kotel,HIGH);
  518.                 }
  519.              }
  520.          }
  521.      }
  522.  
  523.     if(default_temp_flag == 0)
  524.     {
  525.         if(temps[i]>default_temps[i]+0.2)
  526.         {
  527.             digitalWrite(rele[i],LOW);
  528.         }
  529.         if(temps[i]<default_temps[i]-0.2)
  530.         {
  531.             digitalWrite(rele[i],HIGH);
  532.         }
  533.     }
  534.   }
  535.  if((digitalRead(rele[0])==LOW) && (digitalRead(rele[1])==LOW) && (digitalRead(rele[2])==LOW) && (digitalRead(rele[3])==LOW) && (digitalRead(rele[4])==LOW) && (digitalRead(rele[5])==LOW) && (digitalRead(rele[6])==LOW) && (digitalRead(rele[7])==LOW))
  536.  {
  537.      digitalWrite(kotel,LOW);
  538.  }
  539.  else
  540.  {
  541.      digitalWrite(kotel,HIGH);
  542.  }
  543. }
  544.  
  545. void printIpAddress()
  546. {
  547.     lcd.print("IP adresa:");
  548.     lcd.setCursor(0,1);
  549.     lcd.print(Ethernet.localIP());
  550. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!