Dashboard Hasil Akhir (OWL Frontend)

Komponen antarmuka pengguna ini dibangun menggunakan Odoo Web Library (OWL) dengan visualisasi modern berbasis dark glassmorphism. Dashboard menyediakan pemantauan sensor real-time dengan grafik sparkline interaktif (Chart.js), kontrol relay aktuator secara instan, pemantauan log logis, serta panel rekomendasi bertenaga AI lokal.

Persiapan Compiler & Paket Sistem Operasi (Build Toolchain)

Untuk menjalankan LLM secara lokal via GGUF, kita mengompilasi llama-cpp-python langsung di mesin host agar mendapatkan akselerasi instruksi perangkat keras CPU/GPU. Pasang dependensi build esensial berikut:

# Perbarui daftar paket dan pasang utilitas compiler
sudo apt update
sudo apt install build-essential python3-dev cmake git fuser -y

Konfigurasi Python Conda Environment

Isolasi environment Python Anda menggunakan Conda untuk menghindari konflik pustaka dengan dependensi bawaan sistem operasi.

# Buat environment baru bernama odoo-18 dengan python 3.10
conda create -n odoo-18 python=3.10 -y

# Aktifkan environment conda tersebut
conda activate odoo-18

# Verifikasi versi python aktif
python --version

Instalasi Pustaka Tambahan (llama-cpp-python & requests)

Pasang binding Python untuk AI lokal beserta pustaka requests untuk keperluan active sensor polling.

# Instalasi llama-cpp-python dengan compiler wheel host
pip install llama-cpp-python --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cpu

# Pasang requests untuk HTTP polling
pip install requests

Inisialisasi Addon Odoo 18 & Manifest File

Deklarasikan aset CSS, JavaScript (OWL), QWeb XML, data kronologi, dan menu di dalam berkas manifest modul Odoo.

# -*- coding: utf-8 -*-
{
    'name': 'IoT AI Control Hub',
    'version': '18.0.1.0.0',
    'category': 'IoT/AI',
    'summary': 'AI-driven IoT Automation Controller and Dashboard',
    'description': """
        IoT and AI integration framework for Odoo 18.
        Provides local AI inference using llama-cpp-python (GGUF) and simulated rule engines.
        Includes an OWL dashboard with real-time Chart.js telemetry charts.
    """,
    'depends': ['base', 'web'],
    'data': [
        'security/ir.model.access.csv',
        'data/iotai_cron_data.xml',
        'views/iotai_views.xml',
    ],
    'demo': [
        'demo/iotai_demo_data.xml',
    ],
    'assets': {
        'web.assets_backend': [
            'iotai/static/lib/marked/marked.min.js',
            'iotai/static/src/css/iot_dashboard.css',
            'iotai/static/src/js/iot_dashboard.js',
            'iotai/static/src/xml/iot_dashboard.xml',
        ],
    },
    'installable': True,
    'application': True,
    'license': 'OPL-1',
}

Pendaftaran Modul & Struktur Folder (__init__.py)

Gunakan berkas inisialisasi Python untuk mendaftarkan folder model dan routing API controller.

# -*- coding: utf-8 -*-
from . import models
from . import controllers

# -*- coding: utf-8 -*-
from . import sensor
from . import actuator
from . import ai_engine
from . import project_config

Desain Model Database IoT (models/sensor.py, models/actuator.py)

Tulis struktur model sensor dan aktuator menggunakan Odoo ORM. Pada model-model ini, kita mengimplementasikan method init() khusus untuk membersihkan data konflik non-XML sebelum instalasi guna menghindari UniqueViolation.

# -*- coding: utf-8 -*-
from odoo import models, fields, api
import uuid

