// Пример кода JavaScript

// Установка зависимостей
npm install mqtt

// Настройка и подключение
// Настройки MQTT
const username = 'CENTRAL';
const machineNum = '001'; // уникальный для каждого устройства или подключения

const MQTT_CONFIG = {
    server: 'monet.uz',
    port: 8883,
    username: username,
    password: 'test',
    machineNum: machineNum,
    machineId: `${username}_${machineNum}`,
    userId: username,
    protocol: 'mqtts',
    rejectUnauthorized: true   
};


// MQTT клиент (используем библиотеку mqtt.js)
const mqtt = require('mqtt');
let client = null;

// Callback топик для ответов
const CALLBACK_TOPIC = `vending/response/${MQTT_CONFIG.userId}/${machineNum}`;
const REQUEST_TOPIC = 'vending/requests';

// Основные функции
// Подключение к MQTT брокеру
async function connectMQTT() {
    return new Promise((resolve, reject) => {
        const options = {
            port: MQTT_CONFIG.port,
            username: MQTT_CONFIG.username,
            password: MQTT_CONFIG.password,
            protocol: MQTT_CONFIG.protocol,
            ca: require('fs').readFileSync('/path/to/isrgrootx1.pem'), // скачайте над этим блоком примеров, 
            rejectUnauthorized: true                                  // в своем коде укажите путь к сертификату
        };

        client = mqtt.connect(`mqtts://${MQTT_CONFIG.server}`, options);

        client.on('connect', () => {
            console.log('Connected to MQTT broker');
            
            // Подписываемся на топик для ответов
            client.subscribe(CALLBACK_TOPIC, { qos: 1 }, (err) => {
                if (err) {
                    reject(err);
                } else {
                    console.log(`Subscribed to ${CALLBACK_TOPIC}`);
                    resolve(client);
                }
            });
        });

        client.on('error', (error) => {
            console.error('MQTT connection error:', error);
            reject(error);
        });

        // Обработка входящих сообщений
        client.on('message', handleIncomingMessage);
    });
}

// Функция отправки запроса на подтверждение транзакции
async function sendTransactionRequest(amount, transactionId) {
    if (!client || !client.connected) {
        await connectMQTT();
    }

    const message = {
        machine_id: MQTT_CONFIG.machineId,
        user_id: MQTT_CONFIG.userId,
        amount: parseFloat(amount),
        transaction_id: transactionId,
        callback_topic: CALLBACK_TOPIC
    };

    return new Promise((resolve, reject) => {
        client.publish(REQUEST_TOPIC, JSON.stringify(message), { qos: 1 }, (error) => {
            if (error) {
                console.error('Failed to send transaction request:', error);
                reject(error);
            } else {
                console.log('Transaction request sent:', message);
                resolve(message);
            }
        });
    });
}

// Обработка входящих MQTT сообщений
function handleIncomingMessage(topic, message) {
    console.log(`Received message on topic: ${topic}`);
    
    try {
        const data = JSON.parse(message.toString());
        
        if (topic === CALLBACK_TOPIC) {
            processTransactionResponse(data);
        }
    } catch (error) {
        console.error('Error parsing MQTT message:', error);
    }
}

// Обработка ответа о транзакции
function processTransactionResponse(response) {
    console.log('Processing transaction response:', response);
    
    const { status, transaction_id, reason } = response;
    
    switch (status) {
        case 'payment_confirmed':
            console.log(`Transaction ${transaction_id} APPROVED`);
            dispenseProduct();
            break;
            
        case 'payment_timeout':
            console.log(`Transaction ${transaction_id} TIMEUOT. Reason: ${reason}`);
            showError(`Transaction timeout: ${reason}`);
            break;
            
        default:
            console.warn('Unknown transaction status:', status);
    }
}

// Интеграция в основной код
// Генерация уникального ID транзакции
function generateTransactionId() {
    return Math.random().toString(36).substring(2, 15) + 
           Math.random().toString(36).substring(2, 15);
}

