Работа с железом в PHP Laravel с Pinout

use \DanJohnson95\Pinout\Facades\PinService;
 
// Получение доступа к GPIO пину
$pin = PinService::pin(13);
 
// Проверка состояния пина
$pin->isOn();  // Возвращает true, если пин в состоянии HIGH
$pin->isOff(); // Возвращает true, если пин в состоянии LOW
 
// Управление состоянием пина
$pin->turnOn();  // Устанавливает пин в состояние HIGH
$pin->turnOff(); // Устанавливает пин в состояние LOW
 
// Настройка режима пина
$pin->makeInput();  // Устанавливает пин в режим входа
$pin->makeOutput(); // Устанавливает пин в режим выхода

// В секцию providers
DanJohnson95\Pinout\PinoutServiceProvider::class,
 
// В секцию aliases
'PinService' => DanJohnson95\Pinout\Facades\PinService::class,

return [
    // Режим нумерации пинов
    'pin_numbering' => 'BCM',
    
    // Режим отладки
    'debug' => env('PINOUT_DEBUG', false),
    
    // Путь к интерфейсу GPIO в файловой системе
    'gpio_path' => '/sys/class/gpio',
    
    // Настройки для различных типов дисплеев
    'displays' => [
        'lcd' => [
            'rs' => 25,
            'en' => 24,
            'data' => [23, 22, 21, 20],
        ],
        'seven_segment' => [
            'type' => '7447',
            'pins' => [14, 15, 18, 23],
        ],
    ],
];

app/
 ├── Services/
 │    ├── Hardware/
 │    │    ├── LedController.php
 │    │    ├── SensorReader.php
 │    │    └── DisplayManager.php
 │    └── ...
 ├── Console/
 │    └── Commands/
 │         ├── MonitorTemperature.php
 │         └── ...
 └── ...

use \DanJohnson95\Pinout\Facades\PinService;
 
// Получение объекта пина по его номеру
$pin = PinService::pin(13);

// Настройка пина на вывод (для управления внешними устройствами)
$pin->makeOutput();
 
// Настройка пина на ввод (для считывания состояния кнопок, датчиков и т.д.)
$pin->makeInput();

// Установка высокого уровня сигнала
$pin->turnOn();
 
// Установка низкого уровня сигнала
$pin->turnOff();
 
// Переключение текущего состояния на противоположное
$pin->toggle();

// Проверка, находится ли пин в состоянии HIGH
if ($pin->isOn()) {
    // Код, выполняемый, если пин активирован
}
 
// Проверка, находится ли пин в состоянии LOW
if ($pin->isOff()) {
    // Код, выполняемый, если пин деактивирован
}

// Получение коллекции пинов
$pins = PinService::pins(13, 19, 26);
 
// Настройка всех пинов на вывод
$pins->makeOutput();
 
// Активация всех пинов
$pins->turnOn();
 
// Деактивация всех пинов
$pins->turnOff();

try {
    $pin = PinService::pin(999); // Несуществующий пин
    $pin->turnOn();
} catch (\DanJohnson95\Pinout\Exceptions\InvalidPinException $e) {
    // Обработка ошибки неверного номера пина
    Log::error('Ошибка GPIO: ' . $e->getMessage());
} catch (\DanJohnson95\Pinout\Exceptions\PinAccessException $e) {
    // Обработка ошибки доступа к пину
    Log::error('Ошибка доступа к GPIO: ' . $e->getMessage());
} catch (\Exception $e) {
    // Обработка других ошибок
    Log::error('Неизвестная ошибка: ' . $e->getMessage());
}

'channels' => [
    // Другие каналы...
    
    'gpio' => [
        'driver' => 'single',
        'path' => storage_path('logs/gpio.log'),
        'level' => 'debug',
    ],
],

Log::channel('gpio')->info('Настройка пина 13 на вывод');

Route::get('/admin/gpio-status', function() {
    $pins = [];
    for ($i = 1; $i <= 26; $i++) {
        try {
            $pin = PinService::pin($i);
            $pins[$i] = [
                'mode' => $pin->isOutput() ? 'output' : 'input',
                'state' => $pin->isOn() ? 'high' : 'low'
            ];
        } catch (\Exception $e) {
            $pins[$i] = ['error' => $e->getMessage()];
        }
    }
    
    return view('admin.gpio-status', ['pins' => $pins]);
});

namespace App\Services\Hardware;
 
use DanJohnson95\Pinout\Facades\PinService;
 
class LedController
{
    protected $pin;
    
    public function __construct(int $pinNumber)
    {
        $this->pin = PinService::pin($pinNumber);
        $this->pin->makeOutput();
    }
    
    public function turnOn()
    {
        $this->pin->turnOn();
        return $this;
    }
    
    public function turnOff()
    {
        $this->pin->turnOff();
        return $this;
    }
    
    public function toggle()
    {
        if ($this->pin->isOn()) {
            $this->pin->turnOff();
        } else {
            $this->pin->turnOn();
        }
        return $this;
    }
    
    public function blink(int $times = 5, float $interval = 0.5)
    {
        for ($i = 0; $i < $times; $i++) {
            $this->turnOn();
            usleep($interval * 1000000);
            $this->turnOff();
            if ($i < $times - 1) {
                usleep($interval * 1000000);
            }
        }
        return $this;
    }
}

$led = new LedController(17); // GPIO17
$led->blink(10, 0.2); // Мигаем 10 раз с интервалом 0.2 секунды

