feat(buf): implement SoftSerial traits for HalfDuplexSerial with RingBuffer

a

Cargo.toml

@@ -6,10 +6,12 @@ edition = "2021"
 [dependencies.arduino-hal]
 git = "https://github.com/rahix/avr-hal"
 rev = "3e362624547462928a219c40f9ea8e3a64f21e5f"
-features = ["sparkfun-promicro"]
 
-[dependencies.static_pins]
+[dependencies.static-pins]
-git = "https://gitea.doryan04.ru/TheEmbeddedRust/static_pins"
+git = "https://gitea.doryan04.ru/TheEmbeddedRust/static-pins"
+
+[features]
+sparkfun-promicro = ["arduino-hal/sparkfun-promicro", "static-pins/sparkfun-promicro"]
 
 [dependencies.avr-device]
 version = "0.5.4"

avr-specs/avr-atmega1280.json

@@ -1,41 +0,0 @@
-{
-  "arch": "avr",
-  "atomic-cas": false,
-  "cpu": "atmega1280",
-  "crt-objects-fallback": "false",
-  "data-layout": "e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8-a:8",
-  "eh-frame-header": false,
-  "exe-suffix": ".elf",
-  "late-link-args": {
-    "gnu-cc": [
-      "-lgcc"
-    ],
-    "gnu-lld-cc": [
-      "-lgcc"
-    ]
-  },
-  "linker": "avr-gcc",
-  "linker-flavor": "gnu-cc",
-  "llvm-target": "avr-unknown-unknown",
-  "max-atomic-width": 8,
-  "metadata": {
-    "description": null,
-    "host_tools": null,
-    "std": null,
-    "tier": null
-  },
-  "no-default-libraries": false,
-  "pre-link-args": {
-    "gnu-cc": [
-      "-mmcu=atmega1280",
-      "-Wl,--as-needed,--print-memory-usage"
-    ],
-    "gnu-lld-cc": [
-      "-mmcu=atmega1280",
-      "-Wl,--as-needed,--print-memory-usage"
-    ]
-  },
-  "relocation-model": "static",
-  "target-c-int-width": "16",
-  "target-pointer-width": "16"
-}

avr-specs/avr-atmega1284p.json

@@ -1,41 +0,0 @@
-{
-  "arch": "avr",
-  "atomic-cas": false,
-  "cpu": "atmega1284p",
-  "crt-objects-fallback": "false",
-  "data-layout": "e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8-a:8",
-  "eh-frame-header": false,
-  "exe-suffix": ".elf",
-  "late-link-args": {
-    "gnu-cc": [
-      "-lgcc"
-    ],
-    "gnu-lld-cc": [
-      "-lgcc"
-    ]
-  },
-  "linker": "avr-gcc",
-  "linker-flavor": "gnu-cc",
-  "llvm-target": "avr-unknown-unknown",
-  "max-atomic-width": 8,
-  "metadata": {
-    "description": null,
-    "host_tools": null,
-    "std": null,
-    "tier": null
-  },
-  "no-default-libraries": false,
-  "pre-link-args": {
-    "gnu-cc": [
-      "-mmcu=atmega1284p",
-      "-Wl,--as-needed,--print-memory-usage"
-    ],
-    "gnu-lld-cc": [
-      "-mmcu=atmega1284p",
-      "-Wl,--as-needed,--print-memory-usage"
-    ]
-  },
-  "relocation-model": "static",
-  "target-c-int-width": "16",
-  "target-pointer-width": "16"
-}

avr-specs/avr-atmega128a.json

@@ -1,41 +0,0 @@
-{
-  "arch": "avr",
-  "atomic-cas": false,
-  "cpu": "atmega128a",
-  "crt-objects-fallback": "false",
-  "data-layout": "e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8-a:8",
-  "eh-frame-header": false,
-  "exe-suffix": ".elf",
-  "late-link-args": {
-    "gnu-cc": [
-      "-lgcc"
-    ],
-    "gnu-lld-cc": [
-      "-lgcc"
-    ]
-  },
-  "linker": "avr-gcc",
-  "linker-flavor": "gnu-cc",
-  "llvm-target": "avr-unknown-unknown",
-  "max-atomic-width": 8,
-  "metadata": {
-    "description": null,
-    "host_tools": null,
-    "std": null,
-    "tier": null
-  },
-  "no-default-libraries": false,
-  "pre-link-args": {
-    "gnu-cc": [
-      "-mmcu=atmega128a",
-      "-Wl,--as-needed,--print-memory-usage"
-    ],
-    "gnu-lld-cc": [
-      "-mmcu=atmega128a",
-      "-Wl,--as-needed,--print-memory-usage"
-    ]
-  },
-  "relocation-model": "static",
-  "target-c-int-width": "16",
-  "target-pointer-width": "16"
-}

