sensor.c

#include "sensor.h"
#include "system_config.h"
#include <string.h>

// Hardware abstraction for reading sensor pin
// In real implementation, this would read from FPGA GPIO
static bool read_sensor_pin(void) {
    // Placeholder: In real hardware, this would be:
    // return gpio_read(SENSOR_PIN);
    
    // For simulation/testing, return a mock value
    // In actual implementation, replace with hardware read
    return false;
}

// Initialize sensor
void sensor_init(sensor_t *sensor) {
    if (sensor == NULL) return;
    
    sensor->state = SENSOR_NO_OBJECT;
    sensor->current_reading = false;
    sensor->last_reading = false;
    sensor->detection_start_time = 0;
    sensor->detection_end_time = 0;
    sensor->object_present = false;
    sensor->debounce_counter = 0;
}

// Read sensor input (digital HIGH/LOW)
bool sensor_read(sensor_t *sensor) {
    if (sensor == NULL) return false;
    
    // Read hardware pin
    sensor->last_reading = sensor->current_reading;
    sensor->current_reading = read_sensor_pin();
    
    return sensor->current_reading;
}

// Check if object is detected (with debouncing)
bool sensor_is_object_detected(sensor_t *sensor) {
    if (sensor == NULL) return false;
    
    // Read current sensor state
    sensor_read(sensor);
    
    // Simple debouncing logic
    if (sensor->current_reading != sensor->last_reading) {
        sensor->debounce_counter = 0;
    } else {
        sensor->debounce_counter++;
    }
    
    // If reading is stable for debounce time, update state
    uint32_t debounce_threshold = MS_TO_CLOCK_CYCLES(SENSOR_DEBOUNCE_TIME_MS);
    if (sensor->debounce_counter > debounce_threshold) {
        sensor->object_present = sensor->current_reading;
    }
    
    return sensor->object_present;
}

// Update sensor state
void sensor_update(sensor_t *sensor, uint32_t current_time) {
    if (sensor == NULL) return;
    
    bool detected = sensor_is_object_detected(sensor);
    
    // State machine for sensor detection
    switch (sensor->state) {
        case SENSOR_NO_OBJECT:
            if (detected) {
                sensor->state = SENSOR_OBJECT_DETECTED;
                sensor->detection_start_time = current_time;
            }
            break;
            
        case SENSOR_OBJECT_DETECTED:
            if (!detected) {
                sensor->state = SENSOR_NO_OBJECT;
                sensor->detection_end_time = current_time;
            } else {
                sensor->state = SENSOR_STABLE;
            }
            break;
            
        case SENSOR_STABLE:
            if (!detected) {
                sensor->state = SENSOR_NO_OBJECT;
                sensor->detection_end_time = current_time;
            }
            break;
    }
}

// Get sensor state
sensor_state_t sensor_get_state(sensor_t *sensor) {
    if (sensor == NULL) return SENSOR_NO_OBJECT;
    return sensor->state;
}

// Reset sensor detection timestamps
void sensor_reset(sensor_t *sensor) {
    if (sensor == NULL) return;
    
    sensor->detection_start_time = 0;
    sensor->detection_end_time = 0;
    sensor->debounce_counter = 0;
    sensor->state = SENSOR_NO_OBJECT;
}