class RgbLed
{
    protected $redPin;
    protected $greenPin;
    protected $bluePin;
    
    public function __construct(int $redPinNumber, int $greenPinNumber, int $bluePinNumber)
    {
        $this->redPin = PinService::pin($redPinNumber);
        $this->greenPin = PinService::pin($greenPinNumber);
        $this->bluePin = PinService::pin($bluePinNumber);
        
        $this->redPin->makeOutput();
        $this->greenPin->makeOutput();
        $this->bluePin->makeOutput();
        
        // Начальное состояние - всё выключено
        $this->off();
    }
    
    public function off()
    {
        $this->redPin->turnOff();
        $this->greenPin->turnOff();
        $this->bluePin->turnOff();
        return $this;
    }
    
    public function setColor(bool $red, bool $green, bool $blue)
    {
        $red ? $this->redPin->turnOn() : $this->redPin->turnOff();
        $green ? $this->greenPin->turnOn() : $this->greenPin->turnOff();
        $blue ? $this->bluePin->turnOn() : $this->bluePin->turnOff();
        return $this;
    }
    
    // Предустановленные цвета
    public function red() { return $this->setColor(true, false, false); }
    public function green() { return $this->setColor(false, true, false); }
    public function blue() { return $this->setColor(false, false, true); }
    public function yellow() { return $this->setColor(true, true, false); }
    public function purple() { return $this->setColor(true, false, true); }
    public function cyan() { return $this->setColor(false, true, true); }
    public function white() { return $this->setColor(true, true, true); }
    
    // Плавная смена цветов
    public function rainbow(int $duration = 5)
    {
        $colors = [
            [$this, 'red'], [$this, 'yellow'], [$this, 'green'], 
            [$this, 'cyan'], [$this, 'blue'], [$this, 'purple']
        ];
        
        $interval = $duration / count($colors);
        
        foreach ($colors as $color) {
            call_user_func($color);
            sleep($interval);
        }
        
        return $this;
    }
}

namespace App\Services\Hardware;
 
use DanJohnson95\Pinout\Facades\PinService;
 
class ButtonReader
{
    protected $pin;
    protected $isPullup;
    
    public function __construct(int $pinNumber, bool $pullup = true)
    {
        $this->pin = PinService::pin($pinNumber);
        $this->pin->makeInput();
        $this->isPullup = $pullup;
    }
    
    public function isPressed()
    {
        // Для кнопок с подтягивающим резистором логика инвертирована:
        // LOW означает нажатие кнопки
        return $this->isPullup ? $this->pin->isOff() : $this->pin->isOn();
    }
    
    public function waitForPress($timeout = null)
    {
        $startTime = time();
        while (!$this->isPressed()) {
            if ($timeout !== null && (time() - $startTime > $timeout)) {
                return false;
            }
            usleep(10000); // Пауза 10мс чтобы не нагружать CPU
        }
        return true;
    }
    
    public function waitForRelease($timeout = null)
    {
        $startTime = time();
        while ($this->isPressed()) {
            if ($timeout !== null && (time() - $startTime > $timeout)) {
                return false;
            }
            usleep(10000);
        }
        return true;
    }
}

$button = new ButtonReader(18); // Кнопка на GPIO18
 
if ($button->isPressed()) {
    // Выполнить действие при нажатии кнопки
}
 
// Ожидать нажатия кнопки с таймаутом 5 секунд
if ($button->waitForPress(5)) {
    // Кнопка была нажата
} else {
    // Время ожидания истекло
}

namespace App\Services\Hardware;
 
use DanJohnson95\Pinout\Facades\PinService;
use App\Services\Hardware\DhtReader; // Гипотетическая библиотека для работы с DHT
 
class TemperatureMonitor
{
    protected $sensor;
    protected $readings = [];
    protected $maxReadings = 100;
    
    public function __construct(int $pinNumber, string $sensorType = 'DHT22')
    {
        $this->sensor = new DhtReader($pinNumber, $sensorType);
    }
    
    public function read()
    {
        $data = $this->sensor->read();
        
        if (count($this->readings) >= $this->maxReadings) {
            array_shift($this->readings);
        }
        
        $this->readings[] = [
            'timestamp' => now(),
            'temperature' => $data['temperature'],
            'humidity' => $data['humidity']
        ];
        
        return $data;
    }
    
    public function getHistory()
    {
        return $this->readings;
    }
    
    public function getAverage($hours = 1)
    {
        $cutoff = now()->subHours($hours);
        $filteredReadings = array_filter($this->readings, function($reading) use ($cutoff) {
            return $reading['timestamp']->isAfter($cutoff);
        });
        
        if (empty($filteredReadings)) {
            return null;
        }
        
        $tempSum = $humSum = 0;
        foreach ($filteredReadings as $reading) {
            $tempSum += $reading['temperature'];
            $humSum += $reading['humidity'];
        }
        
        $count = count($filteredReadings);
        return [
            'temperature' => $tempSum / $count,
            'humidity' => $humSum / $count
        ];
    }
}

use DanJohnson95\Pinout\Facades\PinService;
 
// Получаем экземпляр семисегментного дисплея
$display = PinService::getSevenSegmentDisplay();
 
// Отображаем цифру
$display->showDigit(5);
 
// Отображаем последовательность цифр
for ($i = 0; $i <= 9; $i++) {
    $display->showDigit($i);
    sleep(1);
}

