Exemples de code

#!/usr/bin/env python3
"""Client ERP de bout en bout pour le TCC SFEC Terminal via le pont série.
Encadrement : <json>END_JSON sur COM10, 115200 8N1, sans contrôle de flux. Requiert pyserial."""
import base64
import json
import time
from datetime import datetime, timezone
 
import serial  # pyserial
 
COM_PORT = "COM10"          # port exposé par le pont SfecTcpMiddleware
BAUD_RATE = 115200          # 8 bits de données, sans parité, 1 bit de stop, sans contrôle de flux
DELIMITER = b"END_JSON"     # marqueur de trame ASCII littéral (jamais un saut de ligne)
 
INVOICE = {
    "invoiceId": "INV-2026-0001",
    "invoiceType": "salesInvoice",
    "recipientType": "individual",
    "isRecipientTaxable": False,
    "subtotal": 10000.0,
    "totalTaxTAmount": 1800.0,
    "totalTaxRAmount": 0.0,
    "totalExemptAmount": 0.0,
    "totalTaxAmount": 1800.0,
    "discountAmount": 0.0,
    "totalLineDiscountAmount": 0.0,
    "additionalCentTax": 0.0,
    "electronicStampDuty": 0.0,
    "totalAmount": 11800.0,
    "amountDue": 11800.0,
    "currency": "XAF",
    "paymentMethod": "cash",
    "items": [
        {
            "designation": "Produit test",
            "type": "product",
            "unitPrice": 10000.0,
            "quantity": 1.0,
            "subtotal": 10000.0,
            "discountAmount": 0.0,
            "discountType": "percentage",
            "netAmount": 10000.0,
            "taxRate": "18",
            "taxAmount": 1800.0,
            "totalAmount": 11800.0,
        }
    ],
}
 
 
def send_frame(ser: serial.Serial, obj: dict) -> None:
    ser.write(json.dumps(obj, ensure_ascii=False, separators=(",", ":")).encode("utf-8") + DELIMITER)
    ser.flush()
 
 
def read_frame(ser: serial.Serial, timeout: float = 35.0) -> dict:
    """Accumule les octets jusqu'à END_JSON, retire le marqueur et parse le JSON en amont."""
    buffer = bytearray()
    deadline = time.monotonic() + timeout
    while time.monotonic() < deadline:
        chunk = ser.read(ser.in_waiting or 1)
        if chunk:
            buffer.extend(chunk)
            idx = buffer.find(DELIMITER)
            if idx != -1:
                return json.loads(buffer[:idx].decode("utf-8").strip())
    raise TimeoutError(f"No frame within {timeout:.0f}s")
 
 
def health_check(ser: serial.Serial, timeout: float = 5.0) -> bool:
    """Sonde de liveness optionnelle : le pont répond au ping par un pong."""
    send_frame(ser, {"type": "ping",
                     "timestamp": datetime.now(timezone.utc).isoformat(),
                     "source": "erp"})
    try:
        return read_frame(ser, timeout).get("type") == "pong"
    except TimeoutError:
        return False
 
 
def save_qr_png(qr_code_b64: str, path: str) -> int:
    png = base64.b64decode(qr_code_b64)         # Base64 brut, sans saut de ligne, sans préfixe data:
    with open(path, "wb") as fh:
        fh.write(png)
    return len(png)
 
 
def main() -> None:
    with serial.Serial(port=COM_PORT, baudrate=BAUD_RATE, bytesize=serial.EIGHTBITS,
                       parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE,
                       timeout=1, write_timeout=5) as ser:
        if health_check(ser):
            print("[HEALTH] bridge responded pong")
 
        send_frame(ser, INVOICE)
        resp = read_frame(ser)
 
        if resp.get("status") == "success":
            n = save_qr_png(resp["qr_code"], "qr_code.png")
            print(f"[OK] sfec_number        = {resp['sfec_number']}")
            print(f"[OK] invoice_id         = {resp['invoice_id']}")
            print(f"[OK] certification_date = {resp['certification_date']} (epoch ms)")
            print(f"[OK] qr_code.png        = {n} bytes")
        elif resp.get("error_code") == "VALIDATION_ERROR":
            for e in resp.get("errors", []):
                print(f"[VALIDATION] {e['field']}: {e['message']}")
        else:
            print(f"[ERROR] {resp.get('error_code')}: {resp.get('error_message')}")
 
 
