ARTSAT PROJECT 衛星家具

gistfile1.c

///////////////////////////////////////////////
////    ARTSAT PROJECT Dec. 20-21 2010    /////
////  Writen by Koichiro Mori moxus.org   /////
///////////////////////////////////////////////

#include <Ethernet.h>
#include "Dhcp.h"
#include <NunniMCAX.h>
#include <string.h>

// Define Constants
// Max string length may have to be adjusted depending on data to be extracted
#define MAX_STRING_LEN  20
int ledPin = 3; // PWM value should be from 15 to 43 for AC dimer Kit
int monitorledPin = 12; // led for monitor
//int monitorledPin = 4; // led for monitor

// Setup vars
char tagStr[MAX_STRING_LEN] = "";
char dataStr[MAX_STRING_LEN] = "";
char tmpStr[MAX_STRING_LEN] = "";
char endTag[3] = {
  '<', '/', '\0'};
void setTimerBpm(void (*isr)(),int bpm);
void detectUpdate();
int len;

// Flags to differentiate XML tags from document elements (ie. data)
boolean tagFlag = false;
boolean dataFlag = false;
int idNum = 0;

byte mac[] = { 0x90, 0xA2, 0xDA, 0x00, 0x21, 0x5C }; //please replace to your mac
byte server[] = { 122,212,35,122 }; // gs.idd.tamabi.ac.jp

boolean ipAcquired = false;
int counter = 0;
int outputValId = 0;
int updatedFlag = 0;
float outPutVal[] = { 9.36, 12.5, 2.06, 11.5 };
int outPutValCount = 0;
boolean onceUpdateFlag = true;
boolean onceUpdateFlagAlpha = true;

Client client(server, 80);           

void setup()
{
  Serial.begin(115200);

  pinMode(ledPin, OUTPUT);
  pinMode(monitorledPin, OUTPUT); 

//get ip with DHCP
  Serial.println("getting ip...");
  digitalWrite(monitorledPin, HIGH);
  int result = Dhcp.beginWithDHCP(mac);

  if(result == 1)
  {
    ipAcquired = true;

    byte buffer[6];
    Serial.println("ip acquired...");

    Dhcp.getMacAddress(buffer);
    Serial.print("mac address: ");
    printArray(&Serial, ":", buffer, 6, 16);

    Dhcp.getLocalIp(buffer);
    Serial.print("ip address: ");
    printArray(&Serial, ".", buffer, 4, 10);

    Dhcp.getSubnetMask(buffer);
    Serial.print("subnet mask: ");
    printArray(&Serial, ".", buffer, 4, 10);

    Dhcp.getGatewayIp(buffer);
    Serial.print("gateway ip: ");
    printArray(&Serial, ".", buffer, 4, 10);

    Dhcp.getDhcpServerIp(buffer);
    Serial.print("dhcp server ip: ");
    printArray(&Serial, ".", buffer, 4, 10);

    Dhcp.getDnsServerIp(buffer);
    Serial.print("dns server ip: ");
    printArray(&Serial, ".", buffer, 4, 10);
    digitalWrite(monitorledPin, LOW);
    delay(250);

  }
  else
    Serial.println("unable to acquire ip address...");
}

void loop()
{
  if(ipAcquired)
  {
    delay(2);
    if (client.available()) {
      digitalWrite(monitorledPin, HIGH);
      analogWrite(ledPin, int(map( outPutVal[outputValId] , 0,15,15,43)) );
      digitalWrite(monitorledPin, LOW);
      serialEvent();
    }

    if (!client.connected()) {
      Serial.println();
      Serial.println("disconnecting.");
      client.stop();
      
      delay(8000);
      Serial.println("connecting...");
      idNum = 0;
      if (client.connect()) {
        Serial.println("connected");
        client.println("GET /satellite/satellite_result_PRISM.xml HTTP/1.0");
        client.println();
      } 
      else {
        Serial.println("connection failed");
      }
      
      delay(1200);
    
      analogWrite(ledPin, int(map( outPutVal[outputValId] , 0,15,15,43)) );
      delay(1200);
    
      if(updatedFlag == 1){
        detectUpdate();
      };
    
      outputValId++;
      if(outputValId>3){
        outputValId = 0;
      }
    
      counter++;
      Serial.println( counter );
      if(counter>50)counter = 0;  // reset count
    
      for(int i=0;i<4;i++){
        Serial.println(outPutVal[i]);
      }
      delay(1000);
 
    }
  }

}

void printArray(Print *output, char* delimeter, byte* data, int len, int base)
{
  char buf[10] = {
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0    };

  for(int i = 0; i < len; i++)
  {
    if(i != 0)
      output->print(delimeter);
    output->print(itoa(data[i], buf, base));
    
  }
  output->println();
}