use DanJohnson95\Pinout\Facades\PinService;
 
// Получаем экземпляр LCD-дисплея
$lcd = PinService::getLcdDisplay();
 
// Очистка дисплея
$lcd->clear();
 
// Вывод текста
$lcd->write('Hello, World!');
 
// Вывод текста в определённой позиции (строка, столбец)
$lcd->writeAt('Laravel + IoT', 1, 0);
 
// Создание собственных символов
$lcd->createChar(0, [
    0b00000,
    0b01010,
    0b01010,
    0b00000,
    0b10001,
    0b10001,
    0b01110,
    0b00000
]);
 
// Использование созданного символа
$lcd->writeChar(0);

use App\Services\Hardware\TemperatureMonitor;
use App\Services\Hardware\LedController;
use DanJohnson95\Pinout\Facades\PinService;
 
class WeatherStation
{
    protected $tempMonitor;
    protected $display;
    protected $alertLed;
    protected $highTempThreshold = 30;
    
    public function __construct()
    {
        $this->tempMonitor = new TemperatureMonitor(4); // DHT22 на GPIO4
        $this->display = PinService::getLcdDisplay();
        $this->alertLed = new LedController(17); // Красный LED на GPIO17
    }
    
    public function update()
    {
        $data = $this->tempMonitor->read();
        
        $this->display->clear();
        $this->display->writeAt("Temp: {$data['temperature']}C", 0, 0);
        $this->display->writeAt("Hum: {$data['humidity']}%", 1, 0);
        
        if ($data['temperature'] > $this->highTempThreshold) {
            $this->alertLed->turnOn();
        } else {
            $this->alertLed->turnOff();
        }
    }
    
    public function run($interval = 60)
    {
        while (true) {
            $this->update();
            sleep($interval);
        }
    }
}

namespace App\Services\SmartHome;
 
use DanJohnson95\Pinout\Facades\PinService;
 
class LightingSystem
{
    protected $lights = [];
    
    public function addLight(string $name, int $pinNumber)
    {
        $pin = PinService::pin($pinNumber);
        $pin->makeOutput();
        $this->lights[$name] = $pin;
        return $this;
    }
    
    public function turnOn(string $name)
    {
        if (isset($this->lights[$name])) {
            $this->lights[$name]->turnOn();
            return true;
        }
        return false;
    }
    
    public function turnOff(string $name)
    {
        if (isset($this->lights[$name])) {
            $this->lights[$name]->turnOff();
            return true;
        }
        return false;
    }
    
    public function toggle(string $name)
    {
        if (isset($this->lights[$name])) {
            if ($this->lights[$name]->isOn()) {
                $this->lights[$name]->turnOff();
            } else {
                $this->lights[$name]->turnOn();
            }
            return true;
        }
        return false;
    }
    
    public function getStatus(string $name)
    {
        if (isset($this->lights[$name])) {
            return $this->lights[$name]->isOn();
        }
        return null;
    }
    
    public function getAllStatus()
    {
        $status = [];
        foreach ($this->lights as $name => $pin) {
            $status[$name] = $pin->isOn();
        }
        return $status;
    }
}

class SecuritySystem
{
    protected $motionSensors = [];
    protected $doorSensors = [];
    protected $alarm;
    
    public function __construct(int $alarmPinNumber)
    {
        $this->alarm = PinService::pin($alarmPinNumber);
        $this->alarm->makeOutput();
        $this->alarm->turnOff(); // По умолчанию тревога выключена
    }
    
    public function addMotionSensor(string $location, int $pinNumber)
    {
        $pin = PinService::pin($pinNumber);
        $pin->makeInput();
        $this->motionSensors[$location] = $pin;
        return $this;
    }
    
    public function addDoorSensor(string $doorName, int $pinNumber)
    {
        $pin = PinService::pin($pinNumber);
        $pin->makeInput();
        $this->doorSensors[$doorName] = $pin;
        return $this;
    }
    
    public function checkMotion(string $location = null)
    {
        if ($location) {
            return isset($this->motionSensors[$location]) && $this->motionSensors[$location]->isOn();
        }
        
        // Проверка всех датчиков движения
        foreach ($this->motionSensors as $sensor) {
            if ($sensor->isOn()) {
                return true;
            }
        }
        return false;
    }
    
    public function checkDoors(string $doorName = null)
    {
        if ($doorName) {
            return isset($this->doorSensors[$doorName]) && $this->doorSensors[$doorName]->isOn();
        }
        
        // Проверка всех дверных датчиков
        foreach ($this->doorSensors as $sensor) {
            if ($sensor->isOn()) {
                return true;
            }
        }
        return false;
    }
    
    public function triggerAlarm()
    {
        $this->alarm->turnOn();
        return $this;
    }
    
    public function disableAlarm()
    {
        $this->alarm->turnOff();
        return $this;
    }
}

class SmartHomeController
{
    protected $lighting;
    protected $security;
    protected $temperature;
    protected $isArmed = false;
    
    public function __construct(
        LightingSystem $lighting,
        SecuritySystem $security,
        TemperatureMonitor $temperature
    ) {
        $this->lighting = $lighting;
        $this->security = $security;
        $this->temperature = $temperature;
    }
    
    public function arm()
    {
        $this->isArmed = true;
        // Выключаем всё освещение при активации охраны
        foreach ($this->lighting->getAllStatus() as $light => $status) {
            if ($status) {
                $this->lighting->turnOff($light);
            }
        }
        return $this;
    }
    
