Sistema de Asistencia con AS608

Hola gente, es mi primera vez en este foro, y mis conocimientos con Arduino no son realmente grandes, por lo cual pido ayuda o una pequeña guía con un proyecto escolar.
Tengo que presentar un proyecto de titulación en unos cuantos meses, y con mi equipo planeamos hacer un sistema de asistencia, conectado a una base de datos (en este caso, PostgreSQL), esto usando un sensor AS608, un módulo de internet ESP8266, Arduino UNO, entre más sensores que se necesiten. Mi problema aquí, es que no tengo una idea clara de cuáles son los puntos que debemos tocar, cómo o con qué podemos llevar a cabo la subida de datos a Postgre o algún sistema apropiado de bases de datos, agradecería infinitamente si pudiesen ayudarme. De antemano, muchas gracias.

Este es el Lector Dactilar

Y este, es el módulo WiFi

Vaya dilema el de Uds.
Bueno, lo primero es que te pongas a ver y resolver tareas individuales.
Como buen proyecto deberias crear una hoja de ruta, o sea una descripción de las tareas importantes y luego en cada tarea cuales son las subtareas necesarias para que la tarea principal se de por resuelta.
No se que tiene que ver el UNO y el ESP8266, para mi un ESP8266 es mas que suficiente para todo el proyecto pero ya veremos.
El proyecto requiere:

  1. conexión de sensor AS608 a ESP8266 que tmb se conoce como nodemcu porque es uno de los módulos mas conocidos, hay otros.
  2. conexión del nodemcu a WIFI
  3. intercambio de datos entre nodemcu y base de datos residente en un servidor a través de una ip. Eso requiere de otra tarea.
  4. Servidor PotgreSQL que permita el intercambio de datos.
    Creación de las tablas correspondientes.
    Familiarizarse con la creación, borrado, actualización y consulta via SQL.

Tienes trabajo, ve resolviendo y comentando.
Comienza por lo que se sientan mas fuertes como debería ser PostgreSQL porque por algo la eligieron. Resuelvan el Servidor y de ahi continuamos.

Una disculpa por la tardanza en actualizar; ya está hecha la base de datos, y tengo un código simple para intentar detectar el sensor dado que Arduino (pequeño update: ahora usaremos un MEGA) no lo detecta, es el siguiente;

#include <Adafruit_Fingerprint.h>

#if (defined(__AVR__) || defined(ESP8266)) && !defined(__AVR_ATmega2560__)

SoftwareSerial mySerial(0, 1);

#else

#define 

#define mySerial Serial1

#endif

Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);

uint8_t id;

void setup()
{
  Serial.begin(9600);
  while (!Serial);
  delay(100);
  Serial.println("\n\nAS608 Fingerprint sensor registro");

  //enviando datos del sensor al puerto serial
  finger.begin(57600);

  if (finger.verifyPassword()) {
    Serial.println("Sensor AS608 encontrado");
  } else {
    Serial.println("Sensor AS608 no encontrado");
    while (1) { delay(1); }
  }

Serial.println(F("Reading sensor parameters"));
  finger.getParameters();
  Serial.print(F("Status: 0x")); Serial.println(finger.status_reg, HEX);
  Serial.print(F("Sys ID: 0x")); Serial.println(finger.system_id, HEX);
  Serial.print(F("Capacity: ")); Serial.println(finger.capacity);
  Serial.print(F("Security level: ")); Serial.println(finger.security_level);
  Serial.print(F("Device address: ")); Serial.println(finger.device_addr, HEX);
  Serial.print(F("Packet len: ")); Serial.println(finger.packet_len);
  Serial.print(F("Baud rate: ")); Serial.println(finger.baud_rate);
}

Aunque cambie las conexiones sigue dando un error de detección del sensor.

Y en un mega pones SoftwareSerial y encima en pines que ya son Hardware Serial

Faltaría que agregues el esquema de conexiones para tratar de encontrar el problema (aunque me lo imagino).

En el código falta incluir la librería SoftwareSerial (u omitiste copiar líneas).

De todos modos, el código NO usa SoftwareSerial porque está definida una compilación condicional

if (defined(__AVR__) || defined(ESP8266)) && !defined(__AVR_ATmega2560__) 
SoftwareSerial mySerial(0, 1); 
#else
#define mySerial Serial1 
#endif