// Process each char from web
void serialEvent() {
  // Read a char
  char inChar = client.read();

  if (inChar == '<') {
    addChar(inChar, tagStr);
    tagFlag = true;
    dataFlag = false;

  } 
  else if (inChar == '>') {
    addChar(inChar, tmpStr);

    if (tagFlag) {      
      strncpy(tagStr, tmpStr, strlen(tmpStr)+1);
    }

    // Clear tmp
    clearStr(tmpStr);
    tagFlag = false;
    dataFlag = true;      

  } 
  else if (inChar != 10) {
    if (tagFlag) {
      // Add tag char to string
      addChar(inChar, tmpStr);

      // Check for </XML> end tag, ignore it
      if ( tagFlag && strcmp(tmpStr, endTag) == 0 ) {
        clearStr(tmpStr);
        tagFlag = false;
        dataFlag = false;
      }
    }

    if (dataFlag) {
      // Add data char to string
      addChar(inChar, dataStr);
    }
  }  

  if (inChar == 10 ) {
    digitalWrite(monitorledPin, HIGH);
//              Serial.print("tagStr: ");
//              Serial.println(tagStr);
//              Serial.print("dataStr: ");
//              Serial.println(dataStr);
    if (matchTag("/value>")) {
      if(idNum == 0){
        updatedFlag = atoi(dataStr);
        if( updatedFlag == 0 && !onceUpdateFlag )onceUpdateFlag = true;
      }
      
       if( idNum == 1 && onceUpdateFlagAlpha ){
         float inputVal;
         inputVal = atof(dataStr);
         if(inputVal >= -1){
           outPutVal[outPutValCount] = inputVal;
           Serial.println("once");
         }
          outPutValCount++;
          onceUpdateFlagAlpha = false;
          
        }
    
     if( updatedFlag == 1 && idNum == 1 && onceUpdateFlag){
         float inputVal;
         inputVal = atof(dataStr);
         if(!inputVal == -1)outPutVal[outPutValCount] = inputVal;
          outPutValCount++;
          onceUpdateFlag = false;
        }
        
      if( outPutValCount > 3 ){
        outPutValCount = 0;
      }

      if(idNum == 0 || idNum == 1){
        Serial.print("OutValue: ");
        Serial.print(idNum);
        Serial.print(": ");
        Serial.print(dataStr);
      }
      idNum++;
    }
    digitalWrite(monitorledPin, LOW);

    // Clear all strings
    clearStr(tmpStr);
    clearStr(tagStr);
    clearStr(dataStr);

    // Clear Flags
    tagFlag = false;
    dataFlag = false;
  }
}

// Function to clear a string
void clearStr (char* str) {
  int len = strlen(str);
  for (int c = 0; c < len; c++) {
    str[c] = 0;
  }
}

//Function to add a char to a string and check its length
void addChar (char ch, char* str) {
  char *tagMsg  = "<TRUNCATED_TAG>";
  char *dataMsg = "-TRUNCATED_DATA-";

  if (strlen(str) > MAX_STRING_LEN - 2) {
    if (tagFlag) {
      clearStr(tagStr);
      strcpy(tagStr,tagMsg);
    }
    if (dataFlag) {
      clearStr(dataStr);
      strcpy(dataStr,dataMsg);
      //idNum++;
    }

    // Clear the temp buffer and flags to stop current processing
    clearStr(tmpStr);
    tagFlag = false;
    dataFlag = false;

  } 
  else {
    // Add char to string
    str[strlen(str)] = ch;
  }
}

// Function to check the current tag for a specific string
boolean matchTag (char* searchTag) {
  if ( strcmp(tagStr, searchTag) == 0 ) {
    return true;
  } 
  else {
    return false;
  }
}

// when data updated blink the light
void detectUpdate()  { 
 digitalWrite(monitorledPin, HIGH);
  for(int i=0;i<100;i++){
    // fade in from min to max in increments of 5 points:
    for(int fadeValue = 0 ; fadeValue <= 255; fadeValue +=8) { 
      int val;
      // sets the value (range from 0 to 255):
      val = map(fadeValue, 0,255,0,90);
      analogWrite(ledPin, val);         
      // wait for 30 milliseconds to see the dimming effect    
      delay(10);                            
    } 
  digitalWrite(monitorledPin, LOW);
    // fade out from max to min in increments of 5 points:
    for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=8) { 
      int val;
      // sets the value (range from 0 to 255):
      val = map(fadeValue, 0,255,0,90);
      analogWrite(ledPin, val);         
      // wait for 30 milliseconds to see the dimming effect    
      delay(10);                            
    } 
    delay(500);
  }
}

----Library Dependencies----

Dhcp：http://blog.jordanterrell.com/post/Arduino-DHCP-Library-Version-04.aspx

NunniMCAX：http://todotani.cocolog-nifty.com/blog/files/NunniMCAX-1.4.1_arduino.zip