    public function disarm()
    {
        $this->isArmed = false;
        $this->security->disableAlarm();
        return $this;
    }
    
    public function monitor()
    {
        // Мониторинг безопасности
        if ($this->isArmed && ($this->security->checkMotion() || $this->security->checkDoors())) {
            $this->security->triggerAlarm();
            
            // Здесь можно добавить отправку уведомлений
            // например, через SMS, email или push-уведомления
            
            // Включаем всё освещение при тревоге
            foreach ($this->lighting->getAllStatus() as $light => $status) {
                if (!$status) {
                    $this->lighting->turnOn($light);
                }
            }
        }
        
        // Мониторинг температуры
        $data = $this->temperature->read();
        return [
            'armed' => $this->isArmed,
            'alarm' => $this->security->isAlarmActive(),
            'temperature' => $data['temperature'],
            'humidity' => $data['humidity'],
            'lights' => $this->lighting->getAllStatus()
        ];
    }
}

namespace App\Http\Controllers;
 
use App\Services\SmartHome\SmartHomeController;
use Illuminate\Http\Request;
 
class SmartHomeApiController extends Controller
{
    protected $smartHome;
    
    public function __construct(SmartHomeController $smartHome)
    {
        $this->smartHome = $smartHome;
    }
    
    public function getStatus()
    {
        return response()->json($this->smartHome->monitor());
    }
    
    public function toggleLight(Request $request, $name)
    {
        if ($this->smartHome->lighting->toggle($name)) {
            return response()->json(['status' => 'success']);
        }
        return response()->json(['status' => 'error', 'message' => 'Light not found'], 404);
    }
    
    public function arm()
    {
        $this->smartHome->arm();
        return response()->json(['status' => 'success', 'armed' => true]);
    }
    
    public function disarm()
    {
        $this->smartHome->disarm();
        return response()->json(['status' => 'success', 'armed' => false]);
    }
}

namespace App\Services\Garden;
 
use DanJohnson95\Pinout\Facades\PinService;
use Illuminate\Support\Facades\Log;
 
class AutomaticWateringSystem
{
    protected $moistureSensors = [];
    protected $pumps = [];
    protected $thresholds = [];
    
    public function addPlant(string $name, int $sensorPin, int $pumpPin, int $threshold = 30)
    {
        $sensor = PinService::pin($sensorPin);
        $sensor->makeInput();
        
        $pump = PinService::pin($pumpPin);
        $pump->makeOutput();
        $pump->turnOff(); // По умолчанию насос выключен
        
        $this->moistureSensors[$name] = $sensor;
        $this->pumps[$name] = $pump;
        $this->thresholds[$name] = $threshold;
        
        return $this;
    }
    
    public function checkMoisture(string $plantName)
    {
        if (!isset($this->moistureSensors[$plantName])) {
            return null;
        }
        
        // Предполагаем, что значение датчика влажности почвы
        // напрямую соответствует процентному значению (0-100%)
        // В реальной ситуации может потребоваться более сложное преобразование
        $analogValue = $this->readAnalogValue($this->moistureSensors[$plantName]);
        return $analogValue;
    }
    
    protected function readAnalogValue($pin)
    {
        // Этот метод зависит от конкретного типа датчика влажности почвы
        // и может требовать работы с ADC (аналого-цифровым преобразователем)
        // В данном примере предполагаем, что мы уже получаем значение 0-100
        return rand(0, 100); // Заглушка для примера
    }
    
    public function waterPlant(string $plantName, int $duration = 5)
    {
        if (!isset($this->pumps[$plantName])) {
            return false;
        }
        
        $this->pumps[$plantName]->turnOn();
        Log::info("Watering plant: {$plantName}");
        
        // В реальном приложении лучше использовать очереди или задания
        // вместо sleep() для избежания блокировки процесса
        sleep($duration);
        
        $this->pumps[$plantName]->turnOff();
        Log::info("Finished watering plant: {$plantName}");
        
        return true;
    }
    
    public function checkAndWaterIfNeeded()
    {
        $report = [];
        
        foreach ($this->moistureSensors as $name => $sensor) {
            $moisture = $this->checkMoisture($name);
            $threshold = $this->thresholds[$name];
            
            $report[$name] = [
                'moisture' => $moisture,
                'threshold' => $threshold,
                'watered' => false
            ];
            
            if ($moisture < $threshold) {
                $this->waterPlant($name);
                $report[$name]['watered'] = true;
            }
        }
        
        return $report;
    }
}

namespace App\Console\Commands;
 
use App\Services\Garden\AutomaticWateringSystem;
use Illuminate\Console\Command;
 
class WaterPlantsCommand extends Command
{
    protected $signature = 'garden:water';
    protected $description = 'Check soil moisture and water plants if needed';
    
    protected $wateringSystem;
    
    public function __construct(AutomaticWateringSystem $wateringSystem)
    {
        parent::__construct();
        $this->wateringSystem = $wateringSystem;
    }
    
    public function handle()
    {
        $this->info('Checking plants...');
        $report = $this->wateringSystem->checkAndWaterIfNeeded();
        
        foreach ($report as $plant => $data) {
            $this->info("Plant: {$plant}");
            $this->info("- Moisture: {$data['moisture']}%");
            $this->info("- Threshold: {$data['threshold']}%");
            $this->info("- Watered: " . ($data['watered'] ? 'Yes' : 'No'));
            $this->info("---");
        }
        
        return 0;
    }
}

