Fix Family B angle decode + add LR-1FMI model

parse_family_b() dùng sai hệ số góc 0.25°/LSB; theo spec Olei chính hãng
(Olei.LidarSensor/LidarDataBlock.GetAngleDegrees) AngleRaw là 0.01°/LSB.
Sai 25× khiến điểm bị gán nhầm góc → một phòng bị bôi thành vòng tròn trên
RViz. Đã verify với thiết bị thật OLELR-1FMI: sau khi sửa ra 2400 điểm/vòng,
0–359.9°, đúng hình học môi trường.

- Đổi hệ số góc 0.25° → 0.01° trong parse_family_b().
- Bỏ qua block invalid (AngleRaw >= 0xFF00) theo spec.
- Dò ranh giới vòng quay PER-POINT thay vì per-packet (một gói có thể chứa
  >1 vòng), tránh gộp nhiều vòng vào một scan.
- Thêm model LR-1FMI (360°, 0.01°/LSB, ~2400 pts/rev) vào bảng model +
  kModelTable, đặt "1FMI" trước "1F" để khớp đúng chuỗi tên.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

examples/example.cpp

@@ -0,0 +1,48 @@
+// example.cpp — quick try-out of the OLEI LiDAR driver
+#include "lidarlib/lidar.hpp"
+#include <cstdio>
+
+int main() {
+    // ── pick a model ────────────────────────────────────────────────────────
+    // lidarlib::Driver drv(lidarlib::MODEL_VF);        // 2D 360°
+    // lidarlib::Driver drv(lidarlib::MODEL_LR1F);      // 2D 360°, 50m
+    lidarlib::Driver drv(lidarlib::MODEL_VB);           // 2D 270°
+
+    if (!drv.open()) {
+        fprintf(stderr, "Không mở được socket\n");
+        return 1;
+    }
+
+    // ── option 1: blocking recv ─────────────────────────────────────────────
+    for (int i = 0; i < 10; ++i) {
+        lidarlib::ScanResult result;
+        if (!drv.recv_scan(result, 2000)) {
+            fprintf(stderr, "Timeout hoặc lỗi nhận packet\n");
+            break;
+        }
+        const lidarlib::LaserScan& scan = result.scan;
+        const lidarlib::ExtraInfo& info = result.info;
+        printf("Scan #%d: %zu điểm, ts=%u ms, err=0x%02X, model=%s\n",
+               i, scan.ranges.size(), scan.timestamp_ms, info.error_status,
+               info.detected_model.c_str());
+
+        // Print the first few points
+        for (size_t j = 0; j < 20 && j < scan.ranges.size(); ++j) {
+            float angle_deg = (scan.angle_min + j * scan.angle_increment) * 180.f / 3.14159265f;
+            printf("  [%zu] angle=%.2f° dist=%.3fm intensity=%.0f\n",
+                   j, angle_deg, scan.ranges[j], scan.intensities[j]);
+        }
+    }
+
+    // ── option 2: callback (your own loop) ──────────────────────────────────
+    // drv.set_scan_callback([](const lidarlib::ScanResult& result) {
+    //     printf("Got scan: %zu pts\n", result.scan.ranges.size());
+    // });
+    // while (true) drv.spin_once();
+
+    drv.close();
+    return 0;
+}
+
+// Build:
+//   g++ -std=c++17 -O2 -Iinclude -o example examples/example.cpp src/olei_lidar.cpp

examples/lidar_app.cpp

