Salve a tutti,
possiedo un Ardu Ethernet e desidero controllare wireless un relè che si trova a circo 40-50mt dall'arduino.
Ho sentito parlare dei dispositivi Xbee ecc... mi sapreste indicare quale Hardware acquistare (shield moduli ecc) cosi da poter controllare il relè senza cavi?
è possibile dallo stesso Arduino, con l'apposito hardware, comandare diversi relè wireless collocati in diverse posizioni ?

Nessuno sa darmi una dritta?

Preferirei non dover aprire il telecomando e modificarne le saldature...
vorrei piu che altro capire come riportare la sequenza programmata tramite quei 10 pin (nel telecomando che possiedo), nel moduli RF in commercio. Come posso ricalcare quella sequenza, nella programmazione dell'ardu?

Salve,
in auto, come la maggior parte di noi credo, ho un telecomando per l'apertura del cancello di casa.
Vorrei, se esiste, acquistare un modulo per il mio ardu ethernet che faccia la stessa identica cosa (devo impiegare il tutto per un progetto universitario).
Il telecomando che possiedo, l'ho aperto, e ho visto che viene programmato tramite 10 piccoli interruttori che possono essere posti in 2 diversi stati.
Eventualmente, vorrei poter con lo stesso modulo attivare anche le luci del giardino che vengono pilotate dallo stesso telecomando che ho in auto (dove ci sono appunto 2 diversi interruttori, uno per il cancello, uno per le luci).
Sapreste indicarmi un modulo, possibilmente economico, che mi permetta di fare ciò?
Di cosa necessiterei ulteiormente per il mio scopo?
Vi ringrazio anticipatamente

Mi pronuncio nuovamente su questo post, in quanto un ulteriore problema è comparso:
se tento di mandare le seriale veloce (da ardu a pc) , pur cambiando il valore baud sul serial monitor e sul codice, l'output della stringa del seriale è illeggibile, in quanto compaiono caratteri assurdi.
Se tento invece di velocizzare la serial da RFID a ARDU, non funziona piu nulla, infatti sul datasheet del RFId è ben scritto che non più lavorare a baud maggiori do 9600.
Sapreste spiegarmi questo fenomeno e come funzionano le velocità relative alle seriali (software o hardware che esse siano)?
Ho notato poi che se non metto un delay(100) nella fase in cui acquisisco ogni singolo bit da seriale e lo immagazzino in un vettore di char, mi ritrovo nello stesso vettore dei caratteri casuali, o comunque, non quelli letti dall'rfid!
Da che cosa potrebbe essere causato tutto ciò?

La comunicazione seriale tra Rfid e Ardu tramite la Software Serial deve essere a 9600 baud, perché le specifiche del lettore questo prevedono!
Dunque, come potrei ovviare al problema della sincro?
Prima di fare il primo rfidReader.read(), dovrei controllare i byte in attesa di lettura con rfidReader.available() > 0 ?

cosa intendi per veloci?non è che si riempie il buffer della seriale? In oltre è normale che la prima lettura in assoluto sia errta se inizia prima del loop di arduino.
Infine, quando dici di aver aumentato il baudrate e di aver letto solo roba starna, sicuro di averlo aumentato solo alla comunicazione con il PC e non anche alla comunicazione via seriale (quello è il classico output da baudrate troppo alto, invece se si imposta troppo basso in ricezione di solito non si ha nulla)

Che significa scusa che la lettura inizia prima del Loop di Arduino?! a me non sembra affatto che sia cos', ogni rfidReader.read() avviene all'interno del Loop di Arduino.
Non credo che ci sia qualcosa di sbagliato lì