namespace App\Services\IoT;
 
use DanJohnson95\Pinout\Facades\PinService;
use PhpMqtt\Client\Facades\MQTT; // Предполагается использование пакета php-mqtt/laravel
 
class MqttDeviceController
{
    protected $outputPins = [];
    protected $inputPins = [];
    protected $topicPrefix;
    
    public function __construct(string $topicPrefix = 'home/devices/')
    {
        $this->topicPrefix = $topicPrefix;
    }
    
    public function registerOutputDevice(string $deviceId, int $pinNumber)
    {
        $pin = PinService::pin($pinNumber);
        $pin->makeOutput();
        $this->outputPins[$deviceId] = $pin;
        
        // Подписываемся на тему управления устройством
        MQTT::subscribe($this->topicPrefix . $deviceId . '/set', function ($topic, $message) use ($deviceId) {
            if ($message === 'on') {
                $this->outputPins[$deviceId]->turnOn();
                // Публикуем обновленное состояние
                MQTT::publish($this->topicPrefix . $deviceId . '/state', 'on');
            } elseif ($message === 'off') {
                $this->outputPins[$deviceId]->turnOff();
                // Публикуем обновленное состояние
                MQTT::publish($this->topicPrefix . $deviceId . '/state', 'off');
            }
        });
        
        return $this;
    }
    
    public function registerInputDevice(string $deviceId, int $pinNumber, int $pollInterval = 5)
    {
        $pin = PinService::pin($pinNumber);
        $pin->makeInput();
        $this->inputPins[$deviceId] = [
            'pin' => $pin,
            'interval' => $pollInterval,
            'lastState' => null
        ];
        
        return $this;
    }
    
    public function startMonitoring()
    {
        // В реальном приложении лучше использовать Event Loop или Worker
        while (true) {
            foreach ($this->inputPins as $deviceId => $config) {
                $currentState = $config['pin']->isOn() ? 'on' : 'off';
                
                // Публикуем состояние только при изменении
                if ($currentState !== $config['lastState']) {
                    MQTT::publish($this->topicPrefix . $deviceId . '/state', $currentState);
                    $this->inputPins[$deviceId]['lastState'] = $currentState;
                }
                
                sleep($config['interval']);
            }
        }
    }
}

$deviceController = new MqttDeviceController();
 
// Регистрируем устройства
$deviceController->registerOutputDevice('living_room_light', 17);
$deviceController->registerOutputDevice('kitchen_light', 18);
$deviceController->registerInputDevice('front_door_sensor', 22);
$deviceController->registerInputDevice('motion_sensor', 23);
 
// Запускаем мониторинг
$deviceController->startMonitoring();

namespace App\Jobs;
 
use DanJohnson95\Pinout\Facades\PinService;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
 
class ControlDeviceJob implements ShouldQueue
{
   use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
 
   protected $pinNumber;
   protected $action;
   protected $duration;
   
   public function __construct(int $pinNumber, string $action, int $duration = null)
   {
       $this->pinNumber = $pinNumber;
       $this->action = $action;
       $this->duration = $duration;
   }
   
   public function handle()
   {
       $pin = PinService::pin($this->pinNumber);
       $pin->makeOutput();
       
       switch ($this->action) {
           case 'on':
               $pin->turnOn();
               break;
           case 'off':
               $pin->turnOff();
               break;
           case 'pulse':
               $pin->turnOn();
               if ($this->duration) {
                   sleep($this->duration);
                   $pin->turnOff();
               }
               break;
       }
   }
}

// Отправить задание в очередь
ControlDeviceJob::dispatch(17, 'on')->onQueue('hardware');
 
// Отправить с задержкой
ControlDeviceJob::dispatch(17, 'off')->delay(now()->addMinutes(5));
 
// Включить, подождать 10 секунд, выключить
ControlDeviceJob::dispatch(17, 'pulse', 10);

use Illuminate\Support\Facades\Bus;
 
Bus::chain([
   new ControlDeviceJob(17, 'on'),
   new ControlDeviceJob(18, 'on'),
   new ControlDeviceJob(19, 'on'),
])->dispatch();

namespace App\Http\Controllers\Api;
 
use App\Http\Controllers\Controller;
use DanJohnson95\Pinout\Facades\PinService;
use Illuminate\Http\Request;
use App\Jobs\ControlDeviceJob;
 
class DeviceController extends Controller
{
   public function index()
   {
       $devices = config('devices.list');
       $statuses = [];
       
       foreach ($devices as $id => $device) {
           $pin = PinService::pin($device['pin']);
           $statuses[$id] = [
               'name' => $device['name'],
               'type' => $device['type'],
               'status' => $pin->isOn() ? 'on' : 'off'
           ];
       }
       
       return response()->json($statuses);
   }
   
   public function show($id)
   {
       $device = config("devices.list.{$id}");
       
       if (!$device) {
           return response()->json(['error' => 'Device not found'], 404);
       }
       
       $pin = PinService::pin($device['pin']);
       
       return response()->json([
           'id' => $id,
           'name' => $device['name'],
           'type' => $device['type'],
           'status' => $pin->isOn() ? 'on' : 'off'
       ]);
   }
   
