Go Down

Topic: Acionar, via arduino, pino 9 Xbee (Hibernação) (Read 2 times) previous topic - next topic

Kotch

pode postar o seu codigo, aqui?

olhe onde esta o pino 9:



8)
????????????????????

Kotch

????????????????????

jpensk

Eita amigo... não é esse shield não. Uso o stalker V2 (http://www.seeedstudio.com/wiki/Seeeduino_Stalker_v2.1)

Abaixo, segue o código que estou usando. Agradeço sua colaboração!!!
Veja se pode me ajudar.

#include <math.h>

#define TEMPERATURA_ADC 1
#define CORRENTE_ADC    0
#define BAT_ADC         7

#define blinkLed 8

#define BAUDRATE 9600

void sendXbeeTxAPI(byte address64bits[], byte divisor, int valor, int latency_ms, boolean typeTransmission);


   float pad = 9805;                       //valor resistencia do divisor de tensão
                                       
   float thermr = 10000;   float Temp;
   
   long previousMillis = 0;
   long previousMillis2 = 0;
   
   long interval = 1000;
   
   //For analog read
   double value;

   //Constants to convert ADC divisions into mains current values.
   double ADCvoltsperdiv = 0.0032;
   double VDoffset = 1.25; //Initial value (corrected as program runs)

   //Equation of the line calibration values
   double factorA = 15.2; //factorA = CT reduction factor / rsens
   double Ioffset = -0.08;
     
   //Constants set voltage waveform amplitude.
   double SetV = 127;

   //Counter
   int i=0;

   int samplenumber = 1000;

   //Used for calculating real, apparent power, Irms and Vrms.
   double sumI=0.0;

   int sum1i=0;
   double sumVadc=0.0;

   double Vadc,Vsens,Isens,Imains,sqI,Irms;
   double apparentPower;
   
void setup()
{
  pinMode(blinkLed, OUTPUT);
  Serial.begin(BAUDRATE); 
}

void loop()
{
   unsigned long currentMillis = millis();
   if(currentMillis - previousMillis > interval) {
     
      previousMillis = currentMillis;
     
      //SUPERVISORIO#########################################################
      byte address64bits[] = {0x00, 0x13, 0xA2, 0x00, 0x40, 0x6C, 0xBC, 0xC5};
      int latency_ms = 50;
     
      //trata dado temperatura e envia pacote API para coordenador
      byte divisor = 'Q';
      int valor = Temp;
      sendXbeeTxAPI(address64bits, divisor, valor, latency_ms, true);
     
      //trata dado corrente e envia pacote API para coordenador
      divisor = 'W';
      valor = Irms;
      sendXbeeTxAPI(address64bits, divisor, valor, latency_ms, true);
     
      //trata dado tensão bateria e envia pacote API para coordenador
      divisor = 'U';
      analogReference(DEFAULT);//referencia de tensão interna 1.1v no Atmega328
      int valorADC = analogRead(7);
      valor = valorADC*3;       
      sendXbeeTxAPI(address64bits, divisor, valor, latency_ms, true);
     
     
      //ETHERNET#############################################################
      address64bits[0] = 0x00; address64bits[1] = 0x13; address64bits[2] = 0xA2; address64bits[3] = 0x00;
      address64bits[4] = 0x40; address64bits[5] = 0x6F; address64bits[6] = 0x21; address64bits[7] = 0x68;
      latency_ms = 50;
     
      //trata dado temperatura e envia pacote API para ethernet
      divisor = 'Q';
      valor = Temp;
      sendXbeeTxAPI(address64bits, divisor, valor, latency_ms, true);
     
      //trata dado corrente e envia pacote API para ethernet
      divisor = 'W';
      valor = Irms;
      sendXbeeTxAPI(address64bits, divisor, valor, latency_ms, true);
     
      //trata dado tensão bateria e envia pacote API para ethernet
      divisor = 'U';
      analogReference(DEFAULT);//referencia de tensão interna 1.1v no Atmega328
      valorADC = analogRead(7);
      valor = valorADC + valorADC + valorADC;   
      sendXbeeTxAPI(address64bits, divisor, valor, latency_ms, true);
     
      }
     
   corrente();
   temperatura();
 
}

void temperatura(){
  analogReference(DEFAULT); 
  value = analogRead(TEMPERATURA_ADC);
 
  long Resistance;   
 
  Resistance=((1024 * pad / value) - pad);
  Temp = log(Resistance);
  Temp = 1 / (0.001129148 + (0.000234125 * Temp) + (0.0000000876741 * Temp * Temp * Temp));
  Temp = Temp - 273.15;     
}

void corrente(){
   analogReference(DEFAULT);
   value = analogRead(CORRENTE_ADC);
   //Summing counter
   i++;
   //Voltage at ADC
   Vadc = value * ADCvoltsperdiv;
   //Remove voltage divider offset
   Vsens = Vadc-VDoffset;
   //Current transformer scale to find Imains
   Imains = Vsens;                 
   //Calculates Voltage divider offset.
   sum1i++; sumVadc = sumVadc + Vadc;
   if (sum1i>=1000) {VDoffset = sumVadc/sum1i; sum1i = 0; sumVadc=0.0;}
   //Root-mean-square method current
   //1) square current values
   sqI = Imains*Imains;
   //2) sum
   sumI=sumI+sqI;
   if (i>=samplenumber)
   { 
      i=0;
      //Corrente em mA
      Irms = 100*factorA*sqrt(sumI/samplenumber)+Ioffset;
                   
      apparentPower = Irms * SetV;
       
      sumI=0.0;

   }
}

void sendXbeeTxAPI(byte address64bits[], byte divisor, int value, int latency_ms, boolean typeTransmission)
{
  if(value > 9999)
  return;
 
  if (typeTransmission)
  {
      byte unidade = value%10+0x30;
      value /= 10;     
      byte dezena = value%10+0x30;
      value /= 10;
      byte centena = value%10+0x30;
      value /= 10;     
      byte milhar = value%10+0x30;
     
      //Inicializa pacote API
      //0x7E inicia pacote
      Serial.print(0x7E ,BYTE);
      //Tamanho pacote MSB
      Serial.print(0x00 ,BYTE);
      //Tamanho pacote LSB
      Serial.print(0x16 ,BYTE);
      //Frame ID (0x10: transmissão mensagem)
      Serial.print(0x10 ,BYTE);
      //Sem retorno de resposta
      Serial.print(0x00 ,BYTE);
      //64 bits address
      Serial.print(address64bits[0] ,BYTE);
      Serial.print(address64bits[1] ,BYTE);
      Serial.print(address64bits[2] ,BYTE);
      Serial.print(address64bits[3] ,BYTE);
      Serial.print(address64bits[4] ,BYTE);
      Serial.print(address64bits[5] ,BYTE);
      Serial.print(address64bits[6] ,BYTE);
      Serial.print(address64bits[7] ,BYTE);
      //16 bit MY
      //Se desconhecido, MY: 0xFFFE
      Serial.print(0xFF ,BYTE);
      Serial.print(0xFE ,BYTE);
      //Opcções de envio
      Serial.print(0x00 ,BYTE);
      Serial.print(0x00 ,BYTE);
      //Pacote de mensagem
      Serial.print('[' ,BYTE);
      Serial.print(divisor ,BYTE);
      Serial.print(':' ,BYTE);
      Serial.print(milhar ,BYTE);
      Serial.print(centena ,BYTE);
      Serial.print(dezena ,BYTE);
      Serial.print(unidade ,BYTE);
      Serial.print(']' ,BYTE);
      //Soma do checksum
      long sum = 0x10 +
                 address64bits[0] +
                 address64bits[1] +
                 address64bits[2] +
                 address64bits[3] +
                 address64bits[4] +
                 address64bits[5] +
                 address64bits[6] +
                 address64bits[7] +
                 0xFF + 0xFE +
                 '[' + divisor + ':' +
                 milhar + centena + dezena + unidade + ']';
                 
      Serial.print(0xFF - (sum & 0xFF) ,BYTE);
  }
 
  if (!typeTransmission)
  {
      byte valueHighBit = value >> 8 & 0xFF;
      byte valueLowBit  = value & 0xFF;
     
      //Inicializa pacote API
      //0x7E inicia pacote
      Serial.print(0x7E ,BYTE);
      //Tamanho pacote MSB
      Serial.print(0x00 ,BYTE);
      //Tamanho pacote LSB
      Serial.print(0x14 ,BYTE);
      //Frame ID (0x10: transmissão informação)
      Serial.print(0x10 ,BYTE);
      //Sem retorno de resposta
      Serial.print(0x00 ,BYTE);
      //64 bits address
      Serial.print(address64bits[0] ,BYTE);
      Serial.print(address64bits[1] ,BYTE);
      Serial.print(address64bits[2] ,BYTE);
      Serial.print(address64bits[3] ,BYTE);
      Serial.print(address64bits[4] ,BYTE);
      Serial.print(address64bits[5] ,BYTE);
      Serial.print(address64bits[6] ,BYTE);
      Serial.print(address64bits[7] ,BYTE);
      //16 bit MY
      //Se desconhecido, MY: 0xFFFE
      Serial.print(0xFF ,BYTE);
      Serial.print(0xFE ,BYTE);
      //Opcções de envio
      Serial.print(0x00 ,BYTE);
      Serial.print(0x00 ,BYTE);
      //Pacote de mensagem
      Serial.print('[' ,BYTE);
      Serial.print(divisor ,BYTE);
      Serial.print(':' ,BYTE);
      Serial.print(valueHighBit ,BYTE);
      Serial.print(valueLowBit ,BYTE);

      Serial.print(']' ,BYTE);
      //Soma do checksum
      long sum = 0x10 +
                 address64bits[0] +
                 address64bits[1] +
                 address64bits[2] +
                 address64bits[3] +
                 address64bits[4] +
                 address64bits[5] +
                 address64bits[6] +
                 address64bits[7] +
                 0xFF + 0xFE +
                 '[' + divisor + ':' +
                 valueHighBit + valueLowBit + ']';
                 
      Serial.print(0xFF - (sum & 0xFF) ,BYTE);     
  }
 
      //digitalWrite(8, HIGH);
      //delay(latency_ms);
      //digitalWrite(8, LOW);

Kotch

Bele, preciso ir, amanha tenho que "pular" cedo, depois do serviço dou uma olhada no seu codigo e a noite posto alguma cosia aki!
[]'s

kotch

8)
????????????????????


Go Up