Il carattere di inizio sequenza è il 2! Il 3 invece chiude la sequenza!
Ciò che non capisco è come mai viene acquisito il carattere ascii 255 per primo (oltretutto da dove esce?!) se il ciclo inizia la lettura SOLO non appena viene inviato il carattere 2 di inizio sequenza!
Guardando l'algoritmo noterete che l'ho predisposto per leggere tutte e 14 le cifre da seriale, ma inizia ad acquisirle SOLO nel caso in cui viene letta le prima, il 2 , caratterizzante l'inizio della sequenza.
Ciò che poi stampo poi sono le SOLE 10 cifre che dovrebbero rappresentare la seq dei caratteri ascii.
Dopodichè ne ometto i primi 2 (perchè sono come già dette trascurabili) e stampo solo i restanti 8, che , se convertiti da HEX all'equivalente DEC, sono proprio il numero seriale (int) stampato all'esterno del tag letto! (o perlomeno, dovrebbe essere)

Ho suddiviso il codice in funzioni più semplici, fatto stampe di debug ovunque, cambiato la modalità di conservazione dei dati seriali (cambiando tipo dato e struttura) ma niente da fare... il grosso dubbio che ho è il fatto che quel bit "strano" scompare solo quando faccio sovrapporre due letture seriali veloci, altrimenti permane in ogni caso...

Niente da fare, purtroppo non dipende da quello... ho provato e mi ritrovo nella stessa situazione di prima..

