Skip to main content

POS Hardware Integrations

Connect and configure POS peripheral hardware for restaurant operations.

Overview​

Olympus Cloud supports a wide range of POS hardware for complete restaurant operations:

CategorySupported BrandsConnection Types
Receipt PrintersStar, Epson, BixolonUSB, Ethernet, Bluetooth
Kitchen PrintersStar, EpsonEthernet, USB
Cash DrawersAPG, Star, MMFPrinter-driven, USB
Card ReadersStripe, Square, CloverBluetooth, USB
Customer DisplaysLogic Controls, PartnerUSB, Serial
Barcode ScannersZebra, HoneywellUSB, Bluetooth

Architecture​

┌─────────────────────────────────────────────────────────────────┐
│                    Olympus Cloud POS Shell                       │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐        │
│  │  Orders  │  │ Payments │  │  Kitchen │  │  Reports │        │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘        │
└───────┼─────────────┼─────────────┼─────────────┼───────────────┘
        │             │             │             │
        └─────────────┴──────┬──────┴─────────────┘
                             │
              ┌──────────────▼───────────────┐
              │    Hardware Integration Hub   │
              │  • Device discovery           │
              │  • Print queue management     │
              │  • Connection monitoring      │
              └──────────────┬───────────────┘
                             │
        ┌────────────────────┼────────────────────┐
        │                    │                    │
   ┌────▼────┐         ┌─────▼────┐         ┌────▼────┐
   │ Printers│         │ Readers  │         │ Drawers │
   └─────────┘         └──────────┘         └─────────┘

Device Discovery​

Auto-Discovery​

// src/hardware/discovery.rs
pub async fn discover_all_devices() -> Result<DiscoveryResult> {
    let mut result = DiscoveryResult::default();

    // Discover Star printers
    let star_printers = StarPrinterService::discover_printers().await?;
    result.printers.extend(star_printers);

    // Discover USB devices
    let usb_devices = usb::enumerate_devices()?;
    for device in usb_devices {
        match (device.vendor_id, device.product_id) {
            // Epson printers
            (0x04b8, _) => {
                result.printers.push(PrinterInfo {
                    id: device.serial.clone(),
                    name: format!("Epson {}", device.product),
                    connection: ConnectionType::USB { path: device.path },
                    status: PrinterStatus::Online,
                });
            }
            // Cash drawers
            (0x0416, 0x0001) => {
                result.cash_drawers.push(CashDrawerInfo {
                    id: device.serial.clone(),
                    name: "USB Cash Drawer".to_string(),
                    connection: ConnectionType::USB { path: device.path },
                });
            }
            // Barcode scanners
            (0x05e0, _) => {
                result.scanners.push(ScannerInfo {
                    id: device.serial.clone(),
                    name: format!("Zebra {}", device.product),
                    connection: ConnectionType::USB { path: device.path },
                });
            }
            _ => {}
        }
    }

    // Discover network printers
    let network_printers = discover_network_printers().await?;
    result.printers.extend(network_printers);

    Ok(result)
}

Health Monitoring​

Device Status Check​

pub async fn check_all_devices(ctx: &TenantContext) -> Result<DeviceHealth> {
    let mut health = DeviceHealth::default();

    // Check printers
    for printer in printer_service.get_all(ctx).await? {
        let status = printer_service.check_status(&printer.id).await;
        health.printers.push(DeviceStatus {
            id: printer.id,
            name: printer.name,
            online: status.is_ok(),
            error: status.err().map(|e| e.to_string()),
        });
    }

    // Check card readers
    for reader in card_reader_service.get_all(ctx).await? {
        let status = card_reader_service.check_status(&reader.id).await;
        health.card_readers.push(DeviceStatus {
            id: reader.id,
            name: reader.name,
            online: status.is_ok(),
            error: status.err().map(|e| e.to_string()),
        });
    }

    // Check cash drawers
    for drawer in cash_drawer_service.get_all(ctx).await? {
        let status = cash_drawer_service.check_status(&drawer.id).await;
        health.cash_drawers.push(DeviceStatus {
            id: drawer.id,
            name: drawer.name,
            online: status.is_ok(),
            error: status.err().map(|e| e.to_string()),
        });
    }

    Ok(health)
}

Sub-Pages​