   public function update(Request $request, $id)
   {
       $device = config("devices.list.{$id}");
       
       if (!$device) {
           return response()->json(['error' => 'Device not found'], 404);
       }
       
       $action = $request->input('action');
       
       if (!in_array($action, ['on', 'off', 'toggle', 'pulse'])) {
           return response()->json(['error' => 'Invalid action'], 400);
       }
       
       $duration = $request->input('duration');
       
       // Асинхронное выполнение действия
       ControlDeviceJob::dispatch($device['pin'], $action, $duration);
       
       return response()->json([
           'message' => "Action '{$action}' scheduled for device '{$device['name']}'",
           'status' => 'pending'
       ]);
   }
}

Route::prefix('devices')->group(function () {
   Route::get('/', 'Api\DeviceController@index');
   Route::get('/{id}', 'Api\DeviceController@show');
   Route::put('/{id}', 'Api\DeviceController@update');
});

namespace App\Events;
 
use Illuminate\Broadcasting\Channel;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;
 
class SensorValueChanged implements ShouldBroadcast
{
   use Dispatchable, InteractsWithSockets, SerializesModels;
 
   public $sensorId;
   public $value;
   public $timestamp;
   
   public function __construct(string $sensorId, $value)
   {
       $this->sensorId = $sensorId;
       $this->value = $value;
       $this->timestamp = now();
   }
   
   public function broadcastOn()
   {
       return new Channel('sensors');
   }
   
   public function broadcastAs()
   {
       return 'sensor.value.changed';
   }
}

namespace App\Services;
 
use App\Events\SensorValueChanged;
use DanJohnson95\Pinout\Facades\PinService;
 
class SensorMonitor
{
   protected $sensors = [];
   protected $lastValues = [];
   protected $thresholds = [];
   
   public function register(string $id, int $pinNumber, float $threshold = 0.1)
   {
       $pin = PinService::pin($pinNumber);
       $pin->makeInput();
       
       $this->sensors[$id] = $pin;
       $this->thresholds[$id] = $threshold;
       $this->lastValues[$id] = null;
       
       return $this;
   }
   
   public function monitorCycle()
   {
       foreach ($this->sensors as $id => $pin) {
           $value = $this->readSensorValue($pin);
           
           // Если значение изменилось существенно или это первое чтение
           if ($this->lastValues[$id] === null || 
               abs($value - $this->lastValues[$id]) >= $this->thresholds[$id]) {
               
               // Сохраняем новое значение
               $this->lastValues[$id] = $value;
               
               // Генерируем событие
               event(new SensorValueChanged($id, $value));
           }
       }
   }
   
   protected function readSensorValue($pin)
   {
       // В реальном приложении здесь может быть более сложная логика
       // например, чтение с аналогового датчика через АЦП
       return $pin->isOn() ? 1.0 : 0.0;
   }
}

namespace App\Listeners;
 
use App\Events\SensorValueChanged;
use App\Jobs\ControlDeviceJob;
use Illuminate\Contracts\Queue\ShouldQueue;
 
class ActivateDeviceOnSensorTrigger implements ShouldQueue
{
   public function handle(SensorValueChanged $event)
   {
       // Пример: включаем свет при срабатывании датчика движения
       if ($event->sensorId === 'motion_living_room' && $event->value > 0.5) {
           ControlDeviceJob::dispatch(17, 'on')->onQueue('hardware');
           
           // Выключаем через 5 минут
           ControlDeviceJob::dispatch(17, 'off')
               ->delay(now()->addMinutes(5))
               ->onQueue('hardware');
       }
   }
}

protected $listen = [
    'App\Events\SensorValueChanged' => [
        'App\Listeners\ActivateDeviceOnSensorTrigger',
        'App\Listeners\LogSensorData',
        'App\Listeners\NotifyOnAbnormalValues',
    ],
];

namespace App\Services\IoT;
 
use Illuminate\Support\Facades\Http;
 
class RemoteController
{
   protected $ipAddress;
   protected $apiKey;
   
   public function __construct(string $ipAddress, string $apiKey)
   {
       $this->ipAddress = $ipAddress;
       $this->apiKey = $apiKey;
   }
   
   public function executeAction(string $deviceId, string $action, array $parameters = [])
   {
       $response = Http::withHeaders([
           'Authorization' => "Bearer {$this->apiKey}",
           'Accept' => 'application/json',
       ])->post("http://{$this->ipAddress}/api/devices/{$deviceId}/action", [
           'action' => $action,
           'parameters' => $parameters,
       ]);
       
       if ($response->successful()) {
           return $response->json();
       }
       
       throw new \Exception("Failed to execute action on remote controller: {$response->body()}");
   }
   
   public function getStatus(string $deviceId = null)
   {
       $endpoint = "http://{$this->ipAddress}/api/devices";
       
       if ($deviceId) {
           $endpoint .= "/{$deviceId}";
       }
       
       $response = Http::withHeaders([
           'Authorization' => "Bearer {$this->apiKey}",
           'Accept' => 'application/json',
       ])->get($endpoint);
       
       if ($response->successful()) {
           return $response->json();
       }
       
       throw new \Exception("Failed to get status from remote controller: {$response->body()}");
   }
}

namespace App\Services\IoT;
 
class ControllerManager
{
   protected $controllers = [];
   protected $deviceMapping = [];
   
   public function registerController(string $controllerId, string $ipAddress, string $apiKey)
   {
       $this->controllers[$controllerId] = new RemoteController($ipAddress, $apiKey);
       return $this;
   }
   