avr-specs/avr-atmega164pa.json

@@ -1,41 +0,0 @@
-{
-  "arch": "avr",
-  "atomic-cas": false,
-  "cpu": "atmega164pa",
-  "crt-objects-fallback": "false",
-  "data-layout": "e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8-a:8",
-  "eh-frame-header": false,
-  "exe-suffix": ".elf",
-  "late-link-args": {
-    "gnu-cc": [
-      "-lgcc"
-    ],
-    "gnu-lld-cc": [
-      "-lgcc"
-    ]
-  },
-  "linker": "avr-gcc",
-  "linker-flavor": "gnu-cc",
-  "llvm-target": "avr-unknown-unknown",
-  "max-atomic-width": 8,
-  "metadata": {
-    "description": null,
-    "host_tools": null,
-    "std": null,
-    "tier": null
-  },
-  "no-default-libraries": false,
-  "pre-link-args": {
-    "gnu-cc": [
-      "-mmcu=atmega164pa",
-      "-Wl,--as-needed,--print-memory-usage"
-    ],
-    "gnu-lld-cc": [
-      "-mmcu=atmega164pa",
-      "-Wl,--as-needed,--print-memory-usage"
-    ]
-  },
-  "relocation-model": "static",
-  "target-c-int-width": "16",
-  "target-pointer-width": "16"
-}

avr-specs/avr-atmega168.json

@@ -1,41 +0,0 @@
-{
-  "arch": "avr",
-  "atomic-cas": false,
-  "cpu": "atmega168",
-  "crt-objects-fallback": "false",
-  "data-layout": "e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8-a:8",
-  "eh-frame-header": false,
-  "exe-suffix": ".elf",
-  "late-link-args": {
-    "gnu-cc": [
-      "-lgcc"
-    ],
-    "gnu-lld-cc": [
-      "-lgcc"
-    ]
-  },
-  "linker": "avr-gcc",
-  "linker-flavor": "gnu-cc",
-  "llvm-target": "avr-unknown-unknown",
-  "max-atomic-width": 8,
-  "metadata": {
-    "description": null,
-    "host_tools": null,
-    "std": null,
-    "tier": null
-  },
-  "no-default-libraries": false,
-  "pre-link-args": {
-    "gnu-cc": [
-      "-mmcu=atmega168",
-      "-Wl,--as-needed,--print-memory-usage"
-    ],
-    "gnu-lld-cc": [
-      "-mmcu=atmega168",
-      "-Wl,--as-needed,--print-memory-usage"
-    ]
-  },
-  "relocation-model": "static",
-  "target-c-int-width": "16",
-  "target-pointer-width": "16"
-}

avr-specs/avr-atmega2560.json

@@ -1,41 +0,0 @@
-{
-  "arch": "avr",
-  "atomic-cas": false,
-  "cpu": "atmega2560",
-  "crt-objects-fallback": "false",
-  "data-layout": "e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8-a:8",
-  "eh-frame-header": false,
-  "exe-suffix": ".elf",
-  "late-link-args": {
-    "gnu-cc": [
-      "-lgcc"
-    ],
-    "gnu-lld-cc": [
-      "-lgcc"
-    ]
-  },
-  "linker": "avr-gcc",
-  "linker-flavor": "gnu-cc",
-  "llvm-target": "avr-unknown-unknown",
-  "max-atomic-width": 8,
-  "metadata": {
-    "description": null,
-    "host_tools": null,
-    "std": null,
-    "tier": null
-  },
-  "no-default-libraries": false,
-  "pre-link-args": {
-    "gnu-cc": [
-      "-mmcu=atmega2560",
-      "-Wl,--as-needed,--print-memory-usage"
-    ],
-    "gnu-lld-cc": [
-      "-mmcu=atmega2560",
-      "-Wl,--as-needed,--print-memory-usage"
-    ]
-  },
-  "relocation-model": "static",
-  "target-c-int-width": "16",
-  "target-pointer-width": "16"
-}