if __name__ == "__main__":
    main()

using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Ports;
using System.Text;
using System.Text.Json;
 
internal static class Program
{
    private const string PortName = "COM10";     // port exposé par le pont SfecTcpMiddleware
    private const int BaudRate = 115200;         // 8 bits de données, sans parité, 1 bit de stop
    private const string Delimiter = "END_JSON"; // marqueur de trame ASCII littéral
 
    private static void Main()
    {
        using var serial = new SerialPort(PortName, BaudRate, Parity.None, 8, StopBits.One)
        {
            Handshake = Handshake.None,          // sans contrôle de flux
            Encoding = Encoding.UTF8,
            ReadTimeout = 1000,
            WriteTimeout = 5000,
        };
        serial.Open();
 
        if (HealthCheck(serial))
            Console.WriteLine("[HEALTH] bridge responded pong");
 
        SendFrame(serial, JsonSerializer.Serialize(BuildInvoice()));
        string frame = ReadFrame(serial, TimeSpan.FromSeconds(35));
 
        using var doc = JsonDocument.Parse(frame);
        JsonElement root = doc.RootElement;
        string status = root.GetProperty("status").GetString() ?? "";
 
        if (status == "success")
        {
            byte[] png = Convert.FromBase64String(root.GetProperty("qr_code").GetString()!);
            File.WriteAllBytes("qr_code.png", png); // Base64 brut, sans saut de ligne, sans préfixe data:
            Console.WriteLine($"[OK] sfec_number        = {root.GetProperty("sfec_number").GetString()}");
            Console.WriteLine($"[OK] invoice_id         = {root.GetProperty("invoice_id").GetString()}");
            Console.WriteLine($"[OK] certification_date = {root.GetProperty("certification_date").GetInt64()} (epoch ms)");
            Console.WriteLine($"[OK] qr_code.png        = {png.Length} bytes");
        }
        else if (root.TryGetProperty("error_code", out JsonElement ec) && ec.GetString() == "VALIDATION_ERROR")
        {
            foreach (JsonElement err in root.GetProperty("errors").EnumerateArray())
                Console.WriteLine($"[VALIDATION] {err.GetProperty("field").GetString()}: {err.GetProperty("message").GetString()}");
        }
        else
        {
            Console.WriteLine($"[ERROR] {root.GetProperty("error_code").GetString()}: {root.GetProperty("error_message").GetString()}");
        }
    }
 
    private static object BuildInvoice() => new
    {
        invoiceId = "INV-2026-0001",
        invoiceType = "salesInvoice",
        recipientType = "individual",
        isRecipientTaxable = false,
        subtotal = 10000.0,
        totalTaxTAmount = 1800.0,
        totalTaxRAmount = 0.0,
        totalExemptAmount = 0.0,
        totalTaxAmount = 1800.0,
        discountAmount = 0.0,
        totalLineDiscountAmount = 0.0,
        additionalCentTax = 0.0,
        electronicStampDuty = 0.0,
        totalAmount = 11800.0,
        amountDue = 11800.0,
        currency = "XAF",
        paymentMethod = "cash",
        items = new[]
        {
            new
            {
                designation = "Produit test",
                type = "product",
                unitPrice = 10000.0,
                quantity = 1.0,
                subtotal = 10000.0,
                discountAmount = 0.0,
                discountType = "percentage",
                netAmount = 10000.0,
                taxRate = "18",
                taxAmount = 1800.0,
                totalAmount = 11800.0,
            }
        }
    };
 
