for YouTube Lighting vs Podcasting: A Head-to-Head

import serial
import time
import csv
from datetime import datetime
from typing import List, Dict, Optional

class SekonicC800Client:
    """Client for Sekonic C-800 Color Meter serial interface (firmware v2.1.0+)"""

    def __init__(self, port: str = '/dev/ttyUSB0', baudrate: int = 9600, timeout: int = 2):
        self.port = port
        self.baudrate = baudrate
        self.timeout = timeout
        self.ser: Optional[serial.Serial] = None

    def connect(self) -> bool:
        """Establish serial connection to C-800. Returns True on success."""
        try:
            self.ser = serial.Serial(
                port=self.port,
                baudrate=self.baudrate,
                bytesize=serial.EIGHTBITS,
                parity=serial.PARITY_NONE,
                stopbits=serial.STOPBITS_ONE,
                timeout=self.timeout
            )
            # Wait for device handshake
            time.sleep(1)
            self.ser.flushInput()
            return True
        except serial.SerialException as e:
            print(f"Connection failed: {e}")
            return False

    def take_measurement(self) -> Optional[Dict[str, float]]:
        """Take single CRI/TLCI measurement. Returns dict with 'cri', 'tlci', 'cct' or None on error."""
        if not self.ser or not self.ser.is_open:
            print("Error: Not connected to device")
            return None

        try:
            # Send measurement command per Sekonic C-800 serial protocol v1.2
            self.ser.write(b'MEAS\x0D')
            time.sleep(0.5)

            # Read response (format: CRI:XX.X,TLCI:XX.X,CCT:XXXX)
            response = self.ser.readline().decode('ascii').strip()
            if not response:
                print("Error: Empty response from device")
                return None

            # Parse response
            metrics = {}
            for pair in response.split(','):
                key, val = pair.split(':')
                metrics[key.lower()] = float(val)

            # Validate CRI range (0-100)
            if not 0 <= metrics.get('cri', -1) <= 100:
                print(f"Invalid CRI value: {metrics.get('cri')}")
                return None

            return metrics
        except (UnicodeDecodeError, ValueError) as e:
            print(f"Measurement parse error: {e}")
            return None
        except serial.SerialTimeoutException:
            print("Error: Measurement timed out")
            return None

    def disconnect(self) -> None:
        """Close serial connection."""
        if self.ser and self.ser.is_open:
            self.ser.close()

def run_benchmark(
    client: SekonicC800Client,
    samples: int = 100,
    output_csv: str = 'cri_benchmark_results.csv'
) -> List[Dict[str, float]]:
    """Run CRI/TLCI benchmark with specified number of samples. Exports to CSV."""
    results = []

    for i in range(samples):
        print(f"Taking sample {i+1}/{samples}...")
        measurement = client.take_measurement()
        if measurement:
            results.append(measurement)
            time.sleep(0.2)  # Prevent device flooding
        else:
            print(f"Sample {i+1} failed, retrying...")
            time.sleep(1)

    # Calculate averages
    avg_cri = sum(m['cri'] for m in results) / len(results) if results else 0
    avg_tlci = sum(m['tlci'] for m in results) / len(results) if results else 0
    print(f"\nBenchmark complete: {len(results)}/{samples} valid samples")
    print(f"Average CRI: {avg_cri:.1f}, Average TLCI: {avg_tlci:.1f}")

    # Export to CSV
    if results:
        with open(output_csv, 'w', newline='') as f:
            writer = csv.DictWriter(f, fieldnames=['cri', 'tlci', 'cct', 'timestamp'])
            writer.writeheader()
            for m in results:
                m['timestamp'] = datetime.now().isoformat()
                writer.writerow(m)
        print(f"Results exported to {output_csv}")

    return results

