[STM32MP25] BSP I/O 데모: 버튼 → BME280 → HTTP (Yocto/systemd)

1
from http.server import BaseHTTPRequestHandler, HTTPServer
2
from datetime import datetime
3

4
class Handler(BaseHTTPRequestHandler):
5
    def do_POST(self):
6
        n = int(self.headers.get('Content-Length', '0'))
7
        body = self.rfile.read(n).decode('utf-8', errors='replace')
8

9
        ts = datetime.now().isoformat(timespec='microseconds')
10
        print(f"{ts} {self.client_address[0]} {self.path} {body}")
11

12
        # 204 No Content
13
        self.send_response(204)
14
        self.end_headers()
15

16
    def log_message(self, fmt, *args):
17
        # 기본 access log를 끄고 싶으면 pass
18
        return
19

20
if __name__ == '__main__':
21
    addr = ('0.0.0.0', 18000)
22
    print(f"listening on http://{addr[0]}:{addr[1]}/ingest")
23
    HTTPServer(addr, Handler).serve_forever()

1
#define _GNU_SOURCE
2
#include <errno.h>
3
#include <fcntl.h>
4
#include <linux/input.h>
5
#include <signal.h>
6
#include <stdio.h>
7
#include <stdlib.h>
8
#include <stdarg.h>
9
#include <string.h>
10
#include <sys/stat.h>
11
#include <sys/types.h>
12
#include <time.h>
13
#include <unistd.h>
14

15
#include <curl/curl.h>
16

17
static volatile int g_stop = 0;
18

19
static void on_sigint(int sig) {
20
    (void)sig;
21
    g_stop = 1;
22
}
23

24
static void logi(const char *fmt, ...) {
25
    va_list ap;
26
    va_start(ap, fmt);
27
    printf("[INFO] ");
28
    vprintf(fmt, ap);
29
    printf("\n");
30
    fflush(stdout);
31
    va_end(ap);
32
}
33

34
static void logw(const char *fmt, ...) {
35
    va_list ap;
36
    va_start(ap, fmt);
37
    printf("[WARN] ");
38
    vprintf(fmt, ap);
39
    printf("\n");
40
    fflush(stdout);
41
    va_end(ap);
42
}
43

44
static int read_file_to_buf(const char *path, char *buf, size_t buflen) {
45
    int fd = open(path, O_RDONLY | O_CLOEXEC);
46
    if (fd < 0) return -1;
47
    ssize_t n = read(fd, buf, buflen - 1);
48
    close(fd);
49
    if (n <= 0) return -1;
50
    buf[n] = '\0';
51
    // trim newline
52
    char *p = strchr(buf, '\n');
53
    if (p) *p = '\0';
54
    return 0;
55
}
56

57
static int write_str(const char *path, const char *s) {
58
    int fd = open(path, O_WRONLY | O_CLOEXEC);
59
    if (fd < 0) return -1;
60
    ssize_t n = write(fd, s, strlen(s));
61
    close(fd);
62
    return (n == (ssize_t)strlen(s)) ? 0 : -1;
63
}
64

65
static void led_pulse_once(const char *led_name) {
66
    if (!led_name || !*led_name) return;
67

68
    char trig[256];
69
    char bri[256];
70
    snprintf(trig, sizeof(trig), "/sys/class/leds/%s/trigger", led_name);
71
    snprintf(bri, sizeof(bri), "/sys/class/leds/%s/brightness", led_name);
72

73
    // best-effort: disable trigger and pulse
74
    (void)write_str(trig, "none");
75
    (void)write_str(bri, "1");
76
    usleep(80 * 1000);
77
    (void)write_str(bri, "0");
78
}
79

80
static int find_bme280_iio(char *out_dir, size_t out_len) {
81
    // 아주 단순하게 iio:device0~9를 훑어보고 name==bme280인지 확인
82
    for (int i = 0; i < 10; i++) {
83
        char namep[128];
84
        char name[64];
85
        snprintf(namep, sizeof(namep), "/sys/bus/iio/devices/iio:device%d/name", i);
86
        if (read_file_to_buf(namep, name, sizeof(name)) == 0) {
87
            if (strcmp(name, "bme280") == 0 || strcmp(name, "bmp280") == 0) {
88
                snprintf(out_dir, out_len, "/sys/bus/iio/devices/iio:device%d", i);
89
                return 0;
90
            }
91
        }
92
    }
93
    return -1;
94
}
95