class IoTAISensor(models.Model):
    _name = "iotai.sensor"
    _description = "IoT AI Sensor"

    key = fields.Char(string="Key", required=True, index=True)
    name = fields.Char(string="Name", required=True)
    sensor_type = fields.Selection([
        ('single', 'Single Value'),
        ('range', 'Range Value')
    ], string="Sensor Type", default='single', required=True)
    current_value = fields.Char(string="Current Value")
    read_mode = fields.Selection([
        ('active', 'Active Polling'),
        ('passive', 'Passive Webhook')
    ], string="Read Mode", default='active', required=True)
    webhook_token = fields.Char(string="Webhook Token", default=lambda self: self._generate_token())
    polling_url = fields.Char(string="Polling URL")
    polling_method = fields.Selection([('GET', 'GET'), ('POST', 'POST')], string="Polling Method", default='GET')
    polling_interval = fields.Integer(string="Polling Interval (Seconds)", default=30)
    polling_headers = fields.Text(string="Polling Headers (JSON)", default="{}")
    polling_payload = fields.Text(string="Polling Payload (JSON)", default="{}")
    json_path = fields.Char(string="JSON Path")
    last_read_time = fields.Datetime(string="Last Read Time")
    is_active = fields.Boolean(string="Active", default=True)
    log_ids = fields.One2many('iotai.sensor.log', 'sensor_id', string="Telemetry Logs")

    _sql_constraints = [('key_uniq', 'unique(key)', 'Sensor key must be unique!')]

    def init(self):
        super().init()
        # Clean up conflicting keys that are not in ir_model_data
        self.env.cr.execute("""
            DELETE FROM iotai_sensor 
            WHERE key IN ('ph_level', 'water_temp', 'ec_level', 'ambient_lux')
              AND id NOT IN (
                  SELECT COALESCE(res_id, 0) FROM ir_model_data WHERE model = 'iotai.sensor'
              )
        """)

    def _generate_token(self):
        return uuid.uuid4().hex[:16]

class IoTAISensorLog(models.Model):
    _name = "iotai.sensor.log"
    _description = "IoT AI Sensor Log"
    _order = "timestamp desc"

    sensor_id = fields.Many2one('iotai.sensor', string="Sensor", required=True, ondelete='cascade')
    value = fields.Char(string="Value", required=True)
    timestamp = fields.Datetime(string="Timestamp", default=fields.Datetime.now, required=True)

# -*- coding: utf-8 -*-
from odoo import models, fields, api
import uuid

class IoTAIActuator(models.Model):
    _name = "iotai.actuator"
    _description = "IoT AI Actuator"

    key = fields.Char(string="Key", required=True, index=True)
    name = fields.Char(string="Name", required=True)
    description = fields.Text(string="Description")
    state = fields.Selection([('ON', 'ON'), ('OFF', 'OFF')], string="State", default='OFF')
    possible_states = fields.Char(string="Possible States", default="ON, OFF")
    control_mode = fields.Selection([
        ('active', 'Active (Odoo pushes)'),
        ('passive', 'Passive (MCU pulls)')
    ], string="Control Mode", default='active', required=True)
    webhook_token = fields.Char(string="Webhook Token", default=lambda self: self._generate_token())
    api_url = fields.Char(string="API URL")
    api_method = fields.Selection([('GET', 'GET'), ('POST', 'POST')], string="API Method", default='POST')
    api_headers = fields.Text(string="API Headers (JSON)", default="{}")
    api_payload_template = fields.Text(string="API Payload Template (JSON)", default="{}")
    last_action_time = fields.Datetime(string="Last Action Time")
    log_ids = fields.One2many('iotai.actuator.log', 'actuator_id', string="Control Logs")

    _sql_constraints = [('key_uniq', 'unique(key)', 'Actuator key must be unique!')]

    def init(self):
        super().init()
        # Clean up conflicting keys that are not in ir_model_data
        self.env.cr.execute("""
            DELETE FROM iotai_actuator 
            WHERE key IN ('water_pump', 'ph_down_pump', 'nutrient_pump', 'grow_lights')
              AND id NOT IN (
                  SELECT COALESCE(res_id, 0) FROM ir_model_data WHERE model = 'iotai.actuator'
              )
        """)

    def _generate_token(self):
        return uuid.uuid4().hex[:16]

class IoTAIActuatorLog(models.Model):
    _name = "iotai.actuator.log"
    _description = "IoT AI Actuator Log"
    _order = "timestamp desc"

    actuator_id = fields.Many2one('iotai.actuator', string="Actuator", required=True, ondelete='cascade')
    state = fields.Char(string="State", required=True)
    changed_by = fields.Selection([('manual', 'Manual'), ('ai', 'AI Engine')], string="Changed By", default='manual')
    timestamp = fields.Datetime(string="Timestamp", default=fields.Datetime.now, required=True)

Konfigurasi Hak Akses Keamanan (ir.model.access.csv)

Konfigurasikan ACL agar model internal dapat diakses oleh grup pengguna Odoo (base.group_user).