que dice que si es un chip AVR o ESP8266 y no es un ATmega2560 use SoftwareSerial, sino (o sea es una Mega) use Serial1.

Y Serial1 usa los pines 18 y 19, no los pines 0 y 1.
Seguramente ese es el problema, el lector conectado a pines incorrectos.

Me disculpo enormemente por demorarme tanto, nos centramos en otras cosas pensando que el código de arduino sería un poco menos complejo, ya veo el error...
De antemano, probé diferentes formas y al parecer no fui capaz de hacer una conexión entre el MEGA y el ESP8266, por lo cual me decanté por usar exclusivamente el ESP8266 junto al AS608, como me había comentado Surbyte; aunque proximamente agregaré un pequeño display para mostrar la información.
Tengo actualmente un código un poco simple para la lectura y el envío de datos; el envío se realizará mediante una conexión entre el ESP y PHP intermediario, pero el código me causó un error 301:

//(Hago pequeña aclaración, y pregunta: Mi host está comprado en hostinger.com. ¿Esto podría causar algún problema?) De antemano, agradezco si podrían comentar si hay alguna variable o qué podría estar mal, dado que no puedo encontrar el problema. Linda noche.

#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <ESP8266WiFiMulti.h>
#include <Adafruit_Fingerprint.h>
#include <SoftwareSerial.h>

//CREDENCIALES DE INTERNET
const char* ssid = "WIFI_ESP";
const char* psswrd = "ESP8266_bst";
WiFiClient client;

//DEFINICION DEL AS608 Y VARIABLES REFERIDAS A ÉL
#define FING_RX 14 //D5
#define FING_TX 12 //D6

SoftwareSerial mySerial(FING_RX, FING_TX);

Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);

int FingerID = 0;
uint8_t id;

void setup() {
    Serial.begin(115200);
   
    WiFi.begin(ssid, psswrd);
    Serial.print("\nConectando a..."); Serial.print(ssid);
    while(WiFi.status() != WL_CONNECTED) {
        delay(700);
        Serial.print("/");
    }
    Serial.println("\n\nByteSync - TECH");
    Serial.println("\nConectado correctamente");
    Serial.println("Red: "); Serial.print(ssid);
    Serial.println("\nDireccion IP: "); Serial.print(WiFi.localIP());

    finger.begin(57600);
    Serial.println("\n\n\nDetectando el sensor");
    if (finger.verifyPassword()) {
        Serial.println("AS608 Detectado");
    } else {
        Serial.println("No se detecto el sensor");
        while(1) { delay(1); }
    }

    finger.getTemplateCount();
    Serial.println("El sensor cuenta con... "); Serial.print(finger.getTemplateCount()); Serial.println(" plantillas");
    Serial.println("esperando por una huella valida...");
}

void loop() {

    getFingerprintEnroll();

    FingerID = id;
    
    EnviarDatos(FingerID);

}

void EnviarDatos(int finger) {
    if(WiFi.status() == WL_CONNECTED) {
        HTTPClient http;
        String datos_a_enviar = "fingTemplate" + String(finger);

        http.begin(client, "http://bst-proyecto.com/ESP_Post.php");
        http.addHeader("Content-Type", "application/x-www-form-urlencoded");

        int codigo_respuesta = http.POST(datos_a_enviar);

        if(codigo_respuesta > 0) {
            Serial.println("Codigo HTTP: " + String(codigo_respuesta));
            if(codigo_respuesta == 200) {
                String cuerpo_respuesta = http.getString();
                Serial.println("\nRespuesta del servidor: ");
                Serial.println(cuerpo_respuesta);
            }
        } else {
            Serial.println("\nError enviado POST, codigo: ");
            Serial.println(codigo_respuesta);
        }

        http.end();

    } else {
        Serial.println("Error en la conexion WiFi");
    }

    delay(3000);

}