96
static int read_bme280_raw(long *temp_raw, long *hum_raw, double *press_kpa) {
97
    char base[128];
98
    if (find_bme280_iio(base, sizeof(base)) < 0) {
99
        return -1;
100
    }
101

102
    char p_temp[256], p_hum[256], p_press[256];
103
    char b[64];
104

105
    snprintf(p_temp, sizeof(p_temp), "%s/in_temp_input", base);
106
    snprintf(p_hum, sizeof(p_hum), "%s/in_humidityrelative_input", base);
107
    snprintf(p_press, sizeof(p_press), "%s/in_pressure_input", base);
108

109
    if (read_file_to_buf(p_temp, b, sizeof(b)) < 0) return -1;
110
    *temp_raw = strtol(b, NULL, 10);
111

112
    if (read_file_to_buf(p_hum, b, sizeof(b)) < 0) return -1;
113
    *hum_raw = strtol(b, NULL, 10);
114

115
    if (read_file_to_buf(p_press, b, sizeof(b)) < 0) return -1;
116
    long press_pa = strtol(b, NULL, 10);
117

118
    // Pa -> kPa (102739 Pa -> 102.739 kPa)
119
    *press_kpa = ((double)press_pa) / 1000.0;
120
    return 0;
121
}
122

123
static size_t discard_cb(void *ptr, size_t size, size_t nmemb, void *userdata) {
124
    (void)ptr; (void)userdata;
125
    return size * nmemb;
126
}
127

128
static int http_post_json(const char *url, const char *json) {
129
    CURL *curl = curl_easy_init();
130
    if (!curl) return -1;
131

132
    struct curl_slist *hdrs = NULL;
133
    hdrs = curl_slist_append(hdrs, "Content-Type: application/json");
134

135
    curl_easy_setopt(curl, CURLOPT_URL, url);
136
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, hdrs);
137
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json);
138
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, discard_cb);
139
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 3L);
140

141
    CURLcode rc = curl_easy_perform(curl);
142

143
    long http_code = 0;
144
    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);
145

146
    curl_slist_free_all(hdrs);
147
    curl_easy_cleanup(curl);
148

149
    if (rc != CURLE_OK) {
150
        return -1;
151
    }
152
    if (http_code < 200 || http_code >= 300) {
153
        return -1;
154
    }
155
    return 0;
156
}
157

158
int main(void) {
159
    signal(SIGINT, on_sigint);
160
    signal(SIGTERM, on_sigint);
161

162
    const char *server_url = getenv("SERVER_URL");
163
    const char *input_event = getenv("INPUT_EVENT");
164
    const char *led_name = getenv("LED_NAME");
165

166
    if (!server_url) server_url = "http://192.168.45.231:18000/ingest";
167
    if (!input_event) input_event = "/dev/input/event0";
168
    if (!led_name) led_name = "blue:heartbeat";
169

170
    logi("SERVER_URL=%s", server_url);
171
    logi("LED_NAME=%s", led_name);
172
    logi("INPUT_EVENT=%s", input_event);
173

174
    if (curl_global_init(CURL_GLOBAL_DEFAULT) != 0) {
175
        logw("curl_global_init failed");
176
        return 1;
177
    }
178

179
    int fd = open(input_event, O_RDONLY | O_CLOEXEC);
180
    if (fd < 0) {
181
        logw("open(%s) failed: %s", input_event, strerror(errno));
182
        curl_global_cleanup();
183
        return 1;
184
    }
185

186
    while (!g_stop) {
187
        struct input_event ev;
188
        ssize_t n = read(fd, &ev, sizeof(ev));
189
        if (n < 0) {
190
            if (errno == EINTR) continue;
191
            logw("read input_event failed: %s", strerror(errno));
192
            break;
193
        }
194
        if (n != (ssize_t)sizeof(ev)) continue;
195

196
        if (ev.type == EV_KEY && ev.value == 1) { // key press
197
            long t = 0, h = 0;
198
            double p = 0.0;
199

200
            char payload[256];
201
            if (read_bme280_raw(&t, &h, &p) < 0) {
202
                logw("sensor read failed; sending empty payload");
203
                snprintf(payload, sizeof(payload),
204
                         "{\"sensor\":\"bme280\",\"error\":\"read_failed\"}");
205
            } else {
206
                snprintf(payload, sizeof(payload),
207
                         "{\"sensor\":\"bme280\",\"temp_raw\":\"%ld\",\"hum_raw\":\"%ld\",\"press_raw\":\"%.9f\"}",
208
                         t, h, p);
209
            }
210

211
            logi("key_press code=%u -> POST %s payload=%s", ev.code, server_url, payload);
212
            led_pulse_once(led_name);
213

214
            int ok = http_post_json(server_url, payload);
215
            logi("post_result=%s", ok == 0 ? "OK" : "FAIL");
216
        }
217
    }
218

219
    close(fd);
220
    curl_global_cleanup();
221
    return 0;
222
}