tarask
6 days ago 532005c6573d95199ce0ffbc33df4c7a0a4c3ef9
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
#include "modules/my_altimeter/GRF500.h"
#include "modules/my_task_creator/TaskCreator.h"
#include "modules/my_mavlink_tx/MavlinkTransmitter.h"
 
uint8_t GRF500::address = 0x66;
double GRF500::distance = 0.0;
 
GRF500::GRF500(uint8_t addr)
    : registerModeActivated(false), lastReadMs(0)
{
    address = addr;
}
 
bool GRF500::begin()
{
    log_v("GRF500 begin");
    Wire.begin(SDA_PIN, SCL_PIN); // SDA, SCL
 
    log_v("Scanning I2C bus for devices...");
    bool deviceFound = false;
    for (uint8_t addr = 1; addr < 127; ++addr) {
        if (scan(addr)) {
            log_i("I2C device found at 0x%02X", addr);
            deviceFound = true;
        }
    }
    if (!deviceFound) {
        log_i("No I2C devices found");
        return false;
    }
 
    // Verify GRF500 at configured address
    log_i("Checking GRF500 at address 0x%02X", address);
    if (!scan(address)) {
        log_i("GRF500 not responding at 0x%02X", address);
        return false;
    }
    log_i("GRF500 responsive at 0x%02X", address);
    vTaskDelay(pdMS_TO_TICKS(50));
 
    enableRegisterMode();
    registerModeActivated = checkRegisterMode();
    log_i("Register mode %s", registerModeActivated ? "OK" : "FAIL");
    if (!registerModeActivated) return false;
 
    readDistance();
    return true;
}
 
void GRF500::Task(void *pvParameters)
{
    log_v("GRF500 Task started");
    TaskCreator *creator = static_cast<TaskCreator*>(pvParameters);
    GRF500 *sensor = &(creator->mGRF500);
    MavlinkTransmitter *transmitter = &(creator->mTransmitter);
 
    if (!sensor->begin()) {
        log_i("GRF500 initialization failed");
        vTaskDelete(NULL);
        return;
    }
 
    log_i("GRF500 initialized successfully");
    uint32_t lastTick = xTaskGetTickCount();
    for (;;) {
        sensor->readMeasurements();
        bool valid = (distance > 0);
 
        uint32_t now = xTaskGetTickCount();
        if (valid && (now - lastTick >= 100)) {
            transmitter->SendDistanceSensor(distance, valid, (float)RANGEFINDER_GRF500_MAX_DISTANCE);
            lastTick = now;
        }
        vTaskDelay(pdMS_TO_TICKS(10));
    }
}
 
void GRF500::update()
{
    uint32_t now = millis();
    if (now - lastReadMs < 100) return;
    lastReadMs = now;
    if (!registerModeActivated) return;
 
    readMeasurements();
}
 
bool GRF500::scan(uint8_t addr)
{
    Wire.beginTransmission(addr);
    return (Wire.endTransmission() == 0);
}
 
void GRF500::enableRegisterMode()
{
    Wire.beginTransmission(address);
    Wire.write((uint8_t)120);
    Wire.write((uint8_t)0xAA);
    Wire.write((uint8_t)0xAA);
    if (Wire.endTransmission() != 0) {
        log_i("Register-mode write error");
    }
}
 
bool GRF500::checkRegisterMode()
{
    Wire.beginTransmission(address);
    Wire.write((uint8_t)120);
    if (Wire.endTransmission() != 0) return false;
    if (Wire.requestFrom(address, (uint8_t)2) != 2) return false;
 
    uint8_t a = Wire.read();
    uint8_t b = Wire.read();
    return (a == 0xCC && b == 0);
}
 
void GRF500::readDistance()
{
    Wire.beginTransmission(address);
    Wire.write((uint8_t)27);
    if (Wire.endTransmission() != 0) {
        log_i("Distance write error");
        return;
    }
    if (Wire.requestFrom(address, (uint8_t)4) == 4) {
        uint32_t raw = 0;
        raw |= (uint32_t)Wire.read();
        raw |= (uint32_t)Wire.read() << 8;
        raw |= (uint32_t)Wire.read() << 16;
        raw |= (uint32_t)Wire.read() << 24;
        distance = raw / 100.0;
        log_i("Distance: %.2f m", distance);
    }
}
 
void GRF500::readMeasurements()
{
    Wire.beginTransmission(address);
    Wire.write((uint8_t)44);
    if (Wire.endTransmission() != 0) {
        log_i("Measurements write error");
        return;
    }
    if (Wire.requestFrom(address, (uint8_t)8) == 8) {
        int16_t first = Wire.read() | (Wire.read() << 8);
        int16_t strength1 = Wire.read() | (Wire.read() << 8);
        int16_t last = Wire.read() | (Wire.read() << 8);
        int16_t strength2 = Wire.read() | (Wire.read() << 8);
 
        distance = first / 10.0;
        // log_i("First=%d Last=%d S1=%d S2=%d", first, last, strength1, strength2);
    }
}