Buenos días,
He Buscado por varios días y no encuentro la solución por lo cual acudo a ustedes
Les cuento que tengo el siguiente problema:
Conecto con arduino un lector RFID el cual se pueden ver las especificaciones en el siguiente link :
Logro leer las tarjetas, las muestro por las consolas del pc (monitor serie) pero luego al paso del tiempo deja de funcionar (sin mover nada) y no muestra las lecturas.
He realizado las siguientes pruebas para descartar:
Probe en 2 placas diferentes de Arduino (uno original y otro imitación)
Probe Solo conectando el lector y nada mas a Arduino
Medi la corriente entrante al lector RFID y varia entre lo 34.5mA y 35.5mA
Medi la corriente entre el lector y la antena del RFID lo cual al comienzo mide 5uA y al acercar la tarjeta baja a 3uA, cuando el lector falla la corriente es de 13uA y al acercar la tarjeta baja a 9uA
La alimentación del lector RFID lo realizo desde arduino del pin de 5v y la placa arduino la alimenot mediante USB
Si me pueden dar alguna pista de por que funciona por unos 20 min y luego deja de funcionar
Ademas consultar si el lector debe alimentarse con una corriente menor a 50mA que es lo que entiendo en las especificaciones del link , ¿Cual es la corriente mínima que acepta)
*Como segundo dato adicional comento que me pasa algo muy similar con un lector de huella digital, funciona por unos minutos, luego deja de funcionar, pero por el momento necesito solucionar lo del lector RFID.
Desde ya muchas gracias.
Hi,
Cuando esto ocurre que voltajes tienes? Haz tratado una fuente externa al USB. Puede ser que el computador este degenizando el purrto de USB despues de cierto tiempo. Trata de usar una fuente de energia externa y mira ver si el problema continua.
tauro0221:
Hi,
Cuando esto ocurre que voltajes tienes? Haz tratado una fuente externa al USB. Puede ser que el computador este degenizando el purrto de USB despues de cierto tiempo. Trata de usar una fuente de energia externa y mira ver si el problema continua.
Lo intentare , pero te cuento que compre un transformador el cual tiene voltage regulable , pero realmente no entregaba lo que decía por lo que termine quemando la placa ya que entregaba el doble del voltaje indicado, en este caso se supone que entregaría 9v pero entregaba 18v , por lo que quisiera que me indicaran la manera correcta de medir el amperaje que entrega el transformador ya que no quiero quemar la placa que me queda, cual seria la manera correcta de medir esta, sin tener un circuito conectado.
Tengo un multitester capaz de medir el amperaje , pero la única forma que se es conectándolo a un circuito, lo cual no puedo ya que no quiero arriesgar mas componentes
Hi,
Todo mis projectos que yo hago uso el USB para programar solamente el Arduino. Una vez que lo hago entonces conecto al Arduino a un power supply externo lo que se conoce como 5 Volt DC 2.5 Amp Plug In Wall Mount Power Supply. Este te dara suficiente energia para suplir voltaje al Arduino y los modulos conectados a la tarjeta de Arduino y te digo que nunca he tenido problemas con mis proyectos. Adjunto hay un link para que veas de que te estoy hablando pues no se lo poudes comprar en tu localidad.
Este power supply lo puedes conectar directamente al Arduino. Debes de estar seguro de que dice 5 voltios DC. Los hay de AC tambien.
Dode podria ver las especificaciones para la máximo voltage y amperage de Arduino UNO para la alimentación externa, ya que según tengo entendido el voltage puede variar de 7v a 12V (6V-14V máximo) y en Amperage es de 0.75A a 1.5 A
Moderador: Editado. No repitas lo que se lee arriba
Hi,
El regulador de Arduino usa el AMS1117 5.0 voltios 1 amps y un max de voltage de entrada de 15 volts. Creo que un voltaje de 9 voltios de entrada seria lo mas indicado. El usar un voltaje alto causaria que el regulador se calentara y no tine un heatsink para enfriarlo. El voltaje de entrada pasa atraves de un diodo y va directamente al regulador esto haria que tuviera un perdida de .5 voltios mas la perdida atreves del regulador esto daria un voltaje max mas/menos 4.95. Por lo tanto lo idea seria usar uno de 6 volts DC eso te daria 5.0 voltios. Lo dicho es una promedio pues la salida depende de los componentes usados y por lo tanto estos voltajes pueden variar.
Hablas de que tu arduino deja de mostrar datos pero no pones el código!!
No debes suponer que el código esta bien.
Postea el código usando etiquetas. Lee las Normas del foro para hacerlo correctamente.
Moderador: Editado. No repitas lo que se lee arriba
Adjunto mi Código:
#include <SoftwareSerial.h>
SoftwareSerial RFID(9, 10); // RX and TX
int i;
void setup()
{
RFID.begin(9600); // start serial to RFID reader
Serial.begin(9600); // start serial to PC
Serial.println("FIN SETUP");
}
void loop()
{
RFID.listen();
if (RFID.available() > 0)
{
i = RFID.read();
Serial.println(i);
}
}
Hi,
Para hacer una prueba anadele un delay despues del if statement. Pueder ser que este leyendo el module muy rapido se tranca y deja de funcionar.
if (RFID.available() > 0)
{
i = RFID.read();
Serial.println(i);
}
delay(500);
}
Moderador: Código editado con etiquetas
Moderador: No repitas lo que se lee arriba
Puse el delay en el código y el mismo resultado adema que para cada imprimir cada bit tomaba delay, ejemplo:
25 delay
50 delay
30 delay
y así por cada numero de la tarjeta había que esperar los 500ms
Hi,
Tienes razon pues lo que estaba tratando es de no pedir la informacion y esperar para que el modulo le de tiempo para terminar la informaccion que estaba enviando. Posiblemente puse el delay en el sitio incorrecto. El proposito del delay es prevenir pedir informaccion demaciado rapido que el modulo no puede responder a esa velacidad. Haz una cosa cambia el (RFID.available() > 0){ y lo cambia a if(rfid.available()){ y mira a ver que pasa.
Hola buenas, con los cambios sugeridos el problema persiste sigue funcionando un par de minutos luego deja de leer la tarjeta hasta que dejo el arduino desconectado un par de horas
A ver.. yo miré recién tu hilo porque te estaban respondiendo pero veo que el tema sigue atascado.
En tu pdf del lector dice
Baud Rate 9600（TTL Electricity Level RS232 format）
interface Weigang26 Or TTL Electricity Level RS232 format
O sea tienes niveles TTL en el conector P1 pines
1 TX
2 RX
4 GND
5 +5V
Y obviamente lo tendrás conectado
9, 10); // RX and TX
RFID Arduino
1 9
2 10
GND GND
5V 5V
Es corrrecto?
Yo solo para establecer donde estamos.
Y el código del post#7 es todo tu código?
MI primer código es el único código que tengo.
No tengo conectado el RX a ningún lado
Mis conexiones están asi :
P1
PIN 1 -> 9 ARDUINO
P2
PIN1 -> Antena
PIN2 -> Antena
P3
PIN2 -> 5V ARDUINO
PIN3 -> GND RDUINO
Hi,
No se si estoy equivocado pero si no tienes conectado el RX entonces que espera que pase cuando ejecuta este comando "if (RFID.available() > 0)" . Si no lo tienes conectado que accion espera que el comando haga si no recibes la contestacion del sensor sin el RX conectado.
Conecte
PIN2(P1) al pin 10 de Arduino y el problema persiste, según tengo entendido y corríjanme si no es así, no es necesario tener RX y TX conectado (solo en este caso) ya que solo estoy leyendo información del lector y enviando al arduino y no alrevez
Tu no sabes si la librería no le envia algo o acaso la miraste en profundidad?
Ademas si el RFID no necesitara RX entonces para que lo tiene dispnible?
Igualmente no es la respuesta a tu problema.
EDITO: encontre este tutorial que tiene un código interesante
// (c) Michael Schoeffler 2018, http://www.mschoeffler.de
#include <SoftwareSerial.h>
const int BUFFER_SIZE = 14; // RFID DATA FRAME FORMAT: 1byte head (value: 2), 10byte data (2byte version + 8byte tag), 2byte checksum, 1byte tail (value: 3)
const int DATA_SIZE = 10; // 10byte data (2byte version + 8byte tag)
const int DATA_VERSION_SIZE = 2; // 2byte version (actual meaning of these two bytes may vary)
const int DATA_TAG_SIZE = 8; // 8byte tag
const int CHECKSUM_SIZE = 2; // 2byte checksum
SoftwareSerial ssrfid = SoftwareSerial(9,10);
uint8_t buffer[BUFFER_SIZE]; // used to store an incoming data frame
int buffer_index = 0;
void setup() {
Serial.begin(9600);
ssrfid.begin(9600);
ssrfid.listen();
Serial.println("INIT DONE");
}
void loop() {
if (ssrfid.available() > 0){
bool call_extract_tag = false;
int ssvalue = ssrfid.read(); // read
if (ssvalue == -1) { // no data was read
return;
}
if (ssvalue == 2) { // RDM630/RDM6300 found a tag => tag incoming
buffer_index = 0;
} else if (ssvalue == 3) { // tag has been fully transmitted
call_extract_tag = true; // extract tag at the end of the function call
}
if (buffer_index >= BUFFER_SIZE) { // checking for a buffer overflow (It's very unlikely that an buffer overflow comes up!)
Serial.println("Error: Buffer overflow detected!");
return;
}
buffer[buffer_index++] = ssvalue; // everything is alright => copy current value to buffer
if (call_extract_tag == true) {
if (buffer_index == BUFFER_SIZE) {
unsigned tag = extract_tag();
} else { // something is wrong... start again looking for preamble (value: 2)
buffer_index = 0;
return;
}
}
}
}
unsigned extract_tag() {
uint8_t msg_head = buffer[0];
uint8_t *msg_data = buffer + 1; // 10 byte => data contains 2byte version + 8byte tag
uint8_t *msg_data_version = msg_data;
uint8_t *msg_data_tag = msg_data + 2;
uint8_t *msg_checksum = buffer + 11; // 2 byte
uint8_t msg_tail = buffer[13];
// print message that was sent from RDM630/RDM6300
Serial.println("--------");
Serial.print("Message-Head: ");
Serial.println(msg_head);
Serial.println("Message-Data (HEX): ");
for (int i = 0; i < DATA_VERSION_SIZE; ++i) {
Serial.print(char(msg_data_version[i]));
}
Serial.println(" (version)");
for (int i = 0; i < DATA_TAG_SIZE; ++i) {
Serial.print(char(msg_data_tag[i]));
}
Serial.println(" (tag)");
Serial.print("Message-Checksum (HEX): ");
for (int i = 0; i < CHECKSUM_SIZE; ++i) {
Serial.print(char(msg_checksum[i]));
}
Serial.println("");
Serial.print("Message-Tail: ");
Serial.println(msg_tail);
Serial.println("--");
long tag = hexstr_to_value(msg_data_tag, DATA_TAG_SIZE);
Serial.print("Extracted Tag: ");
Serial.println(tag);
long checksum = 0;
for (int i = 0; i < DATA_SIZE; i+= CHECKSUM_SIZE) {
long val = hexstr_to_value(msg_data + i, CHECKSUM_SIZE);
checksum ^= val;
}
Serial.print("Extracted Checksum (HEX): ");
Serial.print(checksum, HEX);
if (checksum == hexstr_to_value(msg_checksum, CHECKSUM_SIZE)) { // compare calculated checksum to retrieved checksum
Serial.print(" (OK)"); // calculated checksum corresponds to transmitted checksum!
} else {
Serial.print(" (NOT OK)"); // checksums do not match
}
Serial.println("");
Serial.println("--------");
return tag;
}
long hexstr_to_value(char *str, unsigned int length) { // converts a hexadecimal value (encoded as ASCII string) to a numeric value
char* copy = malloc((sizeof(char) * length) + 1);
memcpy(copy, str, sizeof(char) * length);
copy[length] = '\0';
// the variable "copy" is a copy of the parameter "str". "copy" has an additional '\0' element to make sure that "str" is null-terminated.
long value = strtol(copy, NULL, 16); // strtol converts a null-terminated string to a long value
free(copy); // clean up
return value;
}
Sigue sucediendo lo mismo al copiar el código funciona un par de veces y luego deja de funcionar
Adjunto el resultado de la ejecución por si sirve de algo
INIT DONE
--------
Message-Head: 2
Message-Data (HEX):
83 (version)
000E373A (tag)
Message-Checksum (HEX): 80
Message-Tail: 3
--
Extracted Tag: 931642
Extracted Checksum (HEX): 80 (OK)
Bueno yo creo que tu módulo tiene alguna problema. Casi lo puedo afirmar. Nada me dice lo contrario. No encuentro explicación al inconveniente.
Yo igual creería esa hipótesis pero lo raro es que funcione por un rato y luego deje de funcionar.