main.c

#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include <unistd.h> // For sleep/usleep (remove for embedded)

#include "motor_control.h"
#include "sensor.h"
#include "measurement.h"
#include "display.h"
#include "system_config.h"

// System state structure
typedef struct {
    motor_control_t motor;
    sensor_t sensor;
    measurement_t measurement;
    display_t display;
    
    uint32_t system_time;       // System time in clock cycles
    bool system_running;
    bool scanning_complete;
    bool measurement_ready;
} system_state_t;

// Initialize system
void system_init(system_state_t *sys) {
    if (sys == NULL) return;
    
    // Initialize all subsystems
    motor_init(&sys->motor);
    sensor_init(&sys->sensor);
    measurement_init(&sys->measurement, CALIBRATION_FACTOR);
    display_init(&sys->display);
    
    // Initialize system state
    sys->system_time = 0;
    sys->system_running = true;
    sys->scanning_complete = false;
    sys->measurement_ready = false;
    
    // Start motor in forward direction
    motor_set_direction(&sys->motor, MOTOR_FORWARD);
    motor_start(&sys->motor);
}

// Main system loop
void system_main_loop(system_state_t *sys) {
    if (sys == NULL) return;
    
    bool object_detected_prev = false;
    
    while (sys->system_running) {
        // Update system time (in real system, this would be from hardware timer)
        sys->system_time += MS_TO_CLOCK_CYCLES(UPDATE_INTERVAL_MS);
        
        // Update motor
        motor_update(&sys->motor);
        uint32_t current_position = motor_get_position(&sys->motor);
        
        // Update sensor
        sensor_update(&sys->sensor, sys->system_time);
        bool object_detected = sensor_is_object_detected(&sys->sensor);
        
        // Handle measurement logic
        if (object_detected && !object_detected_prev) {
            // Object just detected - start measurement
            measurement_start(&sys->measurement, current_position);
            printf("Object detected at position: %u steps\n", current_position);
        } else if (object_detected && object_detected_prev) {
            // Object still detected - update measurement
            measurement_update(&sys->measurement, current_position, true);
        } else if (!object_detected && object_detected_prev) {
            // Object just lost - stop measurement
            measurement_stop(&sys->measurement, current_position);
            sys->measurement_ready = true;
            float length = measurement_get_length_mm(&sys->measurement);
            printf("Measurement complete: %.2f mm\n", length);
        }
        
        object_detected_prev = object_detected;
        
        // Update display
        float current_measurement = 0.0f;
        if (sys->measurement_ready) {
            current_measurement = measurement_get_length_mm(&sys->measurement);
        } else if (sys->measurement.measurement_active) {
            current_measurement = measurement_get_length_mm(&sys->measurement);
        }
        
        display_update(&sys->display, current_measurement, object_detected);
        
        // Check if scanning is complete (motor returned to home)
        if (sys->motor.state == MOTOR_STOP && 
            sys->motor.position == MOTOR_HOME_POSITION &&
            !object_detected) {
            
            if (sys->measurement_ready && !sys->scanning_complete) {
                sys->scanning_complete = true;
                printf("Scanning complete. Final measurement: %.2f mm\n", 
                       measurement_get_length_mm(&sys->measurement));
                
                // Keep displaying result for a few seconds
                // Then reset for next measurement
                // In real system, this could be triggered by a button press
            }
        }
        
        // Check if motor reached end and needs to return
        if (sys->motor.state == MOTOR_BACKWARD && 
            sys->motor.position == MOTOR_HOME_POSITION) {
            // Scanning cycle complete, ready for next measurement
            if (sys->scanning_complete) {
                // Reset for next measurement
                measurement_reset(&sys->measurement);
                sensor_reset(&sys->sensor);
                sys->measurement_ready = false;
                sys->scanning_complete = false;
                
                // Start new scan
                motor_set_direction(&sys->motor, MOTOR_FORWARD);
                motor_start(&sys->motor);
            }
        }
        
        // Simulate delay (in real system, this would be handled by timer interrupts)
        // For embedded systems, remove this and use interrupt-driven timing
        #ifdef SIMULATION
        usleep(UPDATE_INTERVAL_MS * 1000); // Convert ms to microseconds
        #endif
    }
}

// Main entry point
int main(void) {
    system_state_t system;
    
    printf("Object Measurement System Initializing...\n");
    printf("Calibration factor: %.2f steps/mm\n", CALIBRATION_FACTOR);
    
    // Initialize system
    system_init(&system);
    
    printf("System started. Beginning measurement cycle...\n");
    printf("Motor moving forward. Waiting for object detection...\n");
    
    // Run main loop
    system_main_loop(&system);
    
    return 0;
}

// Interrupt handlers (for embedded implementation)
// These would be called by FPGA interrupt controller
void timer_interrupt_handler(void) {
    // Update system timers
    // Trigger periodic updates
}

void sensor_interrupt_handler(void) {
    // Handle sensor state changes
    // Update sensor reading immediately
}