Jorge Morais — Senior Full-Stack Developer at the intersection of AI and Industrial IoT · Remote, EU

// MQTT Bridge for ccTalk Protocol
class CcTalkMQTTBridge {
  constructor(mqttClient, ccTalkParser, io) {
    this.mqttClient = mqttClient;
    this.parser = ccTalkParser;
    this.io = io; // Socket.IO instance
    this.devices = new Map();
  }

  async publishDeviceStatus(deviceId, rawData) {
    try {
      // Parse binary ccTalk data (custom C module via N-API)
      const status = await this.parser.parse(rawData);

      // Calculate health score based on multiple factors
      const health = this.calculateHealthScore(status);

      // Publish to MQTT topic with QoS 1 (at least once delivery)
      const topic = `vending/${deviceId}/status`;
      const payload = {
        timestamp: Date.now(),
        deviceId,
        status: {
          online: status.online,
          coinCount: status.coinCount,
          billCount: status.billCount,
          errors: status.errorCodes,
          temperature: status.temperature
        },
        health: {
          score: health.score,
          level: health.level, // 'excellent' | 'good' | 'warning' | 'critical'
          alerts: health.alerts
        }
      };

      await this.mqttClient.publish(
        topic,
        JSON.stringify(payload),
        { qos: 1, retain: true }
      );

      // Emit real-time update via WebSocket for immediate UI update
      this.emitRealtimeUpdate(deviceId, payload);

      // Store in database for analytics
      await this.storeDeviceStatus(deviceId, payload);

    } catch (error) {
      console.error(`Failed to process device ${deviceId}:`, error);
      this.handleDeviceError(deviceId, error);
    }
  }

  calculateHealthScore(status) {
    let score = 100;
    const alerts = [];

    // Deduct points based on issues
    if (status.errorCodes.length > 0) {
      score -= status.errorCodes.length * 10;
      alerts.push({
        type: 'error',
        severity: 'high',
        message: `${status.errorCodes.length} error(s) detected`
      });
    }

    if (status.temperature > 45) {
      score -= 15;
      alerts.push({
        type: 'warning',
        severity: 'medium',
        message: 'High temperature - potential overheating'
      });
    }

    if (status.coinCount < 50) {
      score -= 5;
      alerts.push({
        type: 'info',
        severity: 'low',
        message: 'Low coin level - collection recommended'
      });
    }

    // Determine health level
    const level = score >= 90 ? 'excellent'
                : score >= 70 ? 'good'
                : score >= 50 ? 'warning'
                : 'critical';

    return { score, level, alerts };
  }

  emitRealtimeUpdate(deviceId, payload) {
    // Send to all clients subscribed to this device
    this.io.to(`device:${deviceId}`).emit('status_update', payload);

    // Send summary to dashboard
    this.io.to('dashboard').emit('device_update', {
      deviceId,
      health: payload.health
    });
  }

  async handleDeviceError(deviceId, error) {
    // Log error
    await this.logError(deviceId, error);

    // Send alert to admin
    this.io.to('admin').emit('device_error', {
      deviceId,
      error: error.message,
      timestamp: Date.now()
    });

    // Update device status to offline if communication failed
    if (error.code === 'ETIMEDOUT' || error.code === 'ECONNREFUSED') {
      await this.setDeviceOffline(deviceId);
    }
  }
}