id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
access_iotai_sensor,access.iotai.sensor,model_iotai_sensor,base.group_user,1,1,1,1
access_iotai_sensor_log,access.iotai.sensor.log,model_iotai_sensor_log,base.group_user,1,1,1,1
access_iotai_actuator,access.iotai.actuator,model_iotai_actuator,base.group_user,1,1,1,1
access_iotai_actuator_log,access.iotai.actuator.log,model_iotai_actuator_log,base.group_user,1,1,1,1
access_iotai_project_config,access.iotai.project.config,model_iotai_project_config,base.group_user,1,1,1,1
access_iotai_ai_decision,access.iotai.ai.decision,model_iotai_ai_decision,base.group_user,1,1,1,1

Deklarasi Demo Data Native XML & Sparkline Logs

Hindari programmatic seeder berbasis Python untuk mencegah tabrakan data demo. Gunakan mekanisme deklaratif Odoo XML melalui demo/iotai_demo_data.xml untuk mendaftarkan konfigurasi, sensor, aktuator, serta pre-seeded logs untuk visualisasi grafik.

<?xml version="1.0" encoding="utf-8"?>
<odoo>
    <data noupdate="1">
        <!-- Default configuration record -->
        <record id="iotai_project_config_default" model="iotai.project.config">
            <field name="name">SIHIPO Hydroponic Smart Farm</field>
            <field name="description">Sistem otomatisasi pertanian cerdas berbasis IoT dan AI lokal.</field>
            <field name="use_simulated_ai">True</field>
            <field name="is_ai_active">True</field>
            <field name="system_prompt">- IF water_temp IS greater than 28.0 THEN water_pump = ON
- IF water_temp IS less than 22.0 THEN water_pump = OFF
- IF ph_level IS less than 5.5 THEN ph_down_pump = OFF
- IF ph_level IS greater than 6.5 THEN ph_down_pump = ON
- IF ec_level IS less than 1.2 THEN nutrient_pump = ON
- IF ec_level IS greater than 2.0 THEN nutrient_pump = OFF
- IF ambient_lux IS less than 300.0 THEN grow_lights = ON
- IF ambient_lux IS greater than 700.0 THEN grow_lights = OFF</field>
        </record>

        <!-- Sensors -->
        <record id="sensor_ph_level" model="iotai.sensor">
            <field name="key">ph_level</field>
            <field name="name">pH Level Sensor</field>
            <field name="sensor_type">single</field>
            <field name="current_value">6.2</field>
            <field name="read_mode">passive</field>
            <field name="webhook_token">ph_token_123</field>
            <field name="is_active">True</field>
        </record>

        <!-- Seeded Historical Logs for pH Level -->
        <record id="log_ph_level_1" model="iotai.sensor.log">
            <field name="sensor_id" ref="sensor_ph_level"/>
            <field name="value">6.0</field>
        </record>
        <record id="log_ph_level_2" model="iotai.sensor.log">
            <field name="sensor_id" ref="sensor_ph_level"/>
            <field name="value">5.9</field>
        </record>
        <record id="log_ph_level_3" model="iotai.sensor.log">
            <field name="sensor_id" ref="sensor_ph_level"/>
            <field name="value">6.2</field>
        </record>
    </data>
</odoo>

Pembuatan Tampilan Backend XML (views/iotai_views.xml)

Definisikan Window Action, Form View, dan Client Action yang mengaitkan tag backend kita ke OWL Frontend.

<?xml version="1.0" encoding="utf-8"?>
<odoo>
    <!-- Config Form View -->
    <record id="view_iotai_project_config_form" model="ir.ui.view">
        <field name="name">iotai.project.config.form</field>
        <field name="model">iotai.project.config</field>
        <field name="arch" type="xml">
            <form string="IoT AI Configuration">
                <sheet>
                    <group>
                        <field name="name"/>
                        <field name="description"/>
                    </group>
                    <group string="AI Automation Parameters">
                        <group>
                            <field name="use_simulated_ai"/>
                            <field name="model_path" invisible="use_simulated_ai == True"/>
                            <field name="is_ai_active" widget="boolean_toggle"/>
                            <field name="ai_decision_interval"/>
                        </group>
                    </group>
                    <group string="Automation Prompt Rules">
                        <field name="system_prompt" widget="text" placeholder="Add custom state rules..."/>
                    </group>
                </sheet>
            </form>
        </field>
    </record>

    <!-- Client Action untuk Custom OWL Dashboard -->
    <record id="action_iotai_dashboard" model="ir.actions.client">
        <field name="name">IoT AI Control Hub</field>
        <field name="tag">iotai.dashboard</field>
    </record>

    <!-- Menu Utama -->
    <menuitem id="menu_iotai_root" name="IoT AI Control" web_icon="iotai,static/description/icon.png" sequence="10"/>
    <menuitem id="menu_iotai_dashboard" name="Dashboard" parent="menu_iotai_root" action="action_iotai_dashboard" sequence="1"/>