if __name__ == '__main__':
    # Configuration
    CLIENT_PORT = '/dev/ttyUSB0'  # Update for your system (e.g., 'COM3' on Windows)
    SAMPLE_COUNT = 100
    OUTPUT_FILE = f'benchmark_{datetime.now().strftime("%Y%m%d_%H%M%S")}.csv'

    # Initialize client and run benchmark
    client = SekonicC800Client(port=CLIENT_PORT)
    if client.connect():
        try:
            run_benchmark(client, samples=SAMPLE_COUNT, output_csv=OUTPUT_FILE)
        finally:
            client.disconnect()
    else:
        print("Failed to connect to Sekonic C-800. Check port and device power.")

const axios = require('axios');
const winston = require('winston');
const { GvmLightClient } = require('gvm-light-api'); // Hypothetical official SDK v1.2.0

// Configure logger
const logger = winston.createLogger({
  level: 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json()
  ),
  transports: [
    new winston.transports.File({ filename: 'gvm-light-control.log' }),
    new winston.transports.Console()
  ]
});

/**
 * Controller for GVM 80W LED Video Light (firmware v2.1+)
 */
class GvmLightController {
  /**
   * @param {string} ip - Local IP address of the GVM light
   * @param {number} port - API port (default 8080)
   */
  constructor(ip, port = 8080) {
    this.ip = ip;
    this.port = port;
    this.client = new GvmLightClient(`http://${ip}:${port}`);
    this.currentBrightness = 0;
    this.currentCct = 5600;
  }

  /**
   * Connect to the light and verify firmware version
   * @returns {Promise} True if connection successful
   */
  async connect() {
    try {
      const status = await this.client.getStatus();
      const firmwareVersion = status.firmware_version;
      logger.info(`Connected to GVM light at ${this.ip}:${this.port}`, { firmwareVersion });

      // Check minimum supported firmware
      if (firmwareVersion < '2.1.0') {
        logger.warn('Firmware version below 2.1.0, some features may not work');
      }
      return true;
    } catch (error) {
      logger.error('Failed to connect to GVM light', { error: error.message, ip: this.ip });
      return false;
    }
  }

  /**
   * Set light brightness (0-100%)
   * @param {number} percentage - Brightness value
   * @returns {Promise} True if set successful
   */
  async setBrightness(percentage) {
    if (percentage < 0 || percentage > 100) {
      logger.error('Brightness must be between 0 and 100', { percentage });
      return false;
    }

    try {
      await this.client.setBrightness(percentage);
      this.currentBrightness = percentage;
      logger.info(`Brightness set to ${percentage}%`);
      return true;
    } catch (error) {
      logger.error('Failed to set brightness', { error: error.message, percentage });
      return false;
    }
  }

  /**
   * Set color temperature (3200K-6500K)
   * @param {number} cct - Color temperature in Kelvin
   * @returns {Promise} True if set successful
   */
  async setCct(cct) {
    if (cct < 3200 || cct > 6500) {
      logger.error('CCT must be between 3200K and 6500K', { cct });
      return false;
    }

    try {
      await this.client.setCct(cct);
      this.currentCct = cct;
      logger.info(`CCT set to ${cct}K`);
      return true;
    } catch (error) {
      logger.error('Failed to set CCT', { error: error.message, cct });
      return false;
    }
  }

  /**
   * Get current power consumption in watts
   * @returns {Promise} Power consumption
   */
  async getPowerConsumption() {
    try {
      const telemetry = await this.client.getTelemetry();
      const power = telemetry.power_watts;
      logger.debug('Power consumption retrieved', { power });
      return power;
    } catch (error) {
      logger.error('Failed to get power consumption', { error: error.message });
      return 0;
    }
  }