    private static void SendFrame(SerialPort serial, string json)
    {
        byte[] data = Encoding.UTF8.GetBytes(json + Delimiter);
        serial.Write(data, 0, data.Length);
        serial.BaseStream.Flush();
    }
 
    private static string ReadFrame(SerialPort serial, TimeSpan timeout)
    {
        byte[] delim = Encoding.ASCII.GetBytes(Delimiter);
        var buffer = new List<byte>();
        var one = new byte[1];
        DateTime deadline = DateTime.UtcNow + timeout;
        while (DateTime.UtcNow < deadline)
        {
            try
            {
                if (serial.Read(one, 0, 1) <= 0) continue;
            }
            catch (TimeoutException) { continue; }
 
            buffer.Add(one[0]);
            if (EndsWith(buffer, delim))
                return Encoding.UTF8.GetString(buffer.ToArray(), 0, buffer.Count - delim.Length).Trim();
        }
        throw new TimeoutException($"No frame within {timeout.TotalSeconds:F0}s");
    }
 
    private static bool EndsWith(List<byte> buffer, byte[] suffix)
    {
        if (buffer.Count < suffix.Length) return false;
        int offset = buffer.Count - suffix.Length;
        for (int i = 0; i < suffix.Length; i++)
            if (buffer[offset + i] != suffix[i]) return false;
        return true;
    }
 
    private static bool HealthCheck(SerialPort serial)
    {
        SendFrame(serial, JsonSerializer.Serialize(new
        {
            type = "ping",
            timestamp = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fffZ"),
            source = "erp",
        }));
        try
        {
            using JsonDocument doc = JsonDocument.Parse(ReadFrame(serial, TimeSpan.FromSeconds(5)));
            return doc.RootElement.TryGetProperty("type", out JsonElement t) && t.GetString() == "pong";
        }
        catch (TimeoutException)
        {
            return false;
        }
    }
}

import com.fazecast.jSerialComm.SerialPort;
import org.json.JSONArray;
import org.json.JSONObject;
 
import java.io.IOException;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.Instant;
import java.util.Arrays;
import java.util.Base64;
 
public final class SfecSerialClient {
 
    private static final String PORT_NAME = "COM10";   // port exposé par le pont SfecTcpMiddleware
    private static final int BAUD_RATE = 115200;        // 8N1, sans contrôle de flux
    private static final byte[] DELIMITER = "END_JSON".getBytes(StandardCharsets.US_ASCII);
 
    public static void main(String[] args) throws Exception {
        SerialPort port = SerialPort.getCommPort(PORT_NAME);
        port.setComPortParameters(BAUD_RATE, 8, SerialPort.ONE_STOP_BIT, SerialPort.NO_PARITY);
        port.setFlowControl(SerialPort.FLOW_CONTROL_DISABLED);
        port.setComPortTimeouts(SerialPort.TIMEOUT_READ_SEMI_BLOCKING, 1000, 0);
 
        if (!port.openPort()) {
            System.err.println("Cannot open " + PORT_NAME);
            return;
        }
        try {
            if (healthCheck(port)) {
                System.out.println("[HEALTH] bridge responded pong");
            }
 
            sendFrame(port, buildInvoice().toString());
            JSONObject resp = new JSONObject(readFrame(port, 35_000));
 
            if ("success".equals(resp.optString("status"))) {
                byte[] png = Base64.getDecoder().decode(resp.getString("qr_code")); // sans saut de ligne, sans préfixe data:
                Files.write(Path.of("qr_code.png"), png);
                System.out.println("[OK] sfec_number        = " + resp.getString("sfec_number"));
                System.out.println("[OK] invoice_id         = " + resp.get("invoice_id"));
                System.out.println("[OK] certification_date = " + resp.getLong("certification_date") + " (epoch ms)");
                System.out.println("[OK] qr_code.png        = " + png.length + " bytes");
            } else if ("VALIDATION_ERROR".equals(resp.optString("error_code"))) {
                JSONArray errors = resp.getJSONArray("errors");
                for (int i = 0; i < errors.length(); i++) {
                    JSONObject e = errors.getJSONObject(i);
                    System.out.println("[VALIDATION] " + e.getString("field") + ": " + e.getString("message"));
                }
            } else {
                System.out.println("[ERROR] " + resp.optString("error_code") + ": " + resp.optString("error_message"));
            }
        } finally {
            port.closePort();
        }
    }
 