uint8_t getFingerprintEnroll() {

  int p = -1;
  Serial.println("Esperando una huella para guardar como... #"); Serial.println(id);

  while (p != FINGERPRINT_OK) {
    p = finger.getImage();
    switch (p) {
    case FINGERPRINT_OK:
      Serial.println("Imagen tomada");
      break;
    case FINGERPRINT_NOFINGER:
      Serial.print(".");
      break;
    case FINGERPRINT_PACKETRECIEVEERR:
      Serial.println("Error de comunicacion");
      break;
    case FINGERPRINT_IMAGEFAIL:
      Serial.println("Error con la imagen");
      break;
    default:
      Serial.println("Error desconocido");
      break;
    }
  }

  // OK success!

  p = finger.image2Tz(1);
  switch (p) {
    case FINGERPRINT_OK:
      Serial.println("Imagen convertida");
      break;
    case FINGERPRINT_IMAGEMESS:
      Serial.println("Imagen con movimiento");
      return p;
    case FINGERPRINT_PACKETRECIEVEERR:
      Serial.println("Error de comunicacion");
      return p;
    case FINGERPRINT_FEATUREFAIL:
      Serial.println("No se encontraron caracteristicas dactilares");
      return p;
    case FINGERPRINT_INVALIDIMAGE:
      Serial.println("No se encontraron caracteristicas dactilares");
      return p;
    default:
      Serial.println("Error desconocido");
      return p;
  }

  Serial.println("Retira tu dedo");
  delay(2000);
  p = 0;
  while (p != FINGERPRINT_NOFINGER) {
    p = finger.getImage();
  }
  Serial.print("ID "); Serial.println(id);
  p = -1;
  Serial.println("Coloca de nuevo el mismo dedo");
  while (p != FINGERPRINT_OK) {
    p = finger.getImage();
    switch (p) {
    case FINGERPRINT_OK:
      Serial.println("Imagen tomada");
      break;
    case FINGERPRINT_NOFINGER:
      Serial.print(".");
      break;
    case FINGERPRINT_PACKETRECIEVEERR:
      Serial.println("Error de comunicacion");
      break;
    case FINGERPRINT_IMAGEFAIL:
      Serial.println("Error de imagen");
      break;
    default:
      Serial.println("Error desconocido");
      break;
    }
  }

  // OK success!

  p = finger.image2Tz(2);
  switch (p) {
    case FINGERPRINT_OK:
      Serial.println("Imagen convertida");
      break;
    case FINGERPRINT_IMAGEMESS:
      Serial.println("Imagen con movimiento");
      return p;
    case FINGERPRINT_PACKETRECIEVEERR:
      Serial.println("Error de comunicacion");
      return p;
    case FINGERPRINT_FEATUREFAIL:
      Serial.println("No se encontraron caracteristicas dactilares");
      return p;
    case FINGERPRINT_INVALIDIMAGE:
      Serial.println("No se encontraron caracteristicas dactilares");
      return p;
    default:
      Serial.println("Error desconocido");
      return p;
  }

  // OK converted!
  Serial.print("Creando modelo para... #");  Serial.println(id);

  p = finger.createModel();
  if (p == FINGERPRINT_OK) {
    Serial.println("Coincidencia encontrada");
  } else if (p == FINGERPRINT_PACKETRECIEVEERR) {
    Serial.println("Error de comunicacion");
    return p;
  } else if (p == FINGERPRINT_ENROLLMISMATCH) {
    Serial.println("No se encontro coincidencia");
    return p;
  } else {
    Serial.println("Error desconocida");
    return p;
  }

  Serial.print("ID "); Serial.println(id);
  p = finger.storeModel(id);
  if (p == FINGERPRINT_OK) {
    Serial.println("Huella almacenada");
  } else if (p == FINGERPRINT_PACKETRECIEVEERR) {
    Serial.println("Error de comunicacion");
    return p;
  } else if (p == FINGERPRINT_BADLOCATION) {
    Serial.println("No se puede almacenar en esa ubicacion");
    return p;
  } else if (p == FINGERPRINT_FLASHERR) {
    Serial.println("Error escribiendo a la memoria");
    return p;
  } else {
    Serial.println("Error desconocido");
    return p;
  }

  return true;

}

Y al momento de ejecutar el código pasa lo siguiente:

EDIT:
Olvidé adjuntar el significado del error 301: Indica que el host ha sido capaz de comunicarse con el servidor, pero que el recurso solicitado ha sido movido a otra dirección permanentemente

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.