@@ -0,0 +1,83 @@
+// lidar_app.cpp — headless skeleton app and integration template.
+//
+// Loads the lidar list from config.json, opens each one through the SINGLE
+// config function lidarlib::make_lidar() (no per-brand branching), then reads scans
+// on one thread per lidar and prints a one-line summary. There is no web UI:
+// edit config.json directly, or build your own GUI on top of this same API.
+//
+// What a GUI author keeps:  load_config() + make_lidar() + the recv_scan() loop.
+// What a GUI author replaces: the printf() with their own rendering/persistence,
+// and save_config() to write edits back.
+//
+//   ./lidar_app [config.json]
+#include "lidarlib/lidarlib.hpp"
+#include <atomic>
+#include <csignal>
+#include <cstdio>
+#include <memory>
+#include <thread>
+#include <vector>
+
+namespace {
+
+std::atomic<bool> g_running{true};
+void on_signal(int) { g_running = false; }
+
+// One reader thread per lidar. Owns the handle for its whole lifetime so the
+// per-instance receive buffers never race another thread.
+void run_lidar(lidarlib::LidarConfig cfg) {
+    std::unique_ptr<lidarlib::Lidar> lidar = lidarlib::make_lidar(cfg);  // the one config call
+    if (!lidar->open()) {
+        fprintf(stderr, "[%s] khong mo duoc %s %s:%u\n",
+                cfg.name.c_str(), cfg.brand.c_str(), cfg.ip.c_str(), cfg.port);
+        return;
+    }
+    printf("[%s] da mo %s %s:%u (model=%s, inverted=%d)\n",
+           cfg.name.c_str(), cfg.brand.c_str(), cfg.ip.c_str(), cfg.port,
+           cfg.model.c_str(), cfg.inverted);
+
+    while (g_running) {
+        lidarlib::ScanResult result;
+        if (!lidar->recv_scan(result, 1000)) continue;  // timeout -> retry
+
+        // Output #1: ROS-shaped LaserScan (same for every lidar)
+        const lidarlib::LaserScan& scan = result.scan;
+        // Output #2: ExtraInfo (fields vary by model/family)
+        const lidarlib::ExtraInfo& info = result.info;
+
+        printf("[%s] %zu diem | ts=%u ms | model=%s | err=0x%02X\n",
+               cfg.name.c_str(), scan.ranges.size(), scan.timestamp_ms,
+               info.detected_model.c_str(), info.error_status);
+    }
+
+    lidar->close();
+    printf("[%s] da dong\n", cfg.name.c_str());
+}
+
+} // namespace
+
+int main(int argc, char** argv) {
+    setvbuf(stdout, nullptr, _IOLBF, 0);  // line-buffer so logs show promptly
+
+    const std::string config_path = (argc > 1) ? argv[1] : "config.json";
+
+    lidarlib::Config cfg = lidarlib::load_config(config_path);
+    lidarlib::save_config(config_path, cfg);  // ensure the file exists & is editable
+
+    if (cfg.lidars.empty()) {
+        fprintf(stderr, "Khong co lidar nao trong %s\n", config_path.c_str());
+        return 1;
+    }
+
+    std::signal(SIGINT, on_signal);
+    std::signal(SIGTERM, on_signal);
+
+    std::vector<std::thread> threads;
+    threads.reserve(cfg.lidars.size());
+    for (const auto& lc : cfg.lidars) threads.emplace_back(run_lidar, lc);
+
+    printf("Dang chay %zu lidar tu %s. Ctrl-C de dung.\n",
+           cfg.lidars.size(), config_path.c_str());
+    for (auto& t : threads) t.join();
+    return 0;
+}

examples/sick_example.cpp

@@ -0,0 +1,40 @@
+// sick_example.cpp — quick try-out of the SICK TiM driver (SOPAS/CoLa-A, TCP)
+//
+// Verified against a real SICK TiM781S — see the caveat in
+// include/lidarlib/sick_lidar.hpp for exactly what was (and wasn't) confirmed.
+#include "lidarlib/sick_lidar.hpp"
+#include <cstdio>
+
+int main() {
+    lidarlib::SickDriver drv(lidarlib::MODEL_SICK_TIM571, "192.168.0.1", 2111);
+
+    if (!drv.open()) {
+        fprintf(stderr, "Không kết nối được TCP tới lidar SICK\n");
+        return 1;
+    }
+
+    for (int i = 0; i < 10; ++i) {
+        lidarlib::ScanResult result;
+        if (!drv.recv_scan(result, 2000)) {
+            fprintf(stderr, "Timeout hoặc lỗi nhận telegram\n");
+            break;
+        }
+        const lidarlib::LaserScan& scan = result.scan;
+        const lidarlib::ExtraInfo& info = result.info;
+        printf("Scan #%d: %zu điểm, ts=%u ms, err=0x%02X, model=%s\n",
+               i, scan.ranges.size(), scan.timestamp_ms, info.error_status,
+               info.detected_model.c_str());
+
+        for (size_t j = 0; j < 20 && j < scan.ranges.size(); ++j) {
+            float angle_deg = (scan.angle_min + j * scan.angle_increment) * 180.f / 3.14159265f;
+            printf("  [%zu] angle=%.2f° dist=%.3fm intensity=%.0f\n",
+                   j, angle_deg, scan.ranges[j], scan.intensities[j]);
+        }
+    }
+
+    drv.close();
+    return 0;
+}
+
+// Build:
+//   g++ -std=c++17 -O2 -Iinclude -o sick_example examples/sick_example.cpp src/sick_lidar.cpp

