Tens de descobrir o protocolo de comunicação entre o telefone e o rádio-base

Não é muito fácil fazer a reengenharia caso a comunicação seja analógica

Se for comunicação digital, é mais fácil

Abraços

John, there's a flaw in your sketch

The array caracter was not declared

Olá

O jeito mais fácil de fazer o Arduino se comunicar com a internet é usando um shield Ethernet

Conectas um cabo do teu roteador ao Arduino e pronto

Se usares XBee, tens de escrever um programa no PC para fazer o roteamento XBee-Ethernet

Faz assim:

Code:

#define LEDPIN13 13
#define LEDPIN11 11
#define LEDPIN9  9
#define LEDPIN7  7
#define LEDPIN5  5

void setup() {
    Serial.begin( 9600 );
    pinMode( LEDPIN13, OUTPUT );
    pinMode( LEDPIN11, OUTPUT );
    pinMode( LEDPIN9,  OUTPUT );
    pinMode( LEDPIN7,  OUTPUT );
    pinMode( LEDPIN5,  OUTPUT );
}

void loop() {
    int buffer[ 5 ];
    int pinos[ 5 ] = { LEDPIN13, LEDPIN11, LEDPIN9, LEDPIN7, LEDPIN5 };
    int indice = 0;

    if ( Serial.available() > 0 ) {
        int input = Serial.read();
        if ( input != '0' && input != '1' ) {
            indice = 0;
        } else {
            buffer[ indice++ ] = input;
        }
    }

    if ( indice == 5 ) {
        for ( int i = 0; i < 5; i++ ) {
            if ( buffer[ i ] == '0' ) {
                digitalWrite( pinos[ i ], LOW );
            } else {
                digitalWrite( pinos[ i ], HIGH );
            }
        }
        indice = 0;
    }
}

O JavaScript a seguir tem de estar na tua página PHP ou HTML:

Code:

    document.onload = onLoadHandler();

    var xhr;

    function onLoadHandler() {

        if ( window.ActiveXObject ) {

            xhr = new ActiveXObject( "Microsoft.XMLHTTP" );

        } else if ( window.XMLHttpRequest ) {

            xhr = new XMLHttpRequest();

        } else {

            alert( "Seu navegador nao suporta AJAX" );

        }
    }

    function openSocket(command) {

        xhr.open( "GET", "suaPaginaPHPQueConversaComOArduino.php?command=" + command, true );
        xhr.send();
        xhr.onreadystatechange = function () {

            if ( xhr.readyState == 4 && xhr.status == 204 ) {

                var info = eval( xhr.responseText );

                if ( info.cozinha == 1 ) {

                    // light up the icon for the kitchen
                } else {

                    // turn off the icon
                }
            }
        };
    }

Depois, toda vez que quiseres averiguar o estado da lâmpada da cozinha, deves chamar a função openSocket() e passar como parâmetro a string "status".

Podes verificar a cadeia de caracteres vinda do cliente e, se ela contiver "status", tu envias de volta um JSON com a informação que desejas:

Code:

//
// código Arduino
//
void loop(){

  EthernetClient client = server.available();

  if (client) {

    while (client.connected()) {

      if (client.available()) {

        char c = client.read();

        //read char by char HTTP request
        if (readString.length() < 100) {

          //store characters to string
          readString += c;
        }

        //if HTTP request has ended
        if (c == '\n') {

           //now output HTML data header
          if(readString.indexOf('?') >=0) { //don't send new page

            client.println("HTTP/1.1 204 Zoomkat");

          }

          ///////////////////// control arduino pin
          if(readString.indexOf("on") >0)//checks for on
          {
            digitalWrite(13, HIGH);    // set pin 4 high
          }

          if(readString.indexOf("off") >0)//checks for off
          {
            digitalWrite(13, LOW);    // set pin 4 low
          }

          if(readString.indexOf("status") > 0) //send JSON
          {
              int luzcoz1 = digitalRead(PINLUZCOZ1) == HIGH? 1: 0;

              client.println("Content-type: application/json");
              client.println();
              client.print("{ cozinha: ");
              client.print(luzcoz1, DEC);
              client.println("}");
          }

          //clearing string for next read
          readString="";

          //stopping client
          client.stop();
        }
      }
    }
  }
}

Coloca o que queres executar dentro do setup() e deixa loop() vazio

Code:

void setup() {
    Serial.begin( 9600 );
    teste( );
}

