From a089eaa8682927ea1d21f6dc5ce1d30c78140852 Mon Sep 17 00:00:00 2001 From: Fred Sundvik Date: Sun, 14 Feb 2016 17:45:25 +0200 Subject: [PATCH] Add sending of small frames with no zeroes --- serial_link/protocol/byte_stuffer.c | 12 +++++- serial_link/protocol/byte_stuffer.h | 1 + serial_link/protocol/physical.h | 25 +++++++++++ serial_link/tests/byte_stuffer_tests.c | 60 +++++++++++++++++++------- 4 files changed, 82 insertions(+), 16 deletions(-) create mode 100644 serial_link/protocol/physical.h diff --git a/serial_link/protocol/byte_stuffer.c b/serial_link/protocol/byte_stuffer.c index f0071b1f77..dfd5942ebc 100644 --- a/serial_link/protocol/byte_stuffer.c +++ b/serial_link/protocol/byte_stuffer.c @@ -24,7 +24,7 @@ SOFTWARE. #include "protocol/byte_stuffer.h" #include "protocol/frame_validator.h" -#include +#include "protocol/physical.h" // This implements the "Consistent overhead byte stuffing protocol" // https://en.wikipedia.org/wiki/Consistent_Overhead_Byte_Stuffing @@ -92,3 +92,13 @@ void recv_byte(byte_stuffer_state_t* state, uint8_t data) { } } } + +void send_frame(uint8_t* data, uint16_t size) { + if (size > 0) { + uint8_t numZeroes = size + 1; + const uint8_t zero = 0; + send_data(&numZeroes, 1); + send_data(data, size); + send_data(&zero, 1); + } +} diff --git a/serial_link/protocol/byte_stuffer.h b/serial_link/protocol/byte_stuffer.h index 9a5551fab5..ea6b8451d4 100644 --- a/serial_link/protocol/byte_stuffer.h +++ b/serial_link/protocol/byte_stuffer.h @@ -25,3 +25,4 @@ SOFTWARE. typedef struct byte_stuffer_state byte_stuffer_state_t; void init_byte_stuffer_state(byte_stuffer_state_t* state); void recv_byte(byte_stuffer_state_t* state, uint8_t data); +void send_frame(uint8_t* data, uint16_t size); diff --git a/serial_link/protocol/physical.h b/serial_link/protocol/physical.h new file mode 100644 index 0000000000..73a7855dfb --- /dev/null +++ b/serial_link/protocol/physical.h @@ -0,0 +1,25 @@ +/* +The MIT License (MIT) + +Copyright (c) 2016 Fred Sundvik + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +void send_data(const uint8_t* data, uint16_t size); diff --git a/serial_link/tests/byte_stuffer_tests.c b/serial_link/tests/byte_stuffer_tests.c index bfa0193861..6e44c9170c 100644 --- a/serial_link/tests/byte_stuffer_tests.c +++ b/serial_link/tests/byte_stuffer_tests.c @@ -27,12 +27,16 @@ SOFTWARE. #include "protocol/byte_stuffer.h" #include "protocol/byte_stuffer.c" #include "protocol/frame_validator.h" +#include "protocol/physical.h" -byte_stuffer_state_t state; +static byte_stuffer_state_t state; +static uint8_t sent_data[MAX_FRAME_SIZE*2]; +static uint16_t sent_data_size; Describe(ByteStuffer); BeforeEach(ByteStuffer) { init_byte_stuffer_state(&state); + sent_data_size = 0; } AfterEach(ByteStuffer) {} @@ -40,6 +44,11 @@ void recv_frame(uint8_t* data, uint16_t size) { mock(data, size); } +void send_data(const uint8_t* data, uint16_t size) { + memcpy(sent_data + sent_data_size, data, size); + sent_data_size += size; +} + Ensure(ByteStuffer, receives_no_frame_for_a_single_zero_byte) { never_expect(recv_frame); recv_byte(&state, 0); @@ -66,7 +75,7 @@ Ensure(ByteStuffer, receives_single_byte_valid_frame) { expect(recv_frame, when(size, is_equal_to(1)), when(data, is_equal_to_contents_of(expected, 1)) - ); + ); recv_byte(&state, 2); recv_byte(&state, 0x37); recv_byte(&state, 0); @@ -77,7 +86,7 @@ Ensure(ByteStuffer, receives_three_bytes_valid_frame) { expect(recv_frame, when(size, is_equal_to(3)), when(data, is_equal_to_contents_of(expected, 3)) - ); + ); recv_byte(&state, 4); recv_byte(&state, 0x37); recv_byte(&state, 0x99); @@ -90,7 +99,7 @@ Ensure(ByteStuffer, receives_single_zero_valid_frame) { expect(recv_frame, when(size, is_equal_to(1)), when(data, is_equal_to_contents_of(expected, 1)) - ); + ); recv_byte(&state, 1); recv_byte(&state, 1); recv_byte(&state, 0); @@ -101,7 +110,7 @@ Ensure(ByteStuffer, receives_valid_frame_with_zeroes) { expect(recv_frame, when(size, is_equal_to(4)), when(data, is_equal_to_contents_of(expected, 4)) - ); + ); recv_byte(&state, 2); recv_byte(&state, 5); recv_byte(&state, 2); @@ -116,11 +125,11 @@ Ensure(ByteStuffer, receives_two_valid_frames) { expect(recv_frame, when(size, is_equal_to(2)), when(data, is_equal_to_contents_of(expected1, 2)) - ); + ); expect(recv_frame, when(size, is_equal_to(1)), when(data, is_equal_to_contents_of(expected2, 1)) - ); + ); recv_byte(&state, 2); recv_byte(&state, 5); recv_byte(&state, 1); @@ -135,7 +144,7 @@ Ensure(ByteStuffer, receives_valid_frame_after_unexpected_zero) { expect(recv_frame, when(size, is_equal_to(2)), when(data, is_equal_to_contents_of(expected, 2)) - ); + ); recv_byte(&state, 3); recv_byte(&state, 1); recv_byte(&state, 0); @@ -150,7 +159,7 @@ Ensure(ByteStuffer, receives_valid_frame_after_unexpected_non_zero) { expect(recv_frame, when(size, is_equal_to(2)), when(data, is_equal_to_contents_of(expected, 2)) - ); + ); recv_byte(&state, 2); recv_byte(&state, 9); recv_byte(&state, 4); // This should have been zero @@ -170,7 +179,7 @@ Ensure(ByteStuffer, receives_a_valid_frame_with_over254_non_zeroes_and_then_end_ expect(recv_frame, when(size, is_equal_to(254)), when(data, is_equal_to_contents_of(expected, 254)) - ); + ); recv_byte(&state, 0xFF); for (i=0;i<254;i++) { recv_byte(&state, i+1); @@ -188,7 +197,7 @@ Ensure(ByteStuffer, receives_a_valid_frame_with_over254_non_zeroes_next_byte_is_ expect(recv_frame, when(size, is_equal_to(255)), when(data, is_equal_to_contents_of(expected, 255)) - ); + ); recv_byte(&state, 0xFF); for (i=0;i<254;i++) { recv_byte(&state, i+1); @@ -208,7 +217,7 @@ Ensure(ByteStuffer, receives_a_valid_frame_with_over254_non_zeroes_next_byte_is_ expect(recv_frame, when(size, is_equal_to(255)), when(data, is_equal_to_contents_of(expected, 255)) - ); + ); recv_byte(&state, 0xFF); for (i=0;i<254;i++) { recv_byte(&state, i+1); @@ -233,7 +242,7 @@ Ensure(ByteStuffer, receives_two_long_frames_and_some_more) { expect(recv_frame, when(size, is_equal_to(515)), when(data, is_equal_to_contents_of(expected, 510)) - ); + ); recv_byte(&state, 0xFF); for (i=0;i<254;i++) { recv_byte(&state, i+1); @@ -258,7 +267,7 @@ Ensure(ByteStuffer, receives_an_all_zeros_frame_that_is_maximum_size) { expect(recv_frame, when(size, is_equal_to(MAX_FRAME_SIZE)), when(data, is_equal_to_contents_of(expected, MAX_FRAME_SIZE)) - ); + ); int i; recv_byte(&state, 1); for(i=0;i