avr-specs/avr-atmega328.json

@@ -1,41 +0,0 @@
-{
-  "arch": "avr",
-  "atomic-cas": false,
-  "cpu": "atmega328",
-  "crt-objects-fallback": "false",
-  "data-layout": "e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8-a:8",
-  "eh-frame-header": false,
-  "exe-suffix": ".elf",
-  "late-link-args": {
-    "gnu-cc": [
-      "-lgcc"
-    ],
-    "gnu-lld-cc": [
-      "-lgcc"
-    ]
-  },
-  "linker": "avr-gcc",
-  "linker-flavor": "gnu-cc",
-  "llvm-target": "avr-unknown-unknown",
-  "max-atomic-width": 8,
-  "metadata": {
-    "description": null,
-    "host_tools": null,
-    "std": null,
-    "tier": null
-  },
-  "no-default-libraries": false,
-  "pre-link-args": {
-    "gnu-cc": [
-      "-mmcu=atmega328",
-      "-Wl,--as-needed,--print-memory-usage"
-    ],
-    "gnu-lld-cc": [
-      "-mmcu=atmega328",
-      "-Wl,--as-needed,--print-memory-usage"
-    ]
-  },
-  "relocation-model": "static",
-  "target-c-int-width": "16",
-  "target-pointer-width": "16"
-}

avr-specs/avr-atmega328p.json

@@ -1,41 +0,0 @@
-{
-  "arch": "avr",
-  "atomic-cas": false,
-  "cpu": "atmega328p",
-  "crt-objects-fallback": "false",
-  "data-layout": "e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8-a:8",
-  "eh-frame-header": false,
-  "exe-suffix": ".elf",
-  "late-link-args": {
-    "gnu-cc": [
-      "-lgcc"
-    ],
-    "gnu-lld-cc": [
-      "-lgcc"
-    ]
-  },
-  "linker": "avr-gcc",
-  "linker-flavor": "gnu-cc",
-  "llvm-target": "avr-unknown-unknown",
-  "max-atomic-width": 8,
-  "metadata": {
-    "description": null,
-    "host_tools": null,
-    "std": null,
-    "tier": null
-  },
-  "no-default-libraries": false,
-  "pre-link-args": {
-    "gnu-cc": [
-      "-mmcu=atmega328p",
-      "-Wl,--as-needed,--print-memory-usage"
-    ],
-    "gnu-lld-cc": [
-      "-mmcu=atmega328p",
-      "-Wl,--as-needed,--print-memory-usage"
-    ]
-  },
-  "relocation-model": "static",
-  "target-c-int-width": "16",
-  "target-pointer-width": "16"
-}

avr-specs/avr-atmega32a.json

@@ -1,41 +0,0 @@
-{
-  "arch": "avr",
-  "atomic-cas": false,
-  "cpu": "atmega32a",
-  "crt-objects-fallback": "false",
-  "data-layout": "e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8-a:8",
-  "eh-frame-header": false,
-  "exe-suffix": ".elf",
-  "late-link-args": {
-    "gnu-cc": [
-      "-lgcc"
-    ],
-    "gnu-lld-cc": [
-      "-lgcc"
-    ]
-  },
-  "linker": "avr-gcc",
-  "linker-flavor": "gnu-cc",
-  "llvm-target": "avr-unknown-unknown",
-  "max-atomic-width": 8,
-  "metadata": {
-    "description": null,
-    "host_tools": null,
-    "std": null,
-    "tier": null
-  },
-  "no-default-libraries": false,
-  "pre-link-args": {
-    "gnu-cc": [
-      "-mmcu=atmega32a",
-      "-Wl,--as-needed,--print-memory-usage"
-    ],
-    "gnu-lld-cc": [
-      "-mmcu=atmega32a",
-      "-Wl,--as-needed,--print-memory-usage"
-    ]
-  },
-  "relocation-model": "static",
-  "target-c-int-width": "16",
-  "target-pointer-width": "16"
-}