void loop() { }

void teste() {

    for ( int i = 0; i < 20; i++) {
        Serial.println( i );
        delay( 500 );
    }

}

Ou seja, posso utilizar uma pilha de 9V ou 6 do tipo AA (mínimo) que não terei problemas, correto ?

Correcto

Code:

void data_read() {

    for( int i = 0; i < 12; i++ ) {

        Serial.print( i, DEC );
        Serial.print( ": " );
        Serial.println( EEPROM.read( i ), HEX );

    }

}

Estás a fazer

Code:

       ponteiro_valor &= key;

que é equivalente a

Code:

       ponteiro_valor = ponteiro_valor & key;

mas vê que ponteiro_valor aponta para o início de um vector; digamos que o vector comece na posição de memória 37:

Code:

        +---+---+---+---+---+
valor   | 0 | 0 | 0 | 0 | 0 |
        +---+---+---+---+---+
          ^
          |
         37  38  39  40  41

Se carregarmos a tecla '0' = 0x30 = 48, ponteiro_valor ganhará o valor 37 & 48 = 32, ou seja, vai acabar apontando para fora dos limites do vector.

O que tens que fazer é o seguinte:

Code:

       *ponteiro_valor++ = key;

Assim, vais preencher o vector com o caractere '0' e assim por diante.

E se quiser cortar o o fio do adaptador para ficar apenas com o plugin que liga directamente à placa para poder ligar a um adaptador de pilhas também irá funcionar ?

Sim, mas terás que fornecer mais que 7 volts à placa Arduino

Pode usar

Sem problemas

Por que não usas a função pulseIn() do Arduino, em vez de esperar por um LOW e depois um HIGH?

http://arduino.cc/en/Reference/pulseIn

O problema do pulse in é que bloqueia o programa...

[code snipped]

Ou seja, apesar do timeout, etc... é processamento desperdicado. Além do facto que o pulseIn não garante contagem dum impulso. Basta que o impulso aconteca logo após um timeout e pronto... perdeu-se esse impulso.

Daí que testar o flanco (que é o que se pretende, em vez da duracão do impulso) seja uma melhor solucão. Ainda assim, a minha preferida é a do timer como contador.

Desculpa não ter dado uma vista de olhos ainda acerca de como o configurar. Vou tentar ver isso hoje.

Mas o fato de o pulseIn() pausar o programa é indiferente se o programa depende exclusivamente da detecção do sensor para fazer o que precisa; além do mais, Serial.print()'s e delay()'s também bloqueiam o programa

Se queres algo que realmente execute apesar dos bloqueios no programa, usa interrupções:

http://arduino.cc/en/Reference/AttachInterrupt

Já testou acessar de um IP interno o IP externo? Tipo, de um micro que esteja na rede interna, tentando conectar-se ao IP dinâmico externo?

Não use a porta 80, use 8080, como foi dito pelo Kotch, porque normalmente há firewalls dentro do provedor de acesso (seu Turbonet ou Speedy podem estar atrás de um firewall, isso que eu queria dizer)

Talvez fosse melhor separar o amp das caixas de som, porque senão ficaria assim o circuito:

Code:

                                                                 ,
                                                                /|
                  +------------[--------]------------------[---/ |
                  |            [ Relê 1 ]                  [     |
                  |     +------[--------]------------------[___  |
                  |     |                '<-------------->'    \ |
                  |     |                   Muito  longo        \|
                  |     |         . . .                          '
                  |     |
[-----------] ----o---------
[ Microfone ]     |     |         . . .
[-----------] ----------o---
                  |     |
                  |     |         . . .
                  |     |
                  |     |                   Muito  longo         ,
                  |     |                '<-------------->'     /|
                  +------------[--------]------------------[---/ |
                        |      [ Relê 5 ]                  [     |
                        +------[--------]------------------[___  |
                                                               \ |
                                                                \|
                                                                 '
Os relês são controlados pelo Arduino (não desenhado para não poluir o diagrama)

O cabo muito longo que vai do relê à caixa de som amplificada funcionaria como uma antena, captando todo tipo de ruído

Caso tenha um amp entre o mic e os relês, o sinal que iria do amp às caixas de som seria forte o bastante para se sobrepor ao ruído eletromagnético ambiente. Poderia ser um cabo coaxial, por exemplo, o que diminuiria ainda mais a captação de ruído desse trecho de cabeamento.