Integrating IoT with Cloud Platforms for Small Businesses

// Node.js example: IoT device publishing to cloud
const mqtt = require('mqtt');
const client = mqtt.connect('mqtts://iot-platform.com', {
  username: 'device-001',
  password: 'secure-token',
  clientId: 'sensor-001'
});

// Connect to broker
client.on('connect', () => {
  console.log('Connected to IoT platform');
  
  // Publish sensor data every 30 seconds
  setInterval(() => {
    const sensorData = {
      deviceId: 'sensor-001',
      timestamp: new Date().toISOString(),
      temperature: readTemperature(),
      humidity: readHumidity(),
      battery: readBatteryLevel()
    };
    
    client.publish('devices/sensor-001/data', JSON.stringify(sensorData), {
      qos: 1, // At least once delivery
      retain: false
    });
  }, 30000);
});

// Handle commands from cloud
client.on('message', (topic, message) => {
  if (topic === 'devices/sensor-001/commands') {
    const command = JSON.parse(message.toString());
    if (command.action === 'calibrate') {
      calibrateSensor();
    }
  }
});

client.subscribe('devices/sensor-001/commands');

// Cloud platform receives and processes data
// AWS IoT Core, Azure IoT Hub, Google Cloud IoT Core

1. Data Ingestion: IoT devices → Message broker (MQTT, Kafka)

2. Data Storage: Time-series database (InfluxDB, TimescaleDB)

3. Processing: Stream processing (Apache Flink, AWS Kinesis)

4. Analytics: ML models, dashboards, alerts

5. Visualization: Grafana, Power BI, custom dashboards

// Predictive maintenance: Analyze equipment data
class PredictiveMaintenance {
  constructor() {
    this.mlModel = loadModel('equipment-failure-predictor');
  }
  
  async analyzeEquipmentData(deviceId, sensorData) {
    // Extract features
    const features = {
      temperature: sensorData.temperature,
      vibration: sensorData.vibration,
      operatingHours: sensorData.operatingHours,
      load: sensorData.load,
      // Historical patterns
      tempTrend: this.calculateTrend(sensorData.temperatureHistory),
      vibrationAnomaly: this.detectAnomaly(sensorData.vibrationHistory)
    };
    
    // Predict failure probability
    const failureProbability = await this.mlModel.predict(features);
    
    // Determine maintenance urgency
    if (failureProbability > 0.8) {
      return {
        status: 'critical',
        action: 'schedule_maintenance_immediately',
        predictedFailureTime: this.estimateFailureTime(features),
        recommendedActions: this.getMaintenanceRecommendations(features)
      };
    } else if (failureProbability > 0.5) {
      return {
        status: 'warning',
        action: 'schedule_maintenance_soon',
        predictedFailureTime: this.estimateFailureTime(features)
      };
    }
    
    return { status: 'normal' };
  }
  
  calculateTrend(history) {
    // Simple linear trend
    const n = history.length;
    const sumX = (n * (n + 1)) / 2;
    const sumY = history.reduce((a, b) => a + b, 0);
    const sumXY = history.reduce((sum, val, idx) => sum + (idx + 1) * val, 0);
    const slope = (n * sumXY - sumX * sumY) / (n * (n * (n + 1) * (2 * n + 1) / 6) - sumX * sumX);
    return slope;
  }
}

AWS IoT Core: Device management, message broker, rules engine, device shadows

Azure IoT Hub: Bidirectional communication, device management, edge computing

Google Cloud IoT Core: Device registry, MQTT broker, integration with GCP services

ThingSpeak: Open-source platform, good for prototyping

Losant: Enterprise IoT platform with visual workflow builder