   public function mapDeviceToController(string $deviceId, string $controllerId, string $remoteDeviceId = null)
   {
       if (!isset($this->controllers[$controllerId])) {
           throw new \Exception("Controller '{$controllerId}' not registered");
       }
       
       $this->deviceMapping[$deviceId] = [
           'controller' => $controllerId,
           'remote_id' => $remoteDeviceId ?? $deviceId
       ];
       
       return $this;
   }
   
   public function executeDeviceAction(string $deviceId, string $action, array $parameters = [])
   {
       if (!isset($this->deviceMapping[$deviceId])) {
           throw new \Exception("Device '{$deviceId}' not mapped to any controller");
       }
       
       $mapping = $this->deviceMapping[$deviceId];
       $controller = $this->controllers[$mapping['controller']];
       
       return $controller->executeAction($mapping['remote_id'], $action, $parameters);
   }
   
   public function getDeviceStatus(string $deviceId)
   {
       if (!isset($this->deviceMapping[$deviceId])) {
           throw new \Exception("Device '{$deviceId}' not mapped to any controller");
       }
       
       $mapping = $this->deviceMapping[$deviceId];
       $controller = $this->controllers[$mapping['controller']];
       
       return $controller->getStatus($mapping['remote_id']);
   }
   
   public function getAllStatuses()
   {
       $statuses = [];
       
       foreach ($this->deviceMapping as $deviceId => $mapping) {
           try {
               $statuses[$deviceId] = $this->getDeviceStatus($deviceId);
           } catch (\Exception $e) {
               $statuses[$deviceId] = ['error' => $e->getMessage()];
           }
       }
       
       return $statuses;
   }
}

$manager = new ControllerManager();
 
// Регистрируем контроллеры
$manager->registerController('living_room', '192.168.1.101', 'api_key_1')
        ->registerController('garage', '192.168.1.102', 'api_key_2')
        ->registerController('garden', '192.168.1.103', 'api_key_3');
 
// Сопоставляем устройства с контроллерами
$manager->mapDeviceToController('main_light', 'living_room', 'ceiling_light')
        ->mapDeviceToController('reading_lamp', 'living_room', 'corner_lamp')
        ->mapDeviceToController('garage_door', 'garage', 'door')
        ->mapDeviceToController('irrigation', 'garden', 'water_system');
 
// Единый интерфейс для управления всеми устройствами
$manager->executeDeviceAction('main_light', 'turn_on');
$manager->executeDeviceAction('irrigation', 'schedule', ['duration' => 30, 'start_time' => '06:00']);
 
// Получение статуса всех устройств
$statuses = $manager->getAllStatuses();

interface ControlStrategy
{
    public function execute($device);
}
 
class TimeBasedStrategy implements ControlStrategy
{
    protected $schedule;
    
    public function __construct(array $schedule)
    {
        $this->schedule = $schedule;
    }
    
    public function execute($device)
    {
        $currentHour = now()->hour;
        
        if (isset($this->schedule[$currentHour])) {
            $action = $this->schedule[$currentHour];
            return $device->execute($action);
        }
        
        return null;
    }
}
 
class SensorBasedStrategy implements ControlStrategy
{
    protected $sensorId;
    protected $threshold;
    protected $action;
    
    public function __construct(string $sensorId, float $threshold, string $action)
    {
        $this->sensorId = $sensorId;
        $this->threshold = $threshold;
        $this->action = $action;
    }
    
    public function execute($device)
    {
        $sensorValue = app(SensorMonitor::class)->getValue($this->sensorId);
        
        if ($sensorValue >= $this->threshold) {
            return $device->execute($this->action);
        }
        
        return null;
    }
}

// Публикатор события
class TemperatureSensor
{
    protected $pin;
    protected $id;
    
    public function __construct(string $id, int $pinNumber)
    {
        $this->id = $id;
        $this->pin = PinService::pin($pinNumber);
        $this->pin->makeInput();
    }
    
    public function read()
    {
        // Логика чтения температуры
        $temperature = $this->simulateTemperatureReading();
        
        // Публикуем событие
        event(new TemperatureChanged($this->id, $temperature));
        
        return $temperature;
    }
    
    protected function simulateTemperatureReading()
    {
        // В реальном устройстве здесь была бы логика чтения с датчика
        return 20 + rand(-5, 5);
    }
}
 
// Слушатель события
class TemperatureLogger
{
    public function handle(TemperatureChanged $event)
    {
        Log::info("Temperature changed for sensor {$event->sensorId}: {$event->temperature}°C");
    }
}

interface DeviceCommand
{
    public function execute();
    public function undo();
}
 
class TurnOnCommand implements DeviceCommand
{
    protected $device;
    
    public function __construct($device)
    {
        $this->device = $device;
    }
    
    public function execute()
    {
        return $this->device->turnOn();
    }
    
    public function undo()
    {
        return $this->device->turnOff();
    }
}
 
class AdjustBrightnessCommand implements DeviceCommand
{
    protected $device;
    protected $level;
    protected $previousLevel;
    
    public function __construct($device, $level)
    {
        $this->device = $device;
        $this->level = $level;
    }
    
    public function execute()
    {
        $this->previousLevel = $this->device->getBrightness();
        return $this->device->setBrightness($this->level);
    }
    
    public function undo()
    {
        return $this->device->setBrightness($this->previousLevel);
    }
}
 