// Основная функция обработки выбора товара
async function onProductSelected(price, productId) {
    try {
        const transactionId = generateTransactionId();
        console.log(`Starting transaction ${transactionId} for ${price}`);
        
        // Отправляем запрос на подтверждение
        await sendTransactionRequest(price, transactionId);
        
        console.log('Waiting for transaction confirmation...');
        // Здесь можно показать UI "Ожидание подтверждения..."
        
    } catch (error) {
        console.error('Transaction failed:', error);
        showError('Transaction initialization failed');
    }
}

// Дополнительные функции
function dispenseProduct() {
    console.log('Dispensing product...');
    // Код выдачи товара
    // Например: управление аппаратными компонентами через GPIO
}

function showError(errorMessage) {
    console.error('Error:', errorMessage);
    // Код отображения ошибки пользователю
    // Например: показать красный индикатор или сообщение на дисплее
}

// Управление соединением
function disconnect() {
    if (client) {
        client.end();
        console.log('MQTT disconnected');
    }
}

// Обработка graceful shutdown
process.on('SIGINT', () => {
    console.log('Shutting down...');
    disconnect();
    process.exit(0);
});

// Пример использования
// Основной файл приложения
async function main() {
    try {
        // Подключаемся к MQTT
        await connectMQTT();
        console.log('Vending machine ready');
        
        // Симуляция выбора товара (в реальном приложении это будет по событию)
        setTimeout(() => {
            onProductSelected(100.00, 'A1');
        }, 3000);
        
    } catch (error) {
        console.error('Application failed to start:', error);
    }
}

// Запуск приложения
main();
                

# Пример кода Python

// Установка зависимостей
pip install paho-mqtt
# или для асинхронной версии
pip install aiomqtt

// Настройка и подключение
import paho.mqtt.client as mqtt
import json
import random
import time
from typing import Callable, Dict, Any
import ssl

# Настройки MQTT
user_id = CENTRAL
mashine_number = '001' // Уникальный для каждого устройства или запроса

MQTT_CONFIG = {
    'server': 'monet.uz',
    'port': 8883,
    'username': user_id,
    'password': 'test',
    'machine_id': f'{user_id}_{mashine_number}',
    'user_id': user_id
}

# Топики
CALLBACK_TOPIC = f"vending/response/{MQTT_CONFIG['user_id']}/{MQTT_CONFIG['machine_id']}"
REQUEST_TOPIC = "vending/requests"