avr-specs/avr-atmega32u4.json

@@ -1,41 +0,0 @@
-{
-  "arch": "avr",
-  "atomic-cas": false,
-  "cpu": "atmega32u4",
-  "crt-objects-fallback": "false",
-  "data-layout": "e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8-a:8",
-  "eh-frame-header": false,
-  "exe-suffix": ".elf",
-  "late-link-args": {
-    "gnu-cc": [
-      "-lgcc"
-    ],
-    "gnu-lld-cc": [
-      "-lgcc"
-    ]
-  },
-  "linker": "avr-gcc",
-  "linker-flavor": "gnu-cc",
-  "llvm-target": "avr-unknown-unknown",
-  "max-atomic-width": 8,
-  "metadata": {
-    "description": null,
-    "host_tools": null,
-    "std": null,
-    "tier": null
-  },
-  "no-default-libraries": false,
-  "pre-link-args": {
-    "gnu-cc": [
-      "-mmcu=atmega32u4",
-      "-Wl,--as-needed,--print-memory-usage"
-    ],
-    "gnu-lld-cc": [
-      "-mmcu=atmega32u4",
-      "-Wl,--as-needed,--print-memory-usage"
-    ]
-  },
-  "relocation-model": "static",
-  "target-c-int-width": "16",
-  "target-pointer-width": "16"
-}

avr-specs/avr-atmega48p.json

@@ -1,41 +0,0 @@
-{
-  "arch": "avr",
-  "atomic-cas": false,
-  "cpu": "atmega48p",
-  "crt-objects-fallback": "false",
-  "data-layout": "e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8-a:8",
-  "eh-frame-header": false,
-  "exe-suffix": ".elf",
-  "late-link-args": {
-    "gnu-cc": [
-      "-lgcc"
-    ],
-    "gnu-lld-cc": [
-      "-lgcc"
-    ]
-  },
-  "linker": "avr-gcc",
-  "linker-flavor": "gnu-cc",
-  "llvm-target": "avr-unknown-unknown",
-  "max-atomic-width": 8,
-  "metadata": {
-    "description": null,
-    "host_tools": null,
-    "std": null,
-    "tier": null
-  },
-  "no-default-libraries": false,
-  "pre-link-args": {
-    "gnu-cc": [
-      "-mmcu=atmega48p",
-      "-Wl,--as-needed,--print-memory-usage"
-    ],
-    "gnu-lld-cc": [
-      "-mmcu=atmega48p",
-      "-Wl,--as-needed,--print-memory-usage"
-    ]
-  },
-  "relocation-model": "static",
-  "target-c-int-width": "16",
-  "target-pointer-width": "16"
-}

avr-specs/avr-atmega8.json

@@ -1,41 +0,0 @@
-{
-  "arch": "avr",
-  "atomic-cas": false,
-  "cpu": "atmega8",
-  "crt-objects-fallback": "false",
-  "data-layout": "e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8-a:8",
-  "eh-frame-header": false,
-  "exe-suffix": ".elf",
-  "late-link-args": {
-    "gnu-cc": [
-      "-lgcc"
-    ],
-    "gnu-lld-cc": [
-      "-lgcc"
-    ]
-  },
-  "linker": "avr-gcc",
-  "linker-flavor": "gnu-cc",
-  "llvm-target": "avr-unknown-unknown",
-  "max-atomic-width": 8,
-  "metadata": {
-    "description": null,
-    "host_tools": null,
-    "std": null,
-    "tier": null
-  },
-  "no-default-libraries": false,
-  "pre-link-args": {
-    "gnu-cc": [
-      "-mmcu=atmega8",
-      "-Wl,--as-needed,--print-memory-usage"
-    ],
-    "gnu-lld-cc": [
-      "-mmcu=atmega8",
-      "-Wl,--as-needed,--print-memory-usage"
-    ]
-  },
-  "relocation-model": "static",
-  "target-c-int-width": "16",
-  "target-pointer-width": "16"
-}

avr-specs/avr-attiny167.json