class MacroCommand implements DeviceCommand
{
    protected $commands = [];
    
    public function add(DeviceCommand $command)
    {
        $this->commands[] = $command;
        return $this;
    }
    
    public function execute()
    {
        foreach ($this->commands as $command) {
            $command->execute();
        }
    }
    
    public function undo()
    {
        foreach (array_reverse($this->commands) as $command) {
            $command->undo();
        }
    }
}

try {
    $pin = PinService::pin(18);
    $pin->makeOutput();
    $pin->turnOn();
    // Светодиод не загорелся? Проблема может быть физической
} catch (\Exception $e) {
    Log::error('GPIO error: ' . $e->getMessage());
}

$pin = PinService::pin(18);
$pin->makeOutput();
 
for ($i = 0; $i < 10; $i++) {
    $pin->turnOn();
    echo "Pin ON\n";
    sleep(1);
    $pin->turnOff();
    echo "Pin OFF\n";
    sleep(1);
}

Error: Failed to open GPIO device: Permission denied

// Пин 18 в системе BCM != пин 18 в системе BOARD
$pin = PinService::pin(18); // Какую систему нумерации использует Pinout?

'pin_numbering' => 'BCM', // или 'BOARD'

Error: Failed to export GPIO pin: Device or resource busy

use Illuminate\Support\Facades\Cache;
 
$lockKey = 'gpio_pin_' . $pinNumber;
 
if (Cache::lock($lockKey, 10)->get()) {
    try {
        // Операции с пином
        $pin = PinService::pin($pinNumber);
        $pin->makeOutput();
        $pin->turnOn();
    } finally {
        Cache::lock($lockKey)->release();
    }
} else {
    Log::warning("Pin $pinNumber is busy");
}

// config/pinout.php
'debug' => true,

// В обработчике исключений
try {
    $pin = PinService::pin($pinNumber);
    // Операции с пином
} catch (\Exception $e) {
    Log::channel('gpio')->error('GPIO error', [
        'pin' => $pinNumber,
        'operation' => 'turnOn',
        'exception' => $e->getMessage(),
        'trace' => $e->getTraceAsString(),
    ]);
}

// Плохо: блокирует запрос
$pin->turnOn();
sleep(5);
$pin->turnOff();

// В контроллере
public function pulseLed()
{
    PulseLedJob::dispatch(18, 5);
    return response()->json(['status' => 'scheduled']);
}
 
// В задании
class PulseLedJob implements ShouldQueue
{
    protected $pinNumber;
    protected $duration;
    
    public function __construct($pinNumber, $duration)
    {
        $this->pinNumber = $pinNumber;
        $this->duration = $duration;
    }
    
    public function handle()
    {
        $pin = PinService::pin($this->pinNumber);
        $pin->makeOutput();
        $pin->turnOn();
        sleep($this->duration);
        $pin->turnOff();
    }
}

class CachedPinService
{
    protected $pinStates = [];
    
    public function pin($number)
    {
        if (!isset($this->pinStates[$number])) {
            $this->pinStates[$number] = [
                'mode' => null,
                'state' => null
            ];
        }
        
        return new CachedPin($number, $this->pinStates[$number]);
    }
}
 
class CachedPin
{
    protected $pin;
    protected $cache;
    
    public function __construct($number, &$cache)
    {
        $this->pin = PinService::pin($number);
        $this->cache = &$cache;
    }
    
    public function turnOn()
    {
        if ($this->cache['state'] !== 'on') {
            $this->pin->turnOn();
            $this->cache['state'] = 'on';
        }
    }
    
    // Аналогично для других методов
}

// Вместо этого:
PinService::pin(17)->makeOutput()->turnOn();
PinService::pin(18)->makeOutput()->turnOn();
PinService::pin(19)->makeOutput()->turnOn();
 
// Используйте это:
PinService::pins(17, 18, 19)->makeOutput()->turnOn();

// Вместо высокочастотного опроса:
while (true) {
    $value = $pin->isOn();
    // Обработка
    usleep(10000); // 10 мс
}
 
// Используйте адаптивный интервал:
$interval = 1000000; // 1 секунда
$minInterval = 10000; // 10 мс
$maxInterval = 5000000; // 5 секунд
 
$lastValue = null;
$unchanged = 0;
 
while (true) {
    $value = $pin->isOn();
    
    if ($value !== $lastValue) {
        // Значение изменилось — обрабатываем и увеличиваем частоту опроса
        processChange($value);
        $interval = $minInterval;
        $unchanged = 0;
    } else {
        // Значение не изменилось — постепенно уменьшаем частоту опроса
        $unchanged++;
        if ($unchanged > 10) {
            $interval = min($maxInterval, $interval * 1.5);
        }
    }
    
    $lastValue = $value;
    usleep($interval);
}

// Не подключайте напрямую высоковольтные устройства к GPIO!
// Используйте промежуточное реле
class RelayController
{
    protected $controlPin;
    
    public function __construct(int $pinNumber)
    {
        $this->controlPin = PinService::pin($pinNumber);
        $this->controlPin->makeOutput();
        $this->turnOff(); // По умолчанию выключено
    }
    
    public function turnOn()
    {
        Log::info("Activating relay on pin {$this->controlPin->getNumber()}");
        $this->controlPin->turnOn();
    }
    
    public function turnOff()
    {
        $this->controlPin->turnOff();
    }
}