Strengthens raw midi packet.

It now very strongly depends on U7s when appropriate

src/data/byte/from_traits.rs

@@ -0,0 +1,12 @@
+
+
+/// Like from, but will conceptually overflow if the value is too big
+/// this is useful from going from higher ranges to lower ranges
+pub trait FromOverFlow<T>:Sized  {
+    fn from_overflow(_:T) -> Self;
+}
+
+/// Like from, but will clamp the value to a maximum value
+pub trait FromClamped<T>:Sized{
+    fn from_clamped(_:T) -> Self;
+}

src/data/byte/mod.rs

@@ -1,2 +1,3 @@
 pub mod u7;
 pub mod u4;
+pub mod from_traits;

src/data/byte/u7.rs

@@ -1,4 +1,5 @@
 use core::convert::TryFrom;
+use crate::data::byte::from_traits::{FromOverFlow,FromClamped};
 
 /// A primitive value that can be from 0-0x7F
 pub struct U7(u8);
@@ -24,7 +25,25 @@ impl From<U7> for u8 {
     }
 }
 
+impl FromOverFlow<u8> for U7 {
+    fn from_overflow(value:u8) -> U7 {
+        const MASK :u8 = 0b0111_1111;
+        let value = MASK & value;
+        U7(value)
+    }
+}
+
+impl FromClamped<u8> for U7{
+    fn from_clamped(value:u8) -> U7{
+        match U7::try_from(value) {
+            Ok(x) => x,
+            _ => U7::MAX
+        }
+    }
+}
+
 impl U7 {
     pub const MAX: U7= U7(0x7F);
     pub const MIN: U7 = U7(0);
+
 }

src/data/midi/message/message.rs

@@ -1,10 +1,11 @@
 
 use crate::data::midi::channel::Channel;
-use crate::data::midi::velocity::Velocity;
 use crate::data::midi::notes::Note;
 use crate::data::byte::u7::U7;
 use crate::data::midi::message::raw::{Raw,Payload};
 
+type Velocity = U7;
+
 /// Represents midi messages
 /// Note: not current exhaustive and SysEx messages end up
 /// being a confusing case. So are currently note implemented 
@@ -29,32 +30,32 @@ impl From<Message> for Raw {
     fn from(value:Message) -> Raw {
         match value {
             Message::NoteOn(chan,note,vel)  =>  {
-                let payload = Payload::DoubleByte(note.into(),vel.into());
+                let payload = Payload::DoubleByte(note.into(),vel);
                 let status =  NOTE_ON_MASK | u8::from(chan);
                 Raw { status, payload  }
             },
             Message::NoteOff(chan,note,vel) => {
-                let payload = Payload::DoubleByte(note.into(),vel.into());
+                let payload = Payload::DoubleByte(note.into(),vel);
                 let status = NOTE_OFF_MASK | u8::from(chan);
                 Raw {status, payload}
             },
             Message::PolyphonicAftertouch(chan,note,pressure) => {
-                let payload = Payload::DoubleByte(note.into(),pressure.into());
+                let payload = Payload::DoubleByte(note.into(),pressure);
                 let status = POLYPHONIC_MASK | u8::from(chan);
                 Raw {status, payload}
             },
             Message::ProgramChange(chan,program) => {
-                let payload = Payload::SingleByte(u8::from(program));
+                let payload = Payload::SingleByte(program);
                 let status = PROGRAM_MASK | u8::from(chan);
                 Raw {status, payload}
             },
             Message::ChannelAftertouch(chan,pressure) => {
-                let payload = Payload::SingleByte(u8::from(pressure));
+                let payload = Payload::SingleByte(pressure);
                 let status = CHANNEL_AFTERTOUCH_MASK | u8::from(chan);
                 Raw {status, payload}
             },
             Message::PitchWheelChange(chan,lsb,msb) => {
-                let payload = Payload::DoubleByte(u8::from(lsb),u8::from(msb));
+                let payload = Payload::DoubleByte(lsb,msb);
                 let status = PITCH_BEND_MASK | u8::from(chan);
                 Raw {status , payload}
             }

src/data/midi/message/mod.rs

@@ -1,4 +1,3 @@
-pub mod voice;
 pub mod message;
 pub mod raw;
 pub use crate::data::midi::message::message::{Message};

src/data/midi/message/raw.rs

@@ -1,8 +1,10 @@
+use crate::data::byte::u7::U7;
+
 /// Represents the payloads that the midi message may contain
 pub enum Payload {
     Empty,
-    SingleByte(u8),
+    SingleByte(U7),
-    DoubleByte(u8,u8)
+    DoubleByte(U7,U7)
 }
 
 /// A struct that captures the valid states

src/data/midi/message/voice.rs

@@ -1,15 +0,0 @@
-
-pub use crate::data::midi::channel::Channel;
-pub use crate::data::midi::notes::Note;
-pub use crate::data::midi::velocity::Velocity;
-
-pub enum Voice { 
-    NoteOff(Channel,Note,Velocity),
-    NoteOn(Channel,Note,Velocity),
-    PolyPressure(Channel)
-}
-
-
-impl Voice {
-    
-}

src/data/midi/mod.rs

@@ -1,4 +1,3 @@
 pub mod notes;
 pub mod channel;
 pub mod message;
-pub mod velocity;

src/data/midi/notes.rs

@@ -1,4 +1,5 @@
-
+use crate::data::byte::u7::U7;
+use crate::data::byte::from_traits::FromOverFlow;
 /// A simple enum type that represents all the midi 'notes'
 /// note the flat versions are associated constants
 /// but can be referenced like Note::Bb3
@@ -26,6 +27,14 @@ impl Into<u8> for Note {
     }
 }
 
+impl From<Note> for U7 {
+    fn from(value:Note) -> U7{
+        let byte = value as u8;
+        U7::from_overflow(byte)
+    }
+}
+
+
 impl Note {
     #[allow(non_upper_case_globals)] pub const Db1m : Note = Note::Cs1m;
     #[allow(non_upper_case_globals)] pub const Eb1m : Note = Note::Ds1m;

src/data/midi/velocity.rs

@@ -1,28 +0,0 @@
-use core::convert::TryFrom;
-
-pub struct Velocity(u8);
-
-pub struct InvalidVelocity(u8);
-
-impl TryFrom<u8> for Velocity{
-    type Error = InvalidVelocity;
-
-    fn try_from(value:u8) -> Result<Self,Self::Error> {
-        if value > 0x7F {
-            Err(InvalidVelocity(value))
-        } else {
-            Ok(Velocity(value))
-        }
-    }
-}
-
-impl Into<u8> for Velocity {
-    fn into(self) -> u8 {
-        self.0
-    }
-}
-
-impl Velocity {
-    pub const MAX: Velocity= Velocity(0x7F);
-    pub const MIN: Velocity = Velocity(0);
-}

src/data/usb_midi/usb_midi_event_packet.rs

@@ -28,8 +28,10 @@ impl From<UsbMidiEventPacket> for [u8;4] {
 
         match raw_midi.payload {
             Payload::Empty => [header,status,0,0],
-            Payload::SingleByte(byte) => [header,status,byte,0],
+            Payload::SingleByte(byte) => 
-            Payload::DoubleByte(byte1,byte2) => [header,status,byte1,byte2]           
+                                [header,status,byte.into(),0],
+            Payload::DoubleByte(byte1,byte2) => 
+                                    [header,status,byte1.into(),byte2.into()]           
         }
     }
 }