// Основные функции
class VendingMachineMQTT:
    def __init__(self):
        self.client = None
        self.is_connected = False
        self.transaction_handlers = {}
        
    def connect_mqtt(self) -> bool:
        """Подключение к MQTT брокеру с SSL"""
        try:
            self.client = mqtt.Client(client_id=f"vending_{int(time.time())}")

            # Устанавливаем логин и пароль
            self.client.username_pw_set(
                MQTT_CONFIG['username'],
                MQTT_CONFIG['password']
            )

            # ----- SSL / TLS настройки -----
            # CA-файл (корневой сертификат ISRG Root X1)
            # Скачайте выше, над этим блоком примеров
            # Укажите путь к сертификату
            ca_cert_path = "/etc/mosquitto/certs/isrgrootx1.pem"

            self.client.tls_set(
                ca_certs=ca_cert_path,
                certfile=None,       
                keyfile=None,        
                tls_version=ssl.PROTOCOL_TLSv1_2,
                ciphers=None
            )

            # Требуем проверку подлинности сервера
            self.client.tls_insecure_set(False)

            # ---- Колбек-функции ----
            self.client.on_connect = self._on_connect
            self.client.on_message = self._on_message
            self.client.on_disconnect = self._on_disconnect

            # --- Подключение ---
            self.client.connect(
                MQTT_CONFIG['server'],
                MQTT_CONFIG['port'],   
                keepalive=60
            )

            self.client.loop_start()
            print("MQTT SSL connection initiated")
            return True

        except Exception as e:
            print(f"MQTT SSL connection failed: {e}")
            return False
    
    def _on_connect(self, client, userdata, flags, rc):
        """Обработчик подключения к MQTT"""
        if rc == 0:
            self.is_connected = True
            print("Connected to MQTT broker")
            # Подписываемся на топик для ответов
            client.subscribe(CALLBACK_TOPIC, qos=1)
            print(f"Subscribed to {CALLBACK_TOPIC}")
        else:
            print(f"Failed to connect, return code {rc}")
            self.is_connected = False
    
    def _on_message(self, client, userdata, msg):
        """Обработчик входящих сообщений"""
        try:
            topic = msg.topic
            payload = msg.payload.decode('utf-8')
            
            print(f"Received message on topic: {topic}")
            print(f"Message: {payload}")
            
            if topic == CALLBACK_TOPIC:
                data = json.loads(payload)
                self._process_transaction_response(data)
                
        except json.JSONDecodeError as e:
            print(f"Error parsing JSON message: {e}")
        except Exception as e:
            print(f"Error processing message: {e}")
    
    def _on_disconnect(self, client, userdata, rc):
        """Обработчик отключения от MQTT"""
        self.is_connected = False
        if rc != 0:
            print("Unexpected MQTT disconnection")
        else:
            print("MQTT disconnected")
    
    def send_transaction_request(self, amount: float, transaction_id: str) -> bool:
        """Отправка запроса на подтверждение транзакции"""
        if not self.is_connected or not self.client:
            print("MQTT not connected")
            return False
        
        try:
            message = {
                "machine_id": MQTT_CONFIG['machine_id'],
                "user_id": MQTT_CONFIG['user_id'],
                "amount": float(amount),
                "transaction_id": transaction_id,
                "callback_topic": CALLBACK_TOPIC
            }
            
            result = self.client.publish(
                REQUEST_TOPIC, 
                json.dumps(message), 
                qos=1
            )
            
            if result.rc == mqtt.MQTT_ERR_SUCCESS:
                print(f"Transaction request sent: {message}")
                return True
            else:
                print(f"Failed to send transaction request: {result.rc}")
                return False
                
        except Exception as e:
            print(f"Error sending transaction request: {e}")
            return False
    
    def _process_transaction_response(self, response: Dict[str, Any]):
        """Обработка ответа о транзакции"""
        try:
            status = response.get('status')
            transaction_id = response.get('transaction_id')
            reason = response.get('reason', 'Unknown reason')
            
            print(f"Processing transaction response: {response}")

            # Примеры ответов смотрите выше на странице
            if status == 'payment_confirmed':
                print(f"Transaction {transaction_id} APPROVED")
                self._dispense_product()
                
            elif status == 'payment_timeout':
                print(f"Transaction {transaction_id} TIMEOUT. Reason: {reason}")
                self._show_error(f"Transaction timeout: {reason}")
                
            else:
                print(f"Unknown transaction status: {status}")
                
        except Exception as e:
            print(f"Error processing transaction response: {e}")
    
    def wait_for_connection(self, timeout: int = 10) -> bool:
        """Ожидание подключения к MQTT"""
        start_time = time.time()
        while not self.is_connected and (time.time() - start_time) < timeout:
            time.sleep(0.5)
        return self.is_connected

// Интеграция в основной код
# Дополнительные функции для интеграции
def generate_transaction_id() -> str:
    """Генерация уникального ID транзакции"""
    timestamp = str(int(time.time()))
    random_suffix = ''.join(random.choices('abcdefghijklmnopqrstuvwxyz0123456789', k=8))
    return f"{timestamp}_{random_suffix}"

def on_product_selected(mqtt_client: VendingMachineMQTT, price: float, product_id: str):
    """Обработчик выбора товара"""
    try:
        transaction_id = generate_transaction_id()
        print(f"Starting transaction {transaction_id} for {price}")
        
        # Убеждаемся, что подключены к MQTT
        if not mqtt_client.is_connected:
            if not mqtt_client.wait_for_connection():
                print("Failed to connect to MQTT")
                mqtt_client._show_error("Network connection failed")
                return
        
        # Отправляем запрос на подтверждение
        success = mqtt_client.send_transaction_request(price, transaction_id)
        
        if success:
            print("Waiting for transaction confirmation...")
            # Здесь можно обновить UI "Ожидание подтверждения..."
        else:
            mqtt_client._show_error("Failed to send transaction request")
            
    except Exception as e:
        print(f"Transaction failed: {e}")
        mqtt_client._show_error("Transaction initialization failed")

