Si je comprends bien, il faudrait presque mettre des plaques métalliques de chaque côté du pilulier qu'on voudrait lire pour ne pas lire le -1 ou le +1?
c'est à envisager. comme tout ce qui concerne des ondes, c'est compliqué. faut tester
il y a peut-être des lecteurs avec antennes directionnelles
Il faut tester la encore pour savoir si cette solution est bonne ou pas
oui - il faut explorer il y a des théories aussi sur les guides d'onde
Je vais regarder si des vidéos ou des expériences (autour de la RFID) ont été mené et voir les différents résultats
Et si au lieu de bloquer "en permanence" on venait bloquer les ondes que lorsque le pilulier a fini d'être analyser, et avec un vérin on fait tomber un bloc (lecteur + "bloqueur d'onde")
Commencez par trouver une antenne, sortez un pilulier rempli de la chaîne et testez la lecture depuis différentes positions (dessus, côté, plus ou moins proche). Ensuite approchez d'autres piluliers pour voir ce qu'il se passe et testez avec des obstacles pour voir ce que ça donne.
ensuite installez la position qui donnait le meilleur résultat sur la chaîne
Avec le lecteur que nous avons où nous faisons la lecture manuellement les tests ont donnée que la lecture par derrière le rack était la plus précise
A voir si avec cette antenne la, les résultats donneront pareil
il n'y a pas moyen de le faire par dessous ? (une découpe dans le métal, avec un cache en plastique/plexi, sous les bandes de déplacement?)
Le constructeur du poste d'analyse, on une option pour ajouter à tous moments un lecteur haute fréquence, et pour faciliter cette installation, en dessous du pilulier qui se fait analyser, dans le tapis il y a un trou déjà prévu pour pouvoir encastrer ce lecteur.
Et au vu de la teille de notre différents lecteur aucuns ne pouvaient rentrer dans ce petit espace donc aucun test n'a été réalisé par le dessous au moment où le rack avance directement sur le tapis, à tester
ok
J'ai pu me procurer le kit de Texas Instrument qui est livré avec 4 puces différentes dont deux qui ressemblent à celles de votre première photo
Quand j'aurais un peu de temps je ferai un test.
Je vais regarder pour pouvoir moi aussi me procurer ce kit, si vous souhaitiez faire des essais, je peux si vous le souhaitez vous envoyer des puces pour faire des essais
Je vous remercie encore pour votre aide!
Pour faire fonctionner ce lecteur, il faut le relier à un port USB, mais pas besoin d'Arduino?
il y a soi disant un soft proposé avec la carte d'évaluation mais c'est pour Windows et une vieille version, pas sûr que ça fonctionne avec les OS modernes (drivers série non signé).
j'ai des tags qui sont fournis avec le kit donc je peux tester. Avec cette antenne il "voit" les petit tags à 7/8cm et le gros tags rond à 15cm. Je sais qu'il les voit car une LED verte s'allume sur le module quand un N° de série correct est détecté. Je n'ai pas encore réussi à configurer le port série correctement pour recevoir le flux cependant
En pratique il ne faudrait que le module DIL RI-STU-MRD2
à intégrer avec une antenne externe que vous placeriez où vous voulez et quelques composants à rajouter autour de la carte, ce qui permet d'avoir son propre design.
EDIT: je n'arrivais pas à communiquer avec le module parce que j'avais branché sur Serial3 sur mon Arduino Mega et je lisais sur Serial1 dans le code.... grrr...
bref - ça fonctionne tout seul. je reçois un byte stream et je peux envoyer des commandes.
d'un point de vue distance ça a l'air de fonctionner raisonnablement si on est à moins de 5/6 cm. Je ne suis pas en environnement électromagnétique bruité cependant.
Pour mémoire, voici le bout de code de test que j'ai écrit:
// © J-M-L For Arduino Forum.
//
// sample code for MRD2EVM (using Microreader RI-STU-MRD2) on Arduino MEGA
// Evaluation kit: https://www.ti.com/tool/MRD2EVM
// user guide: https://www.ti.com/lit/ug/scbu050a/scbu050a.pdf
// Technical documentation https://www.ti.com/lit/ug/scbu049/scbu049.pdf
// POWER MODULE THROUGH USB
// POWER ARDUINO THROUGH USB
// SERIAL CONSOLE OPEN AT 115200 BAUDS
// MRD2EVM switches: CRDM is ON, WLS and RDEN are OFF
// MRD2EVM OKT (29) -> Mega pin 9
// MRD2EVM RXD (5) -> Mega Serial 3 Tx3 (14)
// MRD2EVM TXD (6) -> Mega Serial 3 Rx3 (15)
// MRD2EVM GND (25) -> Mega GND
#define mrd2evm Serial3
const uint8_t oktPin = 9; // Module's pin 29 -> Mega pin 9
const uint8_t cmdGetHardwareType[] = {0x01, 0x02, 0x83, 0x02, 0x83}; // answer 2 bytes: Hardware Type Major, Minor
const uint8_t cmdGetProtocolVersion[] = {0x01, 0x02, 0x83, 0x01, 0x80}; // answer 2 bytes: Protocol Type Major, Minor
const uint8_t cmdGetSerialNumber[] = {0x01, 0x02, 0x83, 0x03, 0x82}; // answer 2x4 bytes: MSP430 Wafer Lot and Position
const uint8_t cmdGetOKTSignalTiming[] = {0x01, 0x03, 0x83, 0x45, 0xFF, 0x3A}; // answer 1 byte: duration in hex ms (0x3C = 60ms)
const uint8_t maxAnswerSize = 100;
uint8_t answerBuffer[maxAnswerSize];
enum t_answerStatus : uint8_t {ANSWER_UNKNOWN, ANSWER_OK, ANSWER_TOO_LONG_FOR_BUFFER, ANSWER_TIMEOUT, ANSWER_BAD_CRC};
enum t_protocolStatus : uint8_t {STARTBYTE, LENGTHBYTE, DATABYTE, CRCBYTE};
void printHexByte(uint8_t b)
{
if (b < 0x10) Serial.write('0');
Serial.print(b, HEX);
Serial.write(' ');
}
t_answerStatus getAnswer(uint8_t* payload, uint8_t& bufferSize, const uint32_t timeout, bool verbose = false)
{
t_answerStatus answer = ANSWER_UNKNOWN;
t_protocolStatus currentState = STARTBYTE ;
uint32_t t0 = millis();
uint8_t answerLength = 0;
uint16_t answerPos = 0;
uint8_t crc = 0;
memset(answerBuffer, 0, bufferSize);
if (verbose) Serial.println();
while ((answer != ANSWER_OK) && (answer != ANSWER_BAD_CRC) && (millis() - t0 < timeout)) {
if (mrd2evm.peek() != -1) { // got something pending
uint8_t received = mrd2evm.read(); // LSB
if (verbose) {
Serial.write('\t'); Serial.print(currentState); Serial.print(F("\t0x")); printHexByte(received); Serial.println();
}
switch (currentState) {
case STARTBYTE: if (received == 0x01) currentState = LENGTHBYTE; break;
case LENGTHBYTE: crc ^= received; answerLength = received; currentState = DATABYTE; break;
case DATABYTE:
crc ^= received;
if (answerPos < bufferSize)
payload[answerPos++] = received;
else
answer = ANSWER_TOO_LONG_FOR_BUFFER;
if (answerPos >= answerLength) currentState = CRCBYTE;
break;
case CRCBYTE:
bufferSize = answerLength;
if (answer != ANSWER_TOO_LONG_FOR_BUFFER) answer = (crc == received) ? ANSWER_OK : ANSWER_BAD_CRC;
break;
} // end switch
} // end peek
} // end while
if (answer == ANSWER_UNKNOWN) answer = ANSWER_TIMEOUT;
return answer;
}
uint8_t awaitAnswer(const uint32_t timeout, byte verboseLevel = 0)
{
uint8_t answerSize = maxAnswerSize; // don't forget to initialize with maxSize
t_answerStatus status = getAnswer(answerBuffer, answerSize, timeout, verboseLevel >= 2);
if (verboseLevel)
switch (status) {
case ANSWER_OK:
for (uint8_t i = 0; i < answerSize; i++) {
Serial.print(("0x"));
if (answerBuffer[i] < 0x10) Serial.write('0');
Serial.print(answerBuffer[i], HEX);
if (i < answerSize - 1) Serial.write(' ');
}
Serial.write('\n');
break;
case ANSWER_TOO_LONG_FOR_BUFFER:
Serial.print(F("Answer was too long for buffer : ")); Serial.println(answerSize);
break;
case ANSWER_TIMEOUT:
Serial.println(F("Answer timed out"));
break;
case ANSWER_BAD_CRC:
Serial.print(F("Got ")); Serial.print(answerSize); Serial.println(F(" data bytes but CRC was incorrect"));
break;
case ANSWER_UNKNOWN:
default:
Serial.println(F("WTF??"));
break;
}
return status == ANSWER_OK ? answerSize : 0;
}
void information()
{
Serial.println(F("*** Testing MRD2EVM ***"));
delay(1000);
Serial.print(F("Hardware Type\t-> "));
mrd2evm.write(cmdGetHardwareType, sizeof cmdGetHardwareType);
awaitAnswer(3000, 1);
Serial.print(F("Protocol\t-> "));
mrd2evm.write(cmdGetProtocolVersion, sizeof cmdGetProtocolVersion);
awaitAnswer(3000, 1);
Serial.print(F("Serial Number\t-> "));
mrd2evm.write(cmdGetSerialNumber, sizeof cmdGetSerialNumber);
awaitAnswer(3000, 1);
Serial.print(F("OKT Signal ∆t\t-> "));
mrd2evm.write(cmdGetOKTSignalTiming, sizeof cmdGetOKTSignalTiming);
awaitAnswer(3000, 1);
}
void setup() {
pinMode(oktPin, INPUT);
Serial.begin(115200);
mrd2evm.begin(9600);
information();
}
void loop() {
if (digitalRead(oktPin) == HIGH) {
uint8_t answerSize = awaitAnswer(1000);
if (answerSize) {
for (uint8_t i = 0; i < answerSize; i++) {
Serial.print(("0x"));
if (answerBuffer[i] < 0x10) Serial.write('0');
Serial.print(answerBuffer[i], HEX);
if (i < answerSize - 1) Serial.write(' ');
}
Serial.write('\n');
}
while (digitalRead(oktPin) == HIGH); // await end of signal
}
}
Fonctionne sur MEGA (pas testé avec Software Serial, ça devrait aller car 9600 bauds par défaut)
Connexions / configuration expliquées dans le code
- POWER MODULE THROUGH USB
- POWER ARDUINO THROUGH USB
- SERIAL CONSOLE OPEN AT 115200 BAUDS
- MRD2EVM switches: CRDM is ON, WLS and RDEN are OFF
- MRD2EVM OKT (29) -> Mega pin 9
- MRD2EVM RXD (5) -> Mega Serial 3 Tx3 (14)
- MRD2EVM TXD (6) -> Mega Serial 3 Rx3 (15)
- MRD2EVM GND (25) -> Mega GND
Il y a un petit switch à basculer sur le lecteur pour passer en mode lecture continue (CRDM).
Notez que la doc dit
If the CRDM pin is active, the response is sent to the serial port, but when a USB connection is established the response is sent to the USB port
Donc il ne faut sans doute pas établir une connexion USB. J'ai juste alimenté le module par USB depuis un vieux chargeur d'iPod.
Quand j'allume le tout, je vois dans le moniteur série (à 115200 bauds)
[color=purple]
*** Testing MRD2EVM ***
Hardware Type -> 0x01 0x00
Protocol -> 0x01 0x00
Serial Number -> 0xA3 0x0A 0x82 0x6E 0xZZ 0xZZ 0xZZ 0xZZ [color=green]([i]changé[/i])[/color]
OKT Signal ∆t -> 0x3C
[/color]
et si j'approche les différents petits badges du kit je vois leur payload
[color=purple]
0x0C 0x32 0x06 0x4C 0x1A 0x00 0x00 0x00 0x00
0x0C 0x32 0x06 0x3A 0x7C 0x00 0x00 0x00 0x00
0x0C 0x09 0x23 0x42 0x4E 0x58 0x89 0x12 0x07
0x1E 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x04
0x0C 0x0F 0x6D 0x58 0x1C 0x30 0x89 0x12 0x07
[/color]
je pense que ça contient des octets de status ainsi que l'ID de la carte, j'ai pas creusé mais la séquence semble totalement déterministe (les mêmes octets quand je présente le même tag).
je vous laisse explorer si vous trouvez ce module (il n'a pas l'air tout jeune, il ya peut être mieux)
Merci pour votre temps et vos explications, il y a des points que je comprends pas trop encore mais je vais essayer de comprendre en détail
Dans un premier temps nous allons faire les tests haute fréquence avec le prêt d'un lecteur haute fréquence de notre fournisseur, pour dans l'avenir (peut-être basculé en HF)
Et ensuite je vais regarder si je trouve d'autres modules "plus jeune" comme vous dites, et sinon je testerais celui-ci
Je vous tiens au courant de l'évolution
J'ai aussi une autre question :
Quand vous lisez un tag vous avez comme ID : 0x0C 0x32 0x06 0x4C 0x1A 0x00 0x00 0x00 0x
Alors que lorsque nous lisons ne tag nous avons quelque chose du style de : O000603077038129
Comment peut-on arriver à ca?
Et est-ce qu'il serait possible d'avoir une photo de votre montage pour voir comment le module est installé/câblé
Salut
je n'ai plus la carte (cf MP) mais ce n'était pas sorcier au niveau câblage:
Pour l'affichage du N° de série, c'est cette partie du code:
for (uint8_t i = 0; i < answerSize; i++) {
Serial.print(("0x"));
if (answerBuffer[i] < 0x10) Serial.write('0');
Serial.print(answerBuffer[i], HEX);
if (i < answerSize - 1) Serial.write(' ');
}
il y a answerSize octets de la réponse qui sont dans answerBuffer[], il suffit de les lire et afficher dans l'ordre que vous voulez (de droite à gauche ou gauche à droite, avec un 0x devant ou pas, avec des espaces ou pas).
Concernent l'Arduino, j'ai pris une MEGA car elle dispose de plusieurs ports série matériels et donc c'est plus robuste mais je pense que ça fonctionnera avec un Arduino Uno en utilisant SoftwareSerial.
La modification du code est minime, Il faudrait enlever#define mrd2evm Serial3et le remplacer par
#include <SoftwareSerial.h>
SoftwareSerial mrd2evm(2, 3);
et bien sûr pour le branchement connecter la pin 2 (Rx) à la pin 6 (Tx) du module (UNO Tx) et la pin 3 (Uno Tx) à la pin 5 (Rx) du module.
Il faut se brancher sur les 4 mêmes broches et câbler aussi le +5 V? Du moins d'après la doc?