examples/test_dual.cpp

@@ -0,0 +1,55 @@
+// test_dual.cpp — test 2 Olei lidars (front + rear) concurrently, per appsettings.json
+//   Olei-front: scan_1, DeviceIp 192.168.100.11, LocalIp 192.168.100.100, DevicePort 2368
+//   Olei-rear : scan_2, DeviceIp 192.168.100.12, LocalIp 192.168.100.100, DevicePort 2369
+#include "lidarlib/lidar.hpp"
+#include <cstdio>
+#include <thread>
+
+static void run_lidar(const char* tag, const lidarlib::ModelConfig& cfg,
+                       const std::string& local_ip, uint16_t port, bool inverted, int n_scans) {
+    lidarlib::Driver drv(cfg, local_ip, port, inverted);
+    if (!drv.open()) {
+        fprintf(stderr, "[%s] Khong mo duoc socket tren %s:%u (interface khong ton tai?)\n",
+                tag, local_ip.c_str(), port);
+        return;
+    }
+    printf("[%s] Da bind %s:%u, dang doi scan...\n", tag, local_ip.c_str(), port);
+
+    for (int i = 0; i < n_scans; ++i) {
+        lidarlib::ScanResult result;
+        if (!drv.recv_scan(result, 2000)) {
+            fprintf(stderr, "[%s] Timeout/loi nhan packet (scan #%d)\n", tag, i);
+            continue;
+        }
+        const lidarlib::LaserScan& scan = result.scan;
+        const lidarlib::ExtraInfo& info = result.info;
+        printf("[%s] Scan #%d: %zu diem, ts=%u ms, err=0x%02X, model=%s\n",
+               tag, i, scan.ranges.size(), scan.timestamp_ms, info.error_status,
+               info.detected_model.c_str());
+        for (size_t j = 0; j < 20 && j < scan.ranges.size(); ++j) {
+            float angle_deg = (scan.angle_min + j * scan.angle_increment) * 180.f / 3.14159265f;
+            printf("       [%zu] angle=%.2f dist=%.3fm intensity=%.0f\n",
+                   j, angle_deg, scan.ranges[j], scan.intensities[j]);
+        }
+    }
+    drv.close();
+}
+
+int main() {
+    // Both front and rear are Family B in practice — front's real header
+    // string is "OLELR-1BS2", rear's is "OLELR-1BS5" (verified via live UDP
+    // sniff), NOT the VB (Family A) model the config name suggested. With
+    // MODEL_AUTO, the driver reads the real model name from the header and
+    // narrows the FOV when it matches a known entry in kModelTable
+    // (olei_lidar.cpp); "1BS5" matches (→ full 360°), but "1BS2" doesn't, so
+    // front currently stays at the unfiltered 360° default. Call
+    // drv.detected_model() to see which name was actually read.
+    std::thread t_front(run_lidar, "front/scan_1", lidarlib::MODEL_AUTO,
+                         "192.168.100.100", 2368, false, 5);
+    std::thread t_rear(run_lidar, "rear/scan_2", lidarlib::MODEL_AUTO,
+                        "192.168.100.100", 2369, true, 5);
+
+    t_front.join();
+    t_rear.join();
+    return 0;
+}