# Дополнительные функции (заглушки)
def _dispense_product(self):
    """Выдача товара"""
    print("Dispensing product...")
    # Код выдачи товара
    # Например: управление аппаратными компонентами через GPIO/REST API

def _show_error(self, error_message: str):
    """Отображение ошибки"""
    print(f"Error: {error_message}")
    # Код отображения ошибки пользователю
    # Например: логирование, отправка уведомления, обновление UI

// Пример использования
# Основной файл приложения
def main():
    # Создаем экземпляр MQTT клиента
    vending_mqtt = VendingMachineMQTT()
    
    # Подключаемся к MQTT
    if vending_mqtt.connect_mqtt():
        print("Vending machine MQTT client started")
        
        # Ждем подключения
        if vending_mqtt.wait_for_connection():
            print("Successfully connected to MQTT broker")
            
            # Симуляция выбора товара (в реальном приложении это будет по событию)
            print("Simulating product selection...")
            time.sleep(2)
            on_product_selected(vending_mqtt, 100.00, "A1")
            
            # Держим программу активной
            try:
                while True:
                    time.sleep(1)
            except KeyboardInterrupt:
                print("Shutting down...")
                if vending_mqtt.client:
                    vending_mqtt.client.loop_stop()
                    vending_mqtt.client.disconnect()
        
        else:
            print("Failed to establish MQTT connection")
    else:
        print("Failed to initialize MQTT client")

if __name__ == "__main__":
    main()

// Асинхронная версия (для asyncio)
import asyncio
import ssl
import aiomqtt

class AsyncVendingMachineMQTT:
    def __init__(self):
        self.client = None

    async def connect_mqtt(self):
        """Асинхронное подключение к MQTT брокеру с TLS"""
        try:
            # ---- TLS контекст ----
            tls_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
            tls_context.load_verify_locations("/etc/mosquitto/certs/isrgrootx1.pem")
            tls_context.check_hostname = True
            tls_context.verify_mode = ssl.CERT_REQUIRED

            async with aiomqtt.Client(
                hostname=MQTT_CONFIG['server'],
                port=MQTT_CONFIG['port'],
                username=MQTT_CONFIG['username'],
                password=MQTT_CONFIG['password'],
                tls_context=tls_context
            ) as client:

                self.client = client

                # Подписка
                await client.subscribe(CALLBACK_TOPIC, qos=1)
                print("Connected to MQTT (TLS) and subscribed")

                # Получение сообщений
                async for message in client.messages:
                    await self._on_message(message)

        except Exception as e:
            print(f"Async MQTT TLS error: {e}")
                

# Пример кода MicroPython для ESP32

// Настройка и подключение
import umqtt.simple as mqtt
import ujson as json
import utime as time
import ubinascii
import machine
from machine import Pin
try:
    import ussl
    SSL_AVAILABLE = True
except ImportError:
    SSL_AVAILABLE = False
    print("SSL not available in this MicroPython build")

# Настройки MQTT
user_id = 'CENTRAL'
mashine_number = '001'
MQTT_CONFIG = {
    'server': 'monet.uz',
    'port': 8883,
    'username': user_id,
    'password': 'test',
    'machine_id': f"{user_id}_{mashine_number}",
    'user_id': user_id,
}

# Топики
CALLBACK_TOPIC = f"vending/response/{user_id}/{mashine_number}".encode()
REQUEST_TOPIC = b"vending/requests"

# Пины для управления (настройте под ваше железо)
LED_PIN = 2  # Built-in LED для индикации
ERROR_LED_PIN = 4  # Дополнительный LED для ошибок