  /**
   * Run a test pattern for benchmarking
   * @param {number} durationMs - Test duration in milliseconds
   */
  async runTestPattern(durationMs = 60000) {
    logger.info(`Starting test pattern for ${durationMs}ms`);
    const startTime = Date.now();
    const powerReadings = [];

    while (Date.now() - startTime < durationMs) {
      // Cycle brightness 0-100-0
      await this.setBrightness(100);
      await new Promise(resolve => setTimeout(resolve, 1000));
      await this.setBrightness(50);
      await new Promise(resolve => setTimeout(resolve, 1000));
      await this.setBrightness(0);
      await new Promise(resolve => setTimeout(resolve, 1000));

      // Take power reading
      const power = await this.getPowerConsumption();
      powerReadings.push(power);
    }

    const avgPower = powerReadings.reduce((a, b) => a + b, 0) / powerReadings.length;
    logger.info(`Test pattern complete. Average power: ${avgPower}W`, { avgPower });
    return avgPower;
  }
}

// Main execution
(async () => {
  const LIGHT_IP = '192.168.1.45'; // Update with your light's IP
  const controller = new GvmLightController(LIGHT_IP);

  if (await controller.connect()) {
    try {
      // Set initial values for YouTube lighting benchmark
      await controller.setCct(5600);
      await controller.setBrightness(80);
      const avgPower = await controller.runTestPattern(300000); // 5 minute test
      console.log(`Benchmark complete. Average power: ${avgPower}W`);
    } catch (error) {
      logger.error('Error during benchmark', { error: error.message });
    }
  } else {
    console.error('Could not connect to GVM light. Check network and power.');
  }
})();

package main

import (
    "encoding/csv"
    "fmt"
    "math"
    "os"
    "strconv"
)

// LightingSetup represents a lighting configuration for TCO calculation
type LightingSetup struct {
    Name              string
    InitialCost       float64 // USD
    PowerWatts        float64 // Watts per hour of use
    BulbLifeHours     float64 // Hours per bulb
    ReplacementCost   float64 // USD per bulb
    MaintenancePerHour float64 // USD per hour for maintenance
    AnnualProductionHours float64 // Hours used per year
    LifespanYears     float64 // Total lifespan in years
}

// TCOResults holds total cost of ownership calculations
type TCOResults struct {
    SetupName        string
    TotalCost        float64
    CostPerHour      float64
    PowerCostTotal   float64
    ReplacementCostTotal float64
    MaintenanceTotal float64
}

// calculateTCO computes total cost of ownership over the setup's lifespan
func calculateTCO(setup LightingSetup, electricityRate float64) (TCOResults, error) {
    if setup.LifespanYears <= 0 {
        return TCOResults{}, fmt.Errorf("lifespan must be positive")
    }
    if setup.AnnualProductionHours <= 0 {
        return TCOResults{}, fmt.Errorf("annual production hours must be positive")
    }
    if electricityRate <= 0 {
        return TCOResults{}, fmt.Errorf("electricity rate must be positive")
    }

    totalHours := setup.AnnualProductionHours * setup.LifespanYears
    totalKwh := (setup.PowerWatts * totalHours) / 1000.0
    powerCostTotal := totalKwh * electricityRate

    // Calculate number of bulb replacements needed
    bulbReplacements := math.Floor(totalHours / setup.BulbLifeHours)
    replacementCostTotal := bulbReplacements * setup.ReplacementCost

    maintenanceTotal := setup.MaintenancePerHour * totalHours

    totalCost := setup.InitialCost + powerCostTotal + replacementCostTotal + maintenanceTotal
    costPerHour := totalCost / totalHours

    return TCOResults{
        SetupName:        setup.Name,
        TotalCost:        totalCost,
        CostPerHour:      costPerHour,
        PowerCostTotal:   powerCostTotal,
        ReplacementCostTotal: replacementCostTotal,
        MaintenanceTotal: maintenanceTotal,
    }, nil
}