</odoo>

Penjadwalan Latar Belakang Native (ir.cron & Automated Tasks)

Gunakan penjadwal bawaan Odoo (ir.cron) untuk mengotomatisasi pemanggilan active polling sensor dan keputusan AI di latar belakang secara terjadwal.

<?xml version="1.0" encoding="utf-8"?>
<odoo>
    <record id="ir_cron_poll_active_sensors" model="ir.cron">
        <field name="name">IoT AI: Poll Active Sensors</field>
        <field name="model_id" ref="model_iotai_sensor"/>
        <field name="state">code</field>
        <field name="code">model.action_poll_active_sensors()</field>
        <field name="interval_number">1</field>
        <field name="interval_type">minutes</field>
        <field name="numbercall">-1</field>
        <field name="active">True</field>
    </record>

    <record id="ir_cron_trigger_ai_decision" model="ir.cron">
        <field name="name">IoT AI: Trigger AI Decision Cycle</field>
        <field name="model_id" ref="model_iotai_project_config"/>
        <field name="state">code</field>
        <field name="code">model.action_trigger_ai_decision()</field>
        <field name="interval_number">5</field>
        <field name="interval_type">minutes</field>
        <field name="numbercall">-1</field>
        <field name="active">True</field>
    </record>
</odoo>

Rule-Based Simulated AI Fallback Engine

Tulis modul pembantu Python di models/ai_engine.py untuk memproses logika otomasi berbasis aturan (regex fallback engine) jika server LLM lokal tidak aktif.

# -*- coding: utf-8 -*-
import re
import logging
_logger = logging.getLogger(__name__)

def execute_simulated_inference(system_prompt, sensors, actuators):
    """
    Evaluates rule prompt lines. Example format:
    - IF water_temp IS greater than 28.0 THEN water_pump = ON
    """
    _logger.info("Executing simulated rule-based inference engine")
    commands = []
    lines = system_prompt.split('\n')
    
    # Map key values
    sensor_map = {s['key']: float(s['value']) for s in sensors if s.get('value')}
    
    for line in lines:
        if not line.strip().startswith('- IF'):
            continue
        
        match = re.match(r'-\s*IF\s+(\w+)\s+(IS\s+)?(greater\s+than|less\s+than|equal\s+to)\s+([\d\.]+)\s+THEN\s+(\w+)\s*=\s*(\w+)', line.strip(), re.IGNORECASE)
        if match:
            s_key, _, operator, limit_val, a_key, a_state = match.groups()
            limit_val = float(limit_val)
            
            if s_key in sensor_map:
                current_val = sensor_map[s_key]
                triggered = False
                
                if 'greater' in operator.lower() and current_val > limit_val:
                    triggered = True
                elif 'less' in operator.lower() and current_val 

Singleton Manager Model AI GGUF Lokal

Gunakan instansiasi LLM tunggal (singleton) untuk menghemat ruang memori RAM Odoo server saat memuat model AI GGUF secara lokal.

# -*- coding: utf-8 -*-
class LlamaModelManager:
    _llm = None

    @classmethod
    def get_llm(cls, model_path):
        """Loads and caches the Llama GGUF model dynamically."""
        if not cls._llm and model_path:
            try:
                from llama_cpp import Llama
                cls._llm = Llama(
                    model_path=model_path,
                    n_ctx=2048,
                    n_threads=4,
                    verbose=False
                )
            except Exception as e:
                _logger.error("Failed to initialize Llama-CPP-Python: %s", str(e))
                cls._llm = None
        return cls._llm

def execute_gguf_inference(model_path, system_prompt, prompt):
    """Runs local inference using local GGUF cache manager."""
    llm = LlamaModelManager.get_llm(model_path)
    if not llm:
        return {'status': 'error', 'response': 'Model not loaded'}
        
    full_prompt = f"System: {system_prompt}\nUser: {prompt}\nResponse:"
    result = llm(full_prompt, max_tokens=150, stop=["\n", "User:"])
    text_res = result['choices'][0]['text'].strip()
    return {
        'status': 'success',
        'response': text_res
    }