// Основные функции
class VendingMachineMQTT:
    def __init__(self):
        self.client = None
        self.is_connected = False
        self.last_transaction_id = None
        
        # Настройка пинов для индикации
        self.led = Pin(LED_PIN, Pin.OUT)
        self.error_led = Pin(ERROR_LED_PIN, Pin.OUT)
        self.led.off()
        self.error_led.off()
    
    def connect_mqtt(self):
        """Подключение к MQTT брокеру по SSL"""
        try:
            print("Connecting to MQTT via SSL...")

            # Загружаем сертификат
            with open("/cert/isrgrootx1.pem", "rb") as f:
                ca_cert = f.read()

            # Создаем SSL-контекст
            ssl_params = {
                "ca_certs": ca_cert,  # Изменить "cert" на "ca_certs"
                "server_hostname": MQTT_CONFIG['server'],
                "cert_reqs": ssl.CERT_REQUIRED  # Добавить проверку сертификата
            }

            # Создаем MQTT клиент с TLS
            self.client = mqtt.MQTTClient(
                MQTT_CONFIG['machine_id'],  
                MQTT_CONFIG['server'],
                port=MQTT_CONFIG['port'],     
                user=MQTT_CONFIG['username'],
                password=MQTT_CONFIG['password'],
                keepalive=60,
                ssl=True,
                ssl_params=ssl_params
            )

            # callback
            self.client.set_callback(self._on_message)

            # подключение
            self.client.connect()
            self.is_connected = True

            # подписка
            self.client.subscribe(CALLBACK_TOPIC)

            print("MQTT SSL connected and subscribed")
            self._blink_led(2, 200)
            return True

        except Exception as e:
            print("MQTT SSL connection failed:", e)
            self.is_connected = False
            self._show_error_led()
            return False

    
    def _on_message(self, topic, msg):
        """Обработчик входящих сообщений"""
        try:
            print("Message received:")
            print("Topic:", topic)
            print("Message:", msg)
            
            if topic == CALLBACK_TOPIC:
                # В MicroPython используем json.loads с bytes
                data = json.loads(msg.decode('utf-8'))
                self._process_transaction_response(data)
                
        except Exception as e:
            print("Error processing message:", e)
    
    def check_messages(self):
        """Проверка новых сообщений (должна вызываться в loop)"""
        if self.is_connected and self.client:
            try:
                self.client.check_msg()
            except Exception as e:
                print("Error checking messages:", e)
                self.is_connected = False
    
    def send_transaction_request(self, amount, transaction_id):
        """Отправка запроса на подтверждение транзакции"""
        if not self.is_connected:
            print("MQTT not connected")
            return False
        
        try:
            message = {
                "machine_id": MQTT_CONFIG['machine_id'],
                "user_id": MQTT_CONFIG['user_id'],
                "amount": float(amount),
                "transaction_id": transaction_id,
                "callback_topic": CALLBACK_TOPIC.decode('utf-8')
            }
            
            # В MicroPython сообщение должно быть в bytes
            message_json = json.dumps(message)
            
            self.client.publish(REQUEST_TOPIC, message_json.encode('utf-8'))
            self.last_transaction_id = transaction_id
            
            print("Transaction request sent")
            self._blink_led(1, 100)  # Индикация отправки
            return True
            
        except Exception as e:
            print("Error sending transaction:", e)
            self._show_error_led()
            return False
    
    def _process_transaction_response(self, response):
        """Обработка ответа о транзакции"""
        try:
            status = response.get('status')
            transaction_id = response.get('transaction_id')
            message = response.get('message', 'Unknown')
            
            print("Transaction response:")
            print("Status:", status)
            print("Transaction ID:", transaction_id)
            
            if status == 'payment_confirmed':
                print("Transaction APPROVED")
                self._blink_led(3, 300)  # Индикация успеха
                self._dispense_product()
                
            elif status == 'payment_timeout':
                print("Transaction TIMEOUT, message:", message)
                self._show_error("Transaction timeout")
                
            else:
                print("Unknown status:", status)
                self._show_error("Unknown response")
                
        except Exception as e:
            print("Error processing response:", e)
            self._show_error_led()

// Интеграция в основной код
# Дополнительные функции для интеграции
def generate_transaction_id():
    """Генерация уникального ID транзакции"""
    timestamp = str(time.time())
    random_bytes = ubinascii.hexlify(machine.unique_id())[:6]
    return timestamp + "_" + random_bytes.decode('utf-8')