@@ -1,41 +0,0 @@
-{
-  "arch": "avr",
-  "atomic-cas": false,
-  "cpu": "attiny167",
-  "crt-objects-fallback": "false",
-  "data-layout": "e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8-a:8",
-  "eh-frame-header": false,
-  "exe-suffix": ".elf",
-  "late-link-args": {
-    "gnu-cc": [
-      "-lgcc"
-    ],
-    "gnu-lld-cc": [
-      "-lgcc"
-    ]
-  },
-  "linker": "avr-gcc",
-  "linker-flavor": "gnu-cc",
-  "llvm-target": "avr-unknown-unknown",
-  "max-atomic-width": 8,
-  "metadata": {
-    "description": null,
-    "host_tools": null,
-    "std": null,
-    "tier": null
-  },
-  "no-default-libraries": false,
-  "pre-link-args": {
-    "gnu-cc": [
-      "-mmcu=attiny167",
-      "-Wl,--as-needed,--print-memory-usage"
-    ],
-    "gnu-lld-cc": [
-      "-mmcu=attiny167",
-      "-Wl,--as-needed,--print-memory-usage"
-    ]
-  },
-  "relocation-model": "static",
-  "target-c-int-width": "16",
-  "target-pointer-width": "16"
-}

avr-specs/avr-attiny2313.json

@@ -1,41 +0,0 @@
-{
-  "arch": "avr",
-  "atomic-cas": false,
-  "cpu": "attiny2313",
-  "crt-objects-fallback": "false",
-  "data-layout": "e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8-a:8",
-  "eh-frame-header": false,
-  "exe-suffix": ".elf",
-  "late-link-args": {
-    "gnu-cc": [
-      "-lgcc"
-    ],
-    "gnu-lld-cc": [
-      "-lgcc"
-    ]
-  },
-  "linker": "avr-gcc",
-  "linker-flavor": "gnu-cc",
-  "llvm-target": "avr-unknown-unknown",
-  "max-atomic-width": 8,
-  "metadata": {
-    "description": null,
-    "host_tools": null,
-    "std": null,
-    "tier": null
-  },
-  "no-default-libraries": false,
-  "pre-link-args": {
-    "gnu-cc": [
-      "-mmcu=attiny2313",
-      "-Wl,--as-needed,--print-memory-usage"
-    ],
-    "gnu-lld-cc": [
-      "-mmcu=attiny2313",
-      "-Wl,--as-needed,--print-memory-usage"
-    ]
-  },
-  "relocation-model": "static",
-  "target-c-int-width": "16",
-  "target-pointer-width": "16"
-}

avr-specs/avr-attiny85.json

@@ -1,41 +0,0 @@
-{
-  "arch": "avr",
-  "atomic-cas": false,
-  "cpu": "attiny85",
-  "crt-objects-fallback": "false",
-  "data-layout": "e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8-a:8",
-  "eh-frame-header": false,
-  "exe-suffix": ".elf",
-  "late-link-args": {
-    "gnu-cc": [
-      "-lgcc"
-    ],
-    "gnu-lld-cc": [
-      "-lgcc"
-    ]
-  },
-  "linker": "avr-gcc",
-  "linker-flavor": "gnu-cc",
-  "llvm-target": "avr-unknown-unknown",
-  "max-atomic-width": 8,
-  "metadata": {
-    "description": null,
-    "host_tools": null,
-    "std": null,
-    "tier": null
-  },
-  "no-default-libraries": false,
-  "pre-link-args": {
-    "gnu-cc": [
-      "-mmcu=attiny85",
-      "-Wl,--as-needed,--print-memory-usage"
-    ],
-    "gnu-lld-cc": [
-      "-mmcu=attiny85",
-      "-Wl,--as-needed,--print-memory-usage"
-    ]
-  },
-  "relocation-model": "static",
-  "target-c-int-width": "16",
-  "target-pointer-width": "16"
-}

avr-specs/avr-attiny88.json