    private static JSONObject buildInvoice() {
        JSONObject item = new JSONObject()
                .put("designation", "Produit test")
                .put("type", "product")
                .put("unitPrice", 10000.0)
                .put("quantity", 1.0)
                .put("subtotal", 10000.0)
                .put("discountAmount", 0.0)
                .put("discountType", "percentage")
                .put("netAmount", 10000.0)
                .put("taxRate", "18")
                .put("taxAmount", 1800.0)
                .put("totalAmount", 11800.0);
 
        return new JSONObject()
                .put("invoiceId", "INV-2026-0001")
                .put("invoiceType", "salesInvoice")
                .put("recipientType", "individual")
                .put("isRecipientTaxable", false)
                .put("subtotal", 10000.0)
                .put("totalTaxTAmount", 1800.0)
                .put("totalTaxRAmount", 0.0)
                .put("totalExemptAmount", 0.0)
                .put("totalTaxAmount", 1800.0)
                .put("discountAmount", 0.0)
                .put("totalLineDiscountAmount", 0.0)
                .put("additionalCentTax", 0.0)
                .put("electronicStampDuty", 0.0)
                .put("totalAmount", 11800.0)
                .put("amountDue", 11800.0)
                .put("currency", "XAF")
                .put("paymentMethod", "cash")
                .put("items", new JSONArray().put(item));
    }
 
    private static void sendFrame(SerialPort port, String json) throws IOException {
        OutputStream out = port.getOutputStream();
        out.write(json.getBytes(StandardCharsets.UTF_8));
        out.write(DELIMITER);
        out.flush();
    }
 
    private static String readFrame(SerialPort port, long timeoutMillis) {
        byte[] buffer = new byte[1024];
        int length = 0;
        int scanned = 0;
        byte[] chunk = new byte[512];
        long deadline = System.currentTimeMillis() + timeoutMillis;
        while (System.currentTimeMillis() < deadline) {
            int n = port.readBytes(chunk, chunk.length);   // honore le read timeout ci-dessus
            if (n <= 0) continue;
            if (length + n > buffer.length) {
                buffer = Arrays.copyOf(buffer, Math.max(buffer.length * 2, length + n));
            }
            System.arraycopy(chunk, 0, buffer, length, n);
            length += n;
            int idx = indexOf(buffer, scanned, length, DELIMITER);
            if (idx >= 0) {
                return new String(buffer, 0, idx, StandardCharsets.UTF_8).trim();
            }
            scanned = Math.max(0, length - DELIMITER.length + 1);
        }
        throw new RuntimeException("No frame within " + (timeoutMillis / 1000) + "s");
    }
 
    private static int indexOf(byte[] data, int from, int length, byte[] target) {
        outer:
        for (int i = from; i <= length - target.length; i++) {
            for (int j = 0; j < target.length; j++) {
                if (data[i + j] != target[j]) continue outer;
            }
            return i;
        }
        return -1;
    }
 
    private static boolean healthCheck(SerialPort port) throws IOException {
        JSONObject ping = new JSONObject()
                .put("type", "ping")
                .put("timestamp", Instant.now().toString())
                .put("source", "erp");
        sendFrame(port, ping.toString());
        return "pong".equals(new JSONObject(readFrame(port, 5_000)).optString("type"));
    }
}