Membangun Controller Webhook Terproteksi Token

ESP32/MCU dapat mengirim data ke Odoo melalui route HTTP. Kita menggunakan kelas http.Controller dengan auth="public". Untuk menulis ke database Odoo sebagai user publik, kita wajib menggunakan .sudo() agar tidak terkena hambatan ACL security.

# -*- coding: utf-8 -*-
from odoo import http, fields
from odoo.http import request
import json
import logging
_logger = logging.getLogger(__name__)

class IoTAIController(http.Controller):

    @http.route('/api/sensor/<string:key>', type='http', auth='public', methods=['POST', 'PUT'], csrf=False)
    def sensor_webhook(self, key, **kwargs):
        # Gunakan sudo() karena dipanggil oleh user publik tanpa login session
        sensor = request.env['iotai.sensor'].sudo().search([
            ('key', '=', key), 
            ('read_mode', '=', 'passive')
        ], limit=1)
        
        token = request.httprequest.args.get('token')
        if not sensor or token != sensor.webhook_token:
            return request.make_response(
                json.dumps({'error': 'Unauthorized or invalid sensor key'}), 
                status=401,
                headers=[('Content-Type', 'application/json')]
            )

        val = request.params.get('value') or request.get_json_data().get('value')
        if not val:
            return request.make_response(
                json.dumps({'error': 'Missing value field'}), 
                status=400,
                headers=[('Content-Type', 'application/json')]
            )

        # Update telemetry data
        sensor.write({
            'current_value': str(val),
            'last_read_time': fields.Datetime.now()
        })
        
        request.env['iotai.sensor.log'].sudo().create({
            'sensor_id': sensor.id,
            'value': str(val),
            'timestamp': fields.Datetime.now()
        })

        _logger.info("Sensor '%s' updated via webhook: %s", key, val)
        return request.make_response(
            json.dumps({'status': 'success', 'key': key, 'value': val}), 
            headers=[('Content-Type', 'application/json')]
        )

Implementasi Kontrol Status Aktuator Pasif (MCU Pull-Based)

Sediakan rute API GET /api/actuator/<key>/status agar ESP32 yang berada di balik jaringan NAT/Router lokal tetap dapat menarik instruksi saklar ON/OFF terbaru secara aman.

    @http.route('/api/actuator/<string:key>/status', type='http', auth='public', methods=['GET'], csrf=False)
    def actuator_status_api(self, key, **kwargs):
        actuator = request.env['iotai.actuator'].sudo().search([
            ('key', '=', key), 
            ('control_mode', '=', 'passive')
        ], limit=1)
        
        token = request.httprequest.args.get('token')
        if not actuator or token != actuator.webhook_token:
            return request.make_response(
                json.dumps({'error': 'Unauthorized'}), 
                status=401,
                headers=[('Content-Type', 'application/json')]
            )

        return request.make_response(
            json.dumps({
                'key': actuator.key,
                'state': actuator.state or 'OFF'
            }), 
            headers=[('Content-Type', 'application/json')]
        )

Dashboard OWL Frontend & Integrasi Chart.js

Tulis komponen frontend menggunakan OWL (Odoo Web Library). Kita mengimplementasikan dinamika penting berikut:

• Dynamic Library Loading: Menggunakan loadBundle("web.chartjs_lib") dalam lifecycle onWillStart untuk memuat library visualisasi bawaan Odoo secara aman.
• HTML Markup Rendering: Mengimpor markup dari @odoo/owl untuk membungkus hasil parser Markdown (dari library marked) sehingga tag HTML dapat di-render secara unescaped oleh directive t-out.
• Bypass SCSS Compilation Limit: Odoo mengompilasi dan menggabungkan semua file CSS di web.assets_backend. Memasukkan `@import` di dalam CSS modul akan merusak parser aset karena letaknya bergeser ke tengah bundle. Kami mengatasinya dengan memuat Google Fonts secara dinamis menggunakan tag HTML <link> di dalam QWeb XML.

/* @odoo-module */
import { Component, onMounted, onWillStart, onWillUnmount, useState, markup } from "@odoo/owl";
import { registry } from "@web/core/registry";
import { useService } from "@web/core/utils/hooks";
import { loadBundle } from "@web/core/assets";

