ObjectMeasurementProject/measurement.c at main · Radifical/ObjectMeasurementProject · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
#include "measurement.h"
#include "system_config.h"
#include <string.h>

// Initialize measurement system
void measurement_init(measurement_t *measurement, float calibration_factor) {
    if (measurement == NULL) return;

    measurement->start_position = 0;
    measurement->end_position = 0;
    measurement->length_steps = 0;
    measurement->length_mm = 0.0f;
    measurement->measurement_complete = false;
    measurement->measurement_active = false;
    measurement->calibration_factor = calibration_factor;
}

// Start measurement (called when object is first detected)
void measurement_start(measurement_t *measurement, uint32_t current_position) {
    if (measurement == NULL) return;

    measurement->start_position = current_position;
    measurement->end_position = current_position;
    measurement->length_steps = 0;
    measurement->length_mm = 0.0f;
    measurement->measurement_complete = false;
    measurement->measurement_active = true;
}

// Update measurement (called continuously during detection)
void measurement_update(measurement_t *measurement, uint32_t current_position, bool object_detected) {
    if (measurement == NULL) return;

    if (!measurement->measurement_active) {
        return;
    }

    if (object_detected) {
        // Update end position while object is still detected
        measurement->end_position = current_position;

        // Calculate current length
        if (measurement->end_position > measurement->start_position) {
            measurement->length_steps = measurement->end_position - measurement->start_position;
        } else {
            // Handle backward movement case
            measurement->length_steps = measurement->start_position - measurement->end_position;
        }

        // Convert to millimeters
        measurement->length_mm = (float)measurement->length_steps / measurement->calibration_factor;
    } else {
        // Object no longer detected, stop measurement
        measurement_stop(measurement, current_position);
    }
}

// Stop measurement (called when object is no longer detected)
void measurement_stop(measurement_t *measurement, uint32_t current_position) {
    if (measurement == NULL) return;

    if (measurement->measurement_active) {
        measurement->end_position = current_position;

        // Calculate final length
        if (measurement->end_position > measurement->start_position) {
            measurement->length_steps = measurement->end_position - measurement->start_position;
        } else {
            measurement->length_steps = measurement->start_position - measurement->end_position;
        }

        // Convert to millimeters
        measurement->length_mm = (float)measurement->length_steps / measurement->calibration_factor;

        measurement->measurement_complete = true;
        measurement->measurement_active = false;
    }
}

// Calculate length in millimeters
float measurement_calculate_length(measurement_t *measurement) {
    if (measurement == NULL) return 0.0f;

    if (measurement->measurement_complete || measurement->measurement_active) {
        return measurement->length_mm;
    }

    return 0.0f;
}

// Get current measurement in millimeters
float measurement_get_length_mm(measurement_t *measurement) {
    if (measurement == NULL) return 0.0f;
    return measurement->length_mm;
}

// Reset measurement
void measurement_reset(measurement_t *measurement) {
    if (measurement == NULL) return;

    measurement->start_position = 0;
    measurement->end_position = 0;
    measurement->length_steps = 0;
    measurement->length_mm = 0.0f;
    measurement->measurement_complete = false;
    measurement->measurement_active = false;
}

// Set calibration factor (steps per millimeter)
void measurement_set_calibration(measurement_t *measurement, float calibration_factor) {
    if (measurement == NULL) return;
    if (calibration_factor > 0.0f) {
        measurement->calibration_factor = calibration_factor;
    }
}