def on_product_selected(mqtt_client, price, product_id):
    """Обработчик выбора товара"""
    try:
        transaction_id = generate_transaction_id()
        print("Starting transaction:", transaction_id)
        print("Amount:", price)
        print("Product:", product_id)
        
        # Убеждаемся, что подключены к MQTT
        if not mqtt_client.is_connected:
            if not mqtt_client.connect_mqtt():
                mqtt_client._show_error("MQTT connection failed")
                return False
        
        # Отправляем запрос
        success = mqtt_client.send_transaction_request(price, transaction_id)
        
        if success:
            print("Waiting for confirmation...")
            # Мигаем LED пока ждем ответа
            mqtt_client._waiting_animation()
            return True
        else:
            mqtt_client._show_error("Send failed")
            return False
            
    except Exception as e:
        print("Transaction error:", e)
        mqtt_client._show_error_led()
        return False

# Дополнительные методы класса
def _blink_led(self, times, delay_ms):
    """Мигание LED указанное количество раз"""
    for i in range(times):
        self.led.on()
        time.sleep_ms(delay_ms)
        self.led.off()
        if i < times - 1:
            time.sleep_ms(delay_ms)

def _waiting_animation(self):
    """Анимация ожидания (быстрое мигание)"""
    for i in range(10):  # 10 циклов мигания
        self.led.on()
        time.sleep_ms(100)
        self.led.off()
        time.sleep_ms(100)
        
        # Проверяем сообщения во время анимации
        self.check_messages()

def _show_error_led(self):
    """Индикация ошибки"""
    for i in range(5):
        self.error_led.on()
        time.sleep_ms(200)
        self.error_led.off()
        time.sleep_ms(200)

def _dispense_product(self):
    """Выдача товара"""
    print("Dispensing product...")
    
    # Код управления мотором/серво/соленоидом
    # Например:
    # motor = Pin(12, Pin.OUT)
    # motor.on()
    # time.sleep_ms(1000)
    # motor.off()
    
    self._blink_led(5, 100)  # Индикация выдачи

def _show_error(self, message):
    """Отображение ошибки"""
    print("ERROR:", message)
    self._show_error_led()
    
    # Здесь можно добавить вывод на дисплей если есть
    # display.show_error(message)

def reconnect_if_needed(self):
    """Переподключение при необходимости"""
    if not self.is_connected:
        print("Attempting to reconnect...")
        try:
            if self.client:
                self.client.disconnect()
            return self.connect_mqtt()
        except Exception as e:
            print("Reconnection failed:", e)
            return False
    return True

// Пример основного цикла
# Основной файл main.py
def main():
    # Создаем экземпляр MQTT клиента
    vending_mqtt = VendingMachineMQTT()
    
    # Подключаемся к MQTT
    vending_mqtt.connect_mqtt()
    
    # Счетчик для демонстрации
    demo_counter = 0
    
    print("Vending machine started")
    
    # Основной цикл
    while True:
        try:
            # Проверяем сообщения
            vending_mqtt.check_messages()
            
            # Демонстрация: имитируем выбор товара каждые 30 секунд
            demo_counter += 1
            if demo_counter >= 300:  # ~30 секунд при time.sleep_ms(100)
                demo_counter = 0
                print("Demo: simulating product selection")
                on_product_selected(vending_mqtt, 100.00, "A1")
            
            # Переподключаемся если соединение потеряно
            if not vending_mqtt.is_connected:
                vending_mqtt.reconnect_if_needed()
            
            time.sleep_ms(100)  # Небольшая задержка
            
        except KeyboardInterrupt:
            print("Stopping...")
            break
        except Exception as e:
            print("Main loop error:", e)
            time.sleep_ms(1000)

# Запуск при включении
if __name__ == "__main__":
    main()

// Версия с WiFi подключением
import network
import usocket as socket

def connect_wifi(ssid, password):
    """Подключение к WiFi"""
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    
    if not wlan.isconnected():
        print('Connecting to WiFi...')
        wlan.connect(ssid, password)
        
        # Ждем подключения
        for i in range(20):
            if wlan.isconnected():
                break
            time.sleep(1)
    
    if wlan.isconnected():
        print('WiFi connected:', wlan.ifconfig())
        return True
    else:
        print('WiFi connection failed')
        return False

# Использование:
# connect_wifi('your_ssid', 'your_password')
# vending_mqtt = VendingMachineMQTT()
# vending_mqtt.connect_mqtt()