export class IoTAIDashboard extends Component {
    setup() {
        this.orm = useService("orm");
        this.notification = useService("notification");
        this.state = useState({
            project: { 
                name: "Loading...", 
                sensors: [], 
                actuators: [], 
                ai_decisions: [] 
            },
            aiInsightHtml: "",
            isGeneratingInsight: false,
            isPolling: false
        });
        this.charts = {};

        onWillStart(async () => {
            // Memuat Chart.js bawaan Odoo secara dinamis
            await loadBundle("web.chartjs_lib");
        });

        onMounted(() => {
            this.loadData();
            // Polling data telemetri real-time setiap 3 detik
            this.pollInterval = setInterval(() => this.loadData(true), 3000);
        });

        onWillUnmount(() => {
            clearInterval(this.pollInterval);
            // Bersihkan instansi Chart.js untuk mencegah kebocoran memori (memory leak) di browser
            Object.values(this.charts).forEach(chart => chart.destroy());
        });
    }

    async loadData(isSilent = false) {
        try {
            const res = await this.orm.call(
                "iotai.project.config",
                "action_get_realtime_data",
                [[]]
            );
            Object.assign(this.state.project, res);
            this.renderCharts();
        } catch (error) {
            if (!isSilent) {
                console.error("Failed to load dashboard data:", error);
                this.notification.add("Connection lost to Odoo IoT backend.", { type: "danger" });
            }
        }
    }

    async onPollSensors() {
        this.state.isPolling = true;
        try {
            await this.orm.call("iotai.sensor", "action_poll_active_sensors", [[]]);
            this.notification.add("Successfully polled active sensors.", { type: "success" });
            await this.loadData();
        } catch (error) {
            this.notification.add("Sensor polling request failed.", { type: "danger" });
        } finally {
            this.state.isPolling = false;
        }
    }

    async onToggleActuator(key, currentState) {
        const targetState = currentState === "ON" ? "OFF" : "ON";
        try {
            await this.orm.call(
                "iotai.actuator",
                "action_set_state_by_key",
                [[], key, targetState]
            );
            this.notification.add(`Actuator ${key} set to ${targetState}`, { type: "success" });
            await this.loadData();
        } catch (error) {
            this.notification.add("Failed to update actuator state.", { type: "danger" });
        }
    }

    async onGenerateInsights() {
        this.state.isGeneratingInsight = true;
        try {
            const res = await this.orm.call(
                "iotai.project.config",
                "action_generate_ai_insight",
                [[]]
            );
            if (res && res.status === "success") {
                // Konversi mentah teks Markdown ke HTML lalu dibungkus dengan markup()
                this.state.aiInsightHtml = markup(marked.parse(res.insight));
                this.notification.add("AI analysis completed.", { type: "success" });
            } else {
                this.notification.add(res.message || "Failed to parse AI response.", { type: "warning" });
            }
        } catch (error) {
            this.notification.add("Local inference server offline.", { type: "danger" });
        } finally {
            this.state.isGeneratingInsight = false;
        }
    }

    renderCharts() {
        this.state.project.sensors.forEach(sensor => {
            const canvasId = `chart_${sensor.key}`;
            const canvas = document.getElementById(canvasId);
            if (!canvas) return;

            const logs = sensor.history_logs || [];
            const labels = logs.map((_, idx) => idx + 1);
            const dataPoints = logs.map(l => parseFloat(l));

            if (this.charts[sensor.key]) {
                const chart = this.charts[sensor.key];
                chart.data.labels = labels;
                chart.data.datasets[0].data = dataPoints;
                chart.update("none"); // Update grafik secara langsung tanpa efek animasi lambat redundan
            } else {
                const ctx = canvas.getContext("2d");
                this.charts[sensor.key] = new Chart(ctx, {
                    type: "line",
                    data: {
                        labels: labels,
                        datasets: [{
                            data: dataPoints,
                            borderColor: "#00A09D",
                            backgroundColor: "rgba(0, 160, 157, 0.05)",
                            borderWidth: 2,
                            pointRadius: 0,
                            fill: true,
                            tension: 0.3
                        }]
                    },
                    options: {
                        responsive: true,
                        maintainAspectRatio: false,
                        plugins: { legend: { display: false } },
                        scales: {
                            x: { display: false },
                            y: { grid: { color: "rgba(255, 255, 255, 0.05)" }, ticks: { color: "#94a3b8" } }
                        }
                    }
                });
            }
        });
    }
}
IoTAIDashboard.template = "iotai.IoTAIDashboard";
registry.category("actions").add("iotai.dashboard", IoTAIDashboard);