@@ -1,41 +0,0 @@
-{
-  "arch": "avr",
-  "atomic-cas": false,
-  "cpu": "attiny88",
-  "crt-objects-fallback": "false",
-  "data-layout": "e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8-a:8",
-  "eh-frame-header": false,
-  "exe-suffix": ".elf",
-  "late-link-args": {
-    "gnu-cc": [
-      "-lgcc"
-    ],
-    "gnu-lld-cc": [
-      "-lgcc"
-    ]
-  },
-  "linker": "avr-gcc",
-  "linker-flavor": "gnu-cc",
-  "llvm-target": "avr-unknown-unknown",
-  "max-atomic-width": 8,
-  "metadata": {
-    "description": null,
-    "host_tools": null,
-    "std": null,
-    "tier": null
-  },
-  "no-default-libraries": false,
-  "pre-link-args": {
-    "gnu-cc": [
-      "-mmcu=attiny88",
-      "-Wl,--as-needed,--print-memory-usage"
-    ],
-    "gnu-lld-cc": [
-      "-mmcu=attiny88",
-      "-Wl,--as-needed,--print-memory-usage"
-    ]
-  },
-  "relocation-model": "static",
-  "target-c-int-width": "16",
-  "target-pointer-width": "16"
-}

src/lib.rs