// exportToCSV writes TCO results to a CSV file
func exportToCSV(results []TCOResults, filename string) error {
    file, err := os.Create(filename)
    if err != nil {
        return fmt.Errorf("failed to create CSV file: %w", err)
    }
    defer file.Close()

    writer := csv.NewWriter(file)
    defer writer.Flush()

    // Write header
    header := []string{"Setup Name", "Total Cost (USD)", "Cost Per Hour (USD)", "Power Cost (USD)", "Replacement Cost (USD)", "Maintenance Cost (USD)"}
    if err := writer.Write(header); err != nil {
        return fmt.Errorf("failed to write header: %w", err)
    }

    // Write rows
    for _, res := range results {
        row := []string{
            res.SetupName,
            fmt.Sprintf("%.2f", res.TotalCost),
            fmt.Sprintf("%.2f", res.CostPerHour),
            fmt.Sprintf("%.2f", res.PowerCostTotal),
            fmt.Sprintf("%.2f", res.ReplacementCostTotal),
            fmt.Sprintf("%.2f", res.MaintenanceTotal),
        }
        if err := writer.Write(row); err != nil {
            return fmt.Errorf("failed to write row: %w", err)
        }
    }

    return nil
}

func main() {
    // Electricity rate: $0.16 per kWh (US average 2024)
    const electricityRate = 0.16

    // Define YouTube Lighting setup (GVM 80W LED)
    ytSetup := LightingSetup{
        Name:              "YouTube: GVM 80W LED Kit",
        InitialCost:       249.99,
        PowerWatts:        80.0,
        BulbLifeHours:     50000.0,
        ReplacementCost:   49.99,
        MaintenancePerHour: 0.005,
        AnnualProductionHours: 1000.0,
        LifespanYears:     2.0,
    }

    // Define Podcasting Lighting setup (Rode PodMic Ring)
    podSetup := LightingSetup{
        Name:              "Podcasting: Rode PodMic LED Ring",
        InitialCost:       79.99,
        PowerWatts:        15.0,
        BulbLifeHours:     30000.0,
        ReplacementCost:   19.99,
        MaintenancePerHour: 0.001,
        AnnualProductionHours: 500.0,
        LifespanYears:     4.0,
    }

    // Calculate TCO for both setups
    ytResults, err := calculateTCO(ytSetup, electricityRate)
    if err != nil {
        fmt.Printf("Error calculating YouTube TCO: %v\n", err)
        return
    }

    podResults, err := calculateTCO(podSetup, electricityRate)
    if err != nil {
        fmt.Printf("Error calculating Podcasting TCO: %v\n", err)
        return
    }

    // Print results
    results := []TCOResults{ytResults, podResults}
    fmt.Println("Total Cost of Ownership Results:")
    fmt.Println("--------------------------------")
    for _, res := range results {
        fmt.Printf("Setup: %s\n", res.SetupName)
        fmt.Printf("  Total Cost: $%.2f\n", res.TotalCost)
        fmt.Printf("  Cost Per Hour: $%.2f\n", res.CostPerHour)
        fmt.Printf("  Power Cost: $%.2f\n", res.PowerCostTotal)
        fmt.Printf("  Replacement Cost: $%.2f\n", res.ReplacementCostTotal)
        fmt.Printf("  Maintenance Cost: $%.2f\n\n", res.MaintenanceTotal)
    }

    // Export to CSV
    if err := exportToCSV(results, "tco_results.csv"); err != nil {
        fmt.Printf("Error exporting to CSV: %v\n", err)
        return
    }
    fmt.Println("Results exported to tco_results.csv")
}

import serial
ser = serial.Serial('/dev/ttyUSB0', 9600, timeout=2)
ser.write(b'MEAS\x0D')
print(ser.readline().decode('ascii'))
ser.close()

const axios = require('axios');
axios.post('http://192.168.1.45:8080/power', { state: 'on' })
  .then(res => console.log('Light powered on'))
  .catch(err => console.error('Error:', err));

func calculatePowerCost(watts, hours, rate float64) float64 {
    kwh := (watts * hours) / 1000.0
    return kwh * rate
}