Niente da fare...  con "Serial.begin(115200);" da seriale ho questa stampa:
þþÿþþþÿþÿ‡$Bà¥W1;ÁP($2®¹”¢Ê)Šª4–Ã`)(I
²$% %ü

(ovviamente dopo avere modificato anche sul serial monitor la rispettiva velocità)

Leggendo da seriale, il risultato è:


0) - Byte: 255 -> Integer: 255   [IGNORATO]
1) - Byte: 51 -> Integer: 3   [IGNORATO]
2) - Byte: 67 -> Integer: 12
3) - Byte: 48 -> Integer: 0
4) - Byte: 48 -> Integer: 0
5) - Byte: 67 -> Integer: 12
6) - Byte: 69 -> Integer: 14
7) - Byte: 55 -> Integer: 7
- Byte: 53 -> Integer: 5
9) - Byte: 52 -> Integer: 4
10) - Byte: 67 -> Integer: 12   [CHECKSUM]
11) - Byte: 67 -> Integer: 12   [CHECKSUM]
ÿ3C00CE754  <<<------------------------------------------------------------------------      ???
Card INVALID
cardNum:                                                    <<------- non avviene la stampa del vettore caratteri "cardNum"
x) HEX: C00CE754
y) DEC: 3222071124
C - 0 - 0 - C - E - 7 - 5 - 4 -                             <<---- Codice HEX relativo alla card

Il problema è quella ÿ (indicata dalla freccia) che si trova in testa al codice. Non si sà da dove venga fuori! è assurdo, o fatto milioni di prove!
Oltretutto, la sua presenza(della Y) crea un successivo errore nella stampa del codice HEX relativo alla card, infatti la 'C' che si  trova in testa alla sequanza di caratteri, dovrebbe trovarsi in coda!
La ÿ viene fuori da quel byte : 255 presente nel codice soprastante, che ha origine ignota... non so davvero da dove possa provenire quel byte!
Cosa ancor più sconvolgente è che , se faccio leggere al lettore Rfid velocemente lo stesso TAG senza dargli tempo di stampare sulla seriale la prima serie, il risultato è il seguente:

0) - Byte: 255 -> Integer: 255   [IGNORATO]
1) - Byte: 51 -> Integer: 3   [IGNORATO]
2) - Byte: 67 -> Integer: 12
3) - Byte: 48 -> Integer: 0
4) - Byte: 48 -> Integer: 0
5) - Byte: 67 -> Integer: 12
6) - Byte: 69 -> Integer: 14
7) - Byte: 55 -> Integer: 7
- Byte: 53 -> Integer: 5
9) - Byte: 52 -> Integer: 4
10) - Byte: 67 -> Integer: 12   [CHECKSUM]
11) - Byte: 67 -> Integer: 12   [CHECKSUM]
ÿ3C00CE754
Card INVALID
cardNum:                                               <<------- non avviene la stampa del vettore caratteri "cardNum" !?!?
x) HEX: C00CE754
y) DEC: 3222071124
C - 0 - 0 - C - E - 7 - 5 - 4 -                                                        <-- fine stampa prima sequenza
0) - Byte: 51 -> Integer: 3   [IGNORATO]                                 <<----NB è scomparso il byte 255, causa della ÿ !!
1) - Byte: 67 -> Integer: 12   [IGNORATO]                               <<--- ORA RIPORTANO ANCHE I 2 BYTE DA IGNORARE X IL CALCOLO DEL SERIALE
2) - Byte: 48 -> Integer: 0
3) - Byte: 48 -> Integer: 0
4) - Byte: 67 -> Integer: 12
5) - Byte: 69 -> Integer: 14
6) - Byte: 55 -> Integer: 7
7) - Byte: 53 -> Integer: 5
- Byte: 52 -> Integer: 4
9) - Byte: 67 -> Integer: 12
10) - Byte: 67 -> Integer: 12   [CHECKSUM]
11) - Byte: 66 -> Integer: 11   [CHECKSUM]
3C00CE754C
Card INVALID
cardNum:                                                <<------- non avviene la stampa del vettore caratteri "cardNum"   !?!?
x) HEX: 00CE754C
y) DEC: 13530444                                   <<----------È TUTTO ESATTO, PERFINO IL VALORE SERIALE CHE TROVO SCRITTO AL DI FUORI DEL TAG !! (13530444)
0 - 0 - C - E - 7 - 5 - 4 - C -   <<--- è proprio l equivalente HEX di 13530444
TUTTO porta come dovrebbe in questo secondo passaggio!

Non so più davvero a che Santo appellarmi.
Come mai al secondo passaggio tutto va come dovrebbe?!?! come mai è scomparsa la ÿ ??
La stringa cardNum continua a non essere stampata, ma in fin dei conti quello è il male minore...
ho anche provato a fare un flush della seriale, ma niente da fare stesso risultato.
Se do tempo alla seriale di stampare tutti i caratteri, l'algoritmo per ricavare il seriale non funziona, se invece avvicino 2 volte in pochissimo tempo il tag al lettore, senza dar tempo  all'ardu di stampare il tutto a video, nella seconda sequenza tutto sembra andar bene e funzionare a dovere (ma nella prima no).

Temo che il tutto abbia dell'incredibile.
Posto il codice per chiarezza

Code:

// Project 45
#define lockPin 9
//#define speakerPin 9
#define tx 3
#define rx 2
#define unlockLength 2000
#include <SoftwareSerial.h>
SoftwareSerial rfidReader = SoftwareSerial(rx, tx);
int users = 3;
char* cards[] = { // valid cards
"11308547",
"3D00251C27",
"3D0029E6BF",
};
char* names[] = { // cardholder names
"Tom Smith",
"Dick Jones",
"Harry Roberts"
};
void setup() {
pinMode (lockPin, OUTPUT);
//pinMode (speakerPin, OUTPUT);
digitalWrite(lockPin, LOW);
Serial.begin(9600);
rfidReader.begin(9600);
}
void loop()
{
        char cardNum[10]; // array to hold card number
        byte cardBytes[6]; // byte version of card number + checksum
        
        int index=0; // current digit
        byte byteIn=0; // byte read from RFID
        byte lastByte=0; // the last byte read
        byte checksum = 0; // checksum result stored here
        int i=1;
        char x[8];
        unsigned long y=0;
        //Serial.flush();
        //rfidReader.flush();
        if (rfidReader.read()==2)
        {
          // read the RFID reader
                while(index<12)
                { // 12 digits in unique serial number
                        byteIn = rfidReader.read(); // store value in byteIn
                        delay(100);
                        Serial.print(index);
                        Serial.print(") - Byte: ");
                        Serial.print(byteIn);
                        Serial.print(" -> Integer: ");
                        if ((byteIn==1) || (byteIn==2) || (byteIn==10) || (byteIn==13)) {return;}
                        // if STX, ETX, CR or LF break
                        if (index<10) {cardNum[index]=byteIn;} // store first 10 HEX digits only(last 2 are checksum)
                        // convert ascii hex to integer hex value
                        if ((byteIn>='0') && (byteIn<='9'))
                        {
                                byteIn -= '0';
                        }
                        else if ((byteIn>='A') && (byteIn<='F'))
                        {
                                byteIn = (byteIn+10)-'A';
                        }
                        Serial.print(byteIn);
                        if(index==0||index==1)
                          Serial.print("   [IGNORATO]");
                        if(index==10||index==11)
                          Serial.print("   [CHECKSUM]");
                        Serial.println();
                        if ((index & 1) == 1)
                        { // if odd number merge 2 4 bit digits into 8 bit byte
                                cardBytes[index/2]= (byteIn | (lastByte<<4)); // move the last digit 4 bitsleft and add new digit
                                if (index<10) {checksum ^= cardBytes[index/2];} // tot up the checksum value
                        }
                        lastByte=byteIn; // store the last byte read
                        index++; // increment the index
                        if (index==12) {cardNum[10] = '\0';} // if we have reached the end of all digitsadd a null terminator
                }
                //rfidReader.flush();    // togliendo questo commento, al passaggio successivo mantengo l'errore nella stringa
                Serial.println(cardNum); // print the card number
                int cardIndex =checkCard(cardNum); // check if card is valid and return index number
                if(cardIndex>=0 && (cardBytes[5]==checksum))
                { // if card number and checksum are valid
                        Serial.println("Card Validated");
                        Serial.print("User: ");
                        Serial.println(names[cardIndex]); // print the relevant name
                        unlock(); // unlock the door
                        Serial.println();
              }
              else
             {
                        Serial.println("Card INVALID");
                        for(i=1;i<11;i++)
                        {
                          x[i-1]=cardNum[i+1];
                          //Serial.print(x[i-1]);
                          //Serial.println(cardNum[i+1]);
                        }
                        //Serial.print(x);
                        x[i+1]='\0';
                        //Serial.print(x);
                        
                        Serial.print("cardNum: ");
                        Serial.println(cardNum); //<---------------------------------------- !
                        Serial.print("x) HEX: ");
                        Serial.println(x);
                        //char z[]="00AC8E03";
                        //y=strtoul(z,NULL,16);
                        y=strtoul(x,NULL,16);
                        Serial.print("y) DEC: ");
                        Serial.println(y);
                        for(int j=0;j<8;j++)
                        {
                          Serial.print(x[j]);
                          Serial.print(" - ");
                        }
                        Serial.println();
                        //Serial.print("Convertito e': ");
                        //Serial.println(y);
                        //tone(speakerPin, 250, 250);
                        delay(250);
                        //tone(speakerPin, 150, 250);
              }
        }
}
int checkCard(char cardNum[10]) {
for (int x=0; x<=users; x++) { // check all valid cards
if(strcmp(cardNum, cards[x])==0) { // compare with last read card number
return (x); // return index of card number
}
}
return (-1); // negative value indicates no match
}
void unlock() {
//tone(speakerPin, 1000, 500);
digitalWrite(lockPin, HIGH);
delay(unlockLength);
digitalWrite(lockPin, LOW);
delay(unlockLength);
digitalWrite(lockPin, HIGH);
delay(unlockLength);
digitalWrite(lockPin, LOW);
}

ahhahaas, no vabè, era una stringa così, tanto per rendere l'idea!
 

ciao, per prima cosa grazie della dritta.
Credo char x ="qwekn45n5"; si sbagliata... cioè dovrebbe essere char x[] ="qwekn45n5";
i valori conviene sempre leggerli come char o magati per il checksum ecc, farebbe comodo vederli come byte?