@@ -4,7 +4,6 @@ use core::marker::PhantomData;
 
 use arduino_hal::{
     delay_us,
-    pac::EXINT,
     port::{
         mode::{Input, PullUp},
         Pin, PinOps,
@@ -15,6 +14,8 @@ use avr_device::asm::delay_cycles;
 
 use static_pins::StaticPinOps;
 
+mod structures;
+
 pub type PollResult = Result<(), PollError>;
 pub type ReadByteResult = Result<u8, CorruptedData>;
 pub type CorruptedData = (u8, u8);
@@ -42,57 +43,13 @@ where
     P: PinOps + StaticPinOps,
 {
     #[inline]
-    pub fn new(_pin: Pin<Input<PullUp>, P>, exint: &EXINT) -> Self {
+    pub fn new(_pin: Pin<Input<PullUp>, P>) -> Self {
-        exint.eimsk.write(|w| w.bits(1 << 1));
-        exint.eicra.write(|w| unsafe { w.bits(!(1 << 3 | 1 << 2)) });
-
         Self {
             _pin: PhantomData {},
         }
     }
-}
 
-pub trait SoftSerial<P>
+    pub fn poll(&self) -> PollResult {
-where
-    P: PinOps + StaticPinOps,
-{
-    fn poll(&self) -> PollResult;
-    fn response(&self);
-
-    fn sync_reciever(&self);
-    fn sync_transmitter(&self);
-
-    fn write_byte(&self, data: u8);
-    fn read_byte(&self) -> ReadByteResult;
-
-    #[inline]
-    fn finish_write(&self) {
-        P::into_pull_up_input();
-        while P::is_low() {}
-    }
-
-    fn write_bytes(&self, transmit_data: &[u8]) {
-        for byte in transmit_data {
-            self.write_byte(*byte);
-            self.sync_transmitter();
-        }
-    }
-
-    fn read_bytes(&self, recieve_buffer: &mut [u8]) {
-        for byte in recieve_buffer {
-            if let Ok(data) = self.read_byte() {
-                *byte = data;
-            }
-            self.sync_reciever();
-        }
-    }
-}
-
-impl<P> SoftSerial<P> for HalfDuplexSerial<P>
-where
-    P: PinOps + StaticPinOps,
-{
-    fn poll(&self) -> PollResult {
         P::into_output();
         delay_cycles(1);
         P::into_pull_up_input();
@@ -114,7 +71,7 @@ where
         PollResult::Ok(())
     }
 
-    fn response(&self) {
+    pub fn response(&self) {
         P::into_output_high();
 
         delay_us(FIRST_HALF_SERIAL_DELAY);
@@ -127,7 +84,7 @@ where
     }
 
     #[inline(never)]
-    fn sync_transmitter(&self) {
+    pub fn sync_transmitter(&self) {
         P::into_output();
 
         delay_us(SERIAL_DELAY);
@@ -136,14 +93,72 @@ where
     }
 
     #[inline(never)]
-    fn sync_reciever(&self) {
+    pub fn sync_reciever(&self) {
         while P::is_high() {}
 
         while P::is_low() {}
     }
 
-    #[inline(never)]
+    #[inline]
-    fn write_byte(&self, data: u8) {
+    pub fn reset(&self) {
+        P::into_pull_up_input();
+    }
+}
+
+pub trait SoftSerialWriter<P, T>
+where
+    P: PinOps + StaticPinOps,
+{
+    fn write_byte(&self, data: u8);
+    fn write_bytes(&self, transmit_data: T);
+}
+
+pub trait SoftSerialReader<P, T>
+where
+    P: PinOps + StaticPinOps,
+{
+    fn read_byte(&self) -> ReadByteResult;
+    fn read_bytes(&self, recieve_data: T);
+}
+
+#[inline(always)]
+pub(crate) fn _priv_read_byte<P: PinOps + StaticPinOps>() -> ReadByteResult {
+    let (mut data, mut reciever_parity_bit) = (0, 0);
+
+    delay_cycles(FIRST_ENTRY_READING);
+    for _ in 0..8 {
+        delay_us(FIRST_HALF_SERIAL_DELAY);
+
+        data <<= 1;
+
+        if P::is_low() {
+            data |= 1;
+            reciever_parity_bit ^= 1;
+        } else {
+            data |= 0;
+            reciever_parity_bit ^= 0;
+        }
+
+        delay_cycles(READING_ADJUST);
+        delay_us(SECOND_HALF_SERIAL_DELAY);
+    }
+
+    delay_us(FIRST_HALF_SERIAL_DELAY);
+
+    let transmitter_parity_bit = (P::read() >> P::PIN_NUM) & LSB;
+
+    delay_cycles(READING_ADJUST);
+    delay_us(SECOND_HALF_SERIAL_DELAY);
+
+    if reciever_parity_bit == transmitter_parity_bit {
+        return Err((data, reciever_parity_bit));
+    }
+
+    Ok(data)
+}
+
+#[inline(always)]
+pub(crate) fn _priv_write_bytes<P: PinOps + StaticPinOps>(data: u8) {
     let (mut data, mut parity_bit) = (data, 0);
 
     for _ in 0..8 {
@@ -171,39 +186,38 @@ where
     delay_us(SERIAL_DELAY);
 }
 
+impl<P> SoftSerialWriter<P, &[u8]> for HalfDuplexSerial<P>
+where
+    P: PinOps + StaticPinOps,
+{
+    #[inline(never)]
+    fn write_byte(&self, data: u8) {
+        _priv_write_bytes::<P>(data);
+    }
+
+    fn write_bytes(&self, transmit_data: &[u8]) {
+        for byte in transmit_data {
+            <Self as SoftSerialWriter<P, &[u8]>>::write_byte(self, *byte);
+            self.sync_transmitter();
+        }
+    }
+}
+
+impl<P> SoftSerialReader<P, &mut [u8]> for HalfDuplexSerial<P>
+where
+    P: PinOps + StaticPinOps,
+{
     #[inline(never)]
     fn read_byte(&self) -> ReadByteResult {
-        let (mut data, mut reciever_parity_bit) = (0, 0);
+        _priv_read_byte::<P>()
-
-        delay_cycles(FIRST_ENTRY_READING);
-        for _ in 0..8 {
-            delay_us(FIRST_HALF_SERIAL_DELAY);
-
-            if P::is_low() {
-                data |= 1;
-                reciever_parity_bit ^= 1;
-            } else {
-                data |= 0;
-                reciever_parity_bit ^= 0;
     }
 
-            delay_cycles(READING_ADJUST);
+    fn read_bytes(&self, recieve_data: &mut [u8]) {
-            delay_us(SECOND_HALF_SERIAL_DELAY);
+        for byte in recieve_data {
-
+            if let Ok(data) = <Self as SoftSerialReader<P, &mut [u8]>>::read_byte(self) {
-            data <<= 1;
+                *byte = data;
+            }
+            self.sync_reciever();
         }
-
-        delay_us(FIRST_HALF_SERIAL_DELAY);
-
-        let transmitter_parity_bit = (P::read() >> P::PIN_NUM) & LSB;
-
-        delay_cycles(READING_ADJUST);
-        delay_us(SECOND_HALF_SERIAL_DELAY);
-
-        if reciever_parity_bit != transmitter_parity_bit {
-            return Err((data, reciever_parity_bit));
-        }
-
-        Ok(data)
     }
 }

src/structures/mod.rs

@@ -0,0 +1 @@
+pub mod ring_buffer;

src/structures/ring_buffer.rs

@@ -0,0 +1,148 @@
+// Thanks to Low Byte Productions, I like this channel.
+// Youtube: https://www.youtube.com/watch?v=uIJnATS9j_0
+
+use arduino_hal::port::PinOps;
+use static_pins::StaticPinOps;
+
+use crate::{HalfDuplexSerial, SoftSerialReader, SoftSerialWriter};
+
+#[derive(Debug, Clone, Copy)]
+pub struct RingBuffer<const N: usize> {
+    buf: [u8; N],
+    mask: usize,
+    head: usize,
+    tail: usize,
+}
+
+impl<const N: usize> RingBuffer<N> {
+    #[inline]
+    pub const fn new() -> Self {
+        if N.is_power_of_two() {
+            RingBuffer {
+                buf: [0; N],
+                mask: N - 1,
+                head: 0,
+                tail: 0,
+            }
+        } else {
+            panic!("Buffer capacity isn't power of two");
+        }
+    }
+
+    #[inline(always)]
+    pub fn get_buffer(&self) -> &[u8] {
+        &self.buf
+    }
+
+    #[inline(always)]
+    pub fn is_empty(&self) -> bool {
+        self.head == self.tail
+    }
+
+    #[inline(always)]
+    pub fn is_full(&self) -> bool {
+        (self.head + 1) & self.mask == self.tail
+    }
+
+    #[inline(always)]
+    pub fn capacity(&self) -> usize {
+        N
+    }
+
+    #[inline(always)]
+    pub fn len(&self) -> usize {
+        self.head.overflowing_sub(self.tail).0 & self.mask
+    }
+
+    #[inline(always)]
+    pub fn clear(&mut self) {
+        self.buf = [0; N];
+        self.head = 0;
+        self.tail = 0;
+    }
+
+    #[inline(always)]
+    pub fn push(&mut self, value: u8) -> Option<()> {
+        let (head, tail) = (self.head, self.tail);
+        let next_head = (head + 1) & self.mask;
+
+        if next_head == tail {
+            return None;
+        }
+
+        self.buf[head] = value;
+        self.head = next_head;
+
+        Some(())
+    }
+
+    #[inline(always)]
+    pub fn pop(&mut self) -> Option<u8> {
+        let (head, mut tail) = (self.head, self.tail);
+
+        if head == tail {
+            return None;
+        }
+
+        let value = self.buf[tail];
+        tail = (tail + 1) & self.mask;
+        self.tail = tail;
+
+        Some(value)
+    }
+}
+
+impl<const N: usize> Iterator for RingBuffer<N> {
+    type Item = u8;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.pop()
+    }
+}
+
+impl<const N: usize, P> SoftSerialWriter<P, &mut RingBuffer<N>> for HalfDuplexSerial<P>
+where
+    P: PinOps + StaticPinOps,
+{
+    #[inline(never)]
+    fn write_byte(&self, data: u8) {
+        crate::_priv_write_bytes::<P>(data);
+    }
+
+    fn write_bytes(&self, transmit_data: &mut RingBuffer<N>) {
+        self.sync_transmitter();
+        <Self as SoftSerialWriter<P, &mut RingBuffer<N>>>::write_byte(self, N as u8);
+
+        for _ in 0..N {
+            let byte = transmit_data.pop().unwrap_or(0);
+            self.sync_transmitter();
+            <Self as SoftSerialWriter<P, &mut RingBuffer<N>>>::write_byte(self, byte);
+        }
+    }
+}
+
+impl<const N: usize, P> SoftSerialReader<P, &mut RingBuffer<N>> for HalfDuplexSerial<P>
+where
+    P: PinOps + StaticPinOps,
+{
+    #[inline(never)]
+    fn read_byte(&self) -> crate::ReadByteResult {
+        crate::_priv_read_byte::<P>()
+    }
+
+    fn read_bytes(&self, recieve_data: &mut RingBuffer<N>) {
+        self.sync_reciever();
+        let byte = <Self as SoftSerialReader<P, &mut RingBuffer<N>>>::read_byte(self);
+
+        if let Ok(len) = byte {
+            for _ in 0..len {
+                self.sync_reciever();
+
+                if let Ok(byte) = <Self as SoftSerialReader<P, &mut RingBuffer<N>>>::read_byte(self)
+                {
+                    recieve_data.push(byte).unwrap_or(());
+                }
+            }
+        }
+    }
+}