From 6f3a81ed8287357b54aad16bff27495c6eaca6df Mon Sep 17 00:00:00 2001 From: Christopher Peplin Date: Fri, 3 Jan 2014 23:45:40 -0500 Subject: [PATCH] Checkpoint commit renaming some functions for clarity. --- src/bitfield/8byte.c | 4 ++-- src/bitfield/8byte.h | 10 +++++----- src/canutil/read.c | 16 +++++++++++----- src/canutil/read.h | 10 +++++++--- src/canutil/write.c | 14 +++++++++++--- src/canutil/write.h | 18 +++++++++++------- tests/8byte_tests.c | 40 ++++++++++++++++++++-------------------- tests/read_tests.c | 4 ++-- tests/write_tests.c | 10 +++++----- 9 files changed, 74 insertions(+), 52 deletions(-) diff --git a/src/bitfield/8byte.c b/src/bitfield/8byte.c index bfceb788..76dccc75 100644 --- a/src/bitfield/8byte.c +++ b/src/bitfield/8byte.c @@ -8,7 +8,7 @@ uint8_t eightbyte_get_nibble(const uint64_t source, const uint8_t nibble_index, const bool data_is_big_endian) { - return get_bit_field(source, NIBBLE_SIZE * nibble_index, NIBBLE_SIZE, + return eightbyte_get_bit_field(source, NIBBLE_SIZE * nibble_index, NIBBLE_SIZE, data_is_big_endian); } @@ -20,7 +20,7 @@ uint8_t eightbyte_get_byte(uint64_t source, const uint8_t byte_index, return (source >> (EIGHTBYTE_BIT - ((byte_index + 1) * CHAR_BIT))) & 0xFF; } -uint64_t get_bit_field(uint64_t source, const uint16_t offset, +uint64_t eightbyte_get_bit_field(uint64_t source, const uint16_t offset, const uint16_t bit_count, const bool data_is_big_endian) { int startByte = offset / CHAR_BIT; int endByte = (offset + bit_count - 1) / CHAR_BIT; diff --git a/src/bitfield/8byte.h b/src/bitfield/8byte.h index 0abc1f07..194007c8 100644 --- a/src/bitfield/8byte.h +++ b/src/bitfield/8byte.h @@ -36,7 +36,7 @@ extern "C" { * * Returns the value of the requested bit field, right aligned in a uint64_t. */ -uint64_t get_bit_field(uint64_t source, const uint16_t offset, +uint64_t eightbyte_get_bit_field(uint64_t source, const uint16_t offset, const uint16_t bit_count, const bool data_is_big_endian); /* Public: Return a single nibble from the payload, with range checking. @@ -50,7 +50,7 @@ uint64_t get_bit_field(uint64_t source, const uint16_t offset, * Returns the retreived nibble, right aligned in a uint8_t. */ uint8_t eightbyte_get_nibble(const uint64_t source, const uint8_t nibble_index, - const bool data_is_big_endian); + const bool data_is_big_endian); /* Public: Return a single byte from the payload, with range checking. * @@ -62,7 +62,7 @@ uint8_t eightbyte_get_nibble(const uint64_t source, const uint8_t nibble_index, * Returns the retreived byte. */ uint8_t eightbyte_get_byte(const uint64_t source, const uint8_t byte_index, - const bool data_is_big_endian); + const bool data_is_big_endian); /* Public: Set the bit field in the given data array to the new value. * @@ -74,8 +74,8 @@ uint8_t eightbyte_get_byte(const uint64_t source, const uint8_t byte_index, * Returns true if the bit_count is enough to fully represent the value, and * false if it will not fit. */ -bool set_bit_field(uint64_t* destination, uint64_t value, const uint16_t offset, - const uint16_t bit_count); +bool eightbyte_set_bit_field(uint64_t* destination, uint64_t value, + const uint16_t offset, const uint16_t bit_count); /* Private: Determine the index of the last bit used. */ diff --git a/src/canutil/read.c b/src/canutil/read.c index fddf75e3..4864a60f 100644 --- a/src/canutil/read.c +++ b/src/canutil/read.c @@ -2,15 +2,21 @@ #include #include -float bitfield_parse_float(uint64_t data, uint8_t bit_offset, uint8_t bit_size, +float eightbyte_parse_float(uint64_t data, uint8_t bit_offset, uint8_t bit_size, float factor, float offset) { - uint64_t raw = get_bit_field(data, bit_offset, - bit_size, true); + uint64_t raw = eightbyte_get_bit_field(data, bit_offset, bit_size, true); return raw * factor + offset; } -bool bitfield_parse_bool(uint64_t data, uint8_t bit_offset, uint8_t bit_size, +bool eightbyte_parse_bool(uint64_t data, uint8_t bit_offset, uint8_t bit_size, float factor, float offset) { - float value = bitfield_parse_float(data, bit_offset, bit_size, factor, offset); + float value = eightbyte_parse_float(data, bit_offset, bit_size, factor, offset); return value == 0.0 ? false : true; } + +float bitfield_parse_float(const uint8_t data[], const uint16_t size, + const uint8_t bit_offset, const uint8_t bit_size, const float factor, + const float offset) { + //TODO + return 0; +} diff --git a/src/canutil/read.h b/src/canutil/read.h index 865bb278..bf6c0ade 100644 --- a/src/canutil/read.h +++ b/src/canutil/read.h @@ -20,8 +20,12 @@ extern "C" { * * Returns the decoded and transformed value of the signal. */ -float bitfield_parse_float(uint64_t data, uint8_t bit_offset, uint8_t bit_size, - float factor, float offset); +float eightbyte_parse_float(const uint64_t data, const uint8_t bit_offset, + const uint8_t bit_size, const float factor, const float offset); + +float bitfield_parse_float(const uint8_t data[], const uint16_t size, + const uint8_t bit_offset, const uint8_t bit_size, const float factor, + const float offset); /* Public: Parse a CAN signal from a message and interpret it as a boolean. * @@ -35,7 +39,7 @@ float bitfield_parse_float(uint64_t data, uint8_t bit_offset, uint8_t bit_size, * * Returns false if the value was 0, otherwise true. */ -bool bitfield_parse_bool(uint64_t data, uint8_t bit_offset, uint8_t bit_size, +bool eightbyte_parse_bool(uint64_t data, uint8_t bit_offset, uint8_t bit_size, float factor, float offset); #ifdef __cplusplus diff --git a/src/canutil/write.c b/src/canutil/write.c index 12c8fa28..09e6caa3 100644 --- a/src/canutil/write.c +++ b/src/canutil/write.c @@ -2,11 +2,13 @@ #include #include -uint64_t bitfield_encode_float(float value, uint8_t bit_offset, uint8_t bit_size, +uint64_t eightbyte_encode_float(float value, uint8_t bit_offset, uint8_t bit_size, float factor, float offset) { float raw = (value - offset) / factor; if(raw > 0) { // round up to avoid losing precision when we cast to an int + // TODO do we need a way to encode an int back to a signal without any + // rounding? raw += 0.5; } uint64_t result = 0; @@ -16,7 +18,13 @@ uint64_t bitfield_encode_float(float value, uint8_t bit_offset, uint8_t bit_size return result; } -uint64_t bitfield_encode_bool(const bool value, const uint8_t bit_offset, +uint64_t eightbyte_encode_bool(const bool value, const uint8_t bit_offset, const uint8_t bit_size) { - return bitfield_encode_float(value, bit_offset, bit_size, 1.0, 0); + return eightbyte_encode_float(value, bit_offset, bit_size, 1.0, 0); +} + +bool bitfield_encode_float(float value, uint8_t bit_offset, + uint8_t bit_size, float factor, float offset, uint8_t destination[]) { + // TODO + return 0; } diff --git a/src/canutil/write.h b/src/canutil/write.h index f117a06c..8fd18cdb 100644 --- a/src/canutil/write.h +++ b/src/canutil/write.h @@ -14,8 +14,8 @@ extern "C" { * value - the floating point value to encode. * bit_offset - the starting point for the encoded bits in the returned value. * bit_size - The max width of the field in the resulting bit array. If bit_size - * isn't big enough to store the fixed point version of the value, the bitfeld - * will *not* be set. TODO some error reporting would be nice. + * isn't big enough to store the fixed point version of the value, the + * bitfeld will *not* be set. TODO some error reporting would be nice. * factor - a factor used to transform from floating to fixed point before * encoding. Use 1.0 for no factor. * offset - an offset used to transform from floating to fixed point before @@ -23,20 +23,24 @@ extern "C" { * * Returns a big-endian uint64_t with the value encoded as a bitfield. */ -uint64_t bitfield_encode_float(float value, uint8_t bit_offset, uint8_t bit_size, - float factor, float offset); +uint64_t eightbyte_encode_float(float value, uint8_t bit_offset, + uint8_t bit_size, float factor, float offset); + +bool bitfield_encode_float(float value, uint8_t bit_offset, + uint8_t bit_size, float factor, float offset, uint8_t destination[]); /* Public: Encode a boolean into fixed bit width field in a bit array. * * value - the boolean value to encode - true will be 1, false will be 0. * bit_offset - the starting point for the encoded bits in the returned value. * bit_size - The max width of the field in the resulting bit array. If bit_size - * isn't big enough to store the fixed point version of the value, the bitfeld - * will *not* be set. TODO some error reporting would be nice. + * isn't big enough to store the fixed point version of the value, the + * bitfeld will *not* be set. TODO some error reporting would be nice. * * Returns a big-endian uint64_t with the value encoded as a bitfield. */ -uint64_t bitfield_encode_bool(const bool value, const uint8_t bit_offset, const uint8_t bit_size); +uint64_t eightbyte_encode_bool(const bool value, const uint8_t bit_offset, + const uint8_t bit_size); #ifdef __cplusplus } diff --git a/tests/8byte_tests.c b/tests/8byte_tests.c index de5adfa7..5ebb0db0 100644 --- a/tests/8byte_tests.c +++ b/tests/8byte_tests.c @@ -12,7 +12,7 @@ END_TEST START_TEST (test_one_bit_not_swapped) { uint64_t data = 0x80; - uint64_t result = get_bit_field(data, 0, 1, false); + uint64_t result = eightbyte_get_bit_field(data, 0, 1, false); fail_if(result == 1); } END_TEST @@ -20,7 +20,7 @@ END_TEST START_TEST (test_one_bit) { uint64_t data = 0x8000000000000000; - uint64_t result = get_bit_field(data, 0, 1, false); + uint64_t result = eightbyte_get_bit_field(data, 0, 1, false); fail_unless(result == 0x1, "First bit in 0x%llx was 0x%llx instead of 0x1", data, result); } @@ -29,7 +29,7 @@ END_TEST START_TEST (test_32_bit_parse) { uint64_t data = 0x0402574d555a0401; - uint64_t result = get_bit_field(data, 16, 32, false); + uint64_t result = eightbyte_get_bit_field(data, 16, 32, false); uint64_t expectedValue = 0x574d555a; fail_unless(result == expectedValue, "Field retrieved in 0x%llx was 0x%llx instead of 0x%llx", data, @@ -40,7 +40,7 @@ END_TEST START_TEST (test_16_bit_parse) { uint64_t data = 0xF34DFCFF00000000; - uint64_t result = get_bit_field(data, 16, 16, false); + uint64_t result = eightbyte_get_bit_field(data, 16, 16, false); uint64_t expectedValue = 0xFCFF; fail_unless(result == expectedValue, "Field retrieved in 0x%llx was 0x%llx instead of 0x%llx", data, @@ -51,13 +51,13 @@ END_TEST START_TEST (test_one_byte) { uint64_t data = 0xFA00000000000000; - uint64_t result = get_bit_field(data, 0, 4, false); + uint64_t result = eightbyte_get_bit_field(data, 0, 4, false); fail_unless(result == 0xF, "First nibble in 0x%llx was 0x%llx instead of 0xF", data, result); - result = get_bit_field(data, 4, 4, false); + result = eightbyte_get_bit_field(data, 4, 4, false); fail_unless(result == 0xA, "Second nibble in 0x%llx was 0x%llx instead of 0xA", data, result); - result = get_bit_field(data, 0, 8, false); + result = eightbyte_get_bit_field(data, 0, 8, false); fail_unless(result == 0xFA, "All bits in 0x%llx were 0x%llx instead of 0x%llx", data, result, data); } @@ -66,19 +66,19 @@ END_TEST START_TEST (test_multi_byte) { uint64_t data = 0x12FA000000000000; - uint64_t result = get_bit_field(data, 0, 4, false); + uint64_t result = eightbyte_get_bit_field(data, 0, 4, false); fail_unless(result == 0x1, "First 4 bits in 0x%llx was 0x%llx instead of 0xF", (data >> 60) & 0xF, result); - result = get_bit_field(data, 4, 4, false); + result = eightbyte_get_bit_field(data, 4, 4, false); fail_unless(result == 0x2, "Second 4 bits in 0x%llx was 0x%llx instead of 0xA", (data >> 56) & 0xF, result); - result = get_bit_field(data, 8, 4, false); + result = eightbyte_get_bit_field(data, 8, 4, false); fail_unless(result == 0xF, "First 4 bits in 0x%llx was 0x%llx instead of 0x1", (data >> 52) & 0xF, result); - result = get_bit_field(data, 12, 4, false); + result = eightbyte_get_bit_field(data, 12, 4, false); fail_unless(result == 0xA, "Second 4 bits in 0x%llx was 0x%llx instead of 0x2", (data >> 48) % 0xF, result); @@ -88,7 +88,7 @@ END_TEST START_TEST (test_get_multi_byte) { uint64_t data = 0x12FA000000000000; - uint64_t result = get_bit_field(data, 0, 9, false); + uint64_t result = eightbyte_get_bit_field(data, 0, 9, false); ck_assert_int_eq(result, 0x25); } END_TEST @@ -96,7 +96,7 @@ END_TEST START_TEST (test_get_off_byte_boundary) { uint64_t data = 0x000012FA00000000; - uint64_t result = get_bit_field(data, 12, 8, false); + uint64_t result = eightbyte_get_bit_field(data, 12, 8, false); ck_assert_int_eq(result, 0x01); } END_TEST @@ -111,16 +111,16 @@ START_TEST (test_set_field) { uint64_t data = 0; fail_unless(set_bit_field(&data, 1, 0, 1)); - uint64_t result = get_bit_field(data, 0, 1, false); + uint64_t result = eightbyte_get_bit_field(data, 0, 1, false); ck_assert_int_eq(result, 0x1); data = 0; fail_unless(set_bit_field(&data, 1, 1, 1)); - result = get_bit_field(data, 1, 1, false); + result = eightbyte_get_bit_field(data, 1, 1, false); ck_assert_int_eq(result, 0x1); data = 0; fail_unless(set_bit_field(&data, 0xf, 3, 4)); - result = get_bit_field(data, 3, 4, false); + result = eightbyte_get_bit_field(data, 3, 4, false); ck_assert_int_eq(result, 0xf); } END_TEST @@ -129,7 +129,7 @@ START_TEST (test_set_doesnt_clobber_existing_data) { uint64_t data = 0xFFFC4DF300000000; fail_unless(set_bit_field(&data, 0x4fc8, 16, 16)); - uint64_t result = get_bit_field(data, 16, 16, false); + uint64_t result = eightbyte_get_bit_field(data, 16, 16, false); fail_unless(result == 0x4fc8, "Field retrieved in 0x%llx was 0x%llx instead of 0x%x", data, result, 0xc84f); @@ -146,7 +146,7 @@ START_TEST (test_set_off_byte_boundary) { uint64_t data = 0xFFFC4DF300000000; fail_unless(set_bit_field(&data, 0x12, 12, 8)); - uint64_t result = get_bit_field(data, 12, 12, false); + uint64_t result = eightbyte_get_bit_field(data, 12, 12, false); ck_assert_int_eq(result,0x12d); } END_TEST @@ -155,14 +155,14 @@ START_TEST (test_set_odd_number_of_bits) { uint64_t data = 0xFFFC4DF300000000LLU; fail_unless(set_bit_field(&data, 0x12, 11, 5)); - uint64_t result = get_bit_field(data, 11, 5, false); + uint64_t result = eightbyte_get_bit_field(data, 11, 5, false); fail_unless(result == 0x12, "Field set in 0x%llx%llx%llx%llx was 0x%llx instead of 0x%llx", data, result, 0x12); data = 0xFFFC4DF300000000LLU; fail_unless(set_bit_field(&data, 0x2, 11, 5)); - result = get_bit_field(data, 11, 5, false); + result = eightbyte_get_bit_field(data, 11, 5, false); fail_unless(result == 0x2, "Field set in 0x%llx%llx%llx%llx was 0x%llx instead of 0x%llx", data, result, 0x2); diff --git a/tests/read_tests.c b/tests/read_tests.c index 71b0ab65..1cde4612 100644 --- a/tests/read_tests.c +++ b/tests/read_tests.c @@ -6,7 +6,7 @@ const uint64_t BIG_ENDIAN_TEST_DATA = __builtin_bswap64(0xEB00000000000000); START_TEST (test_parse_float) { - float result = bitfield_parse_float(BIG_ENDIAN_TEST_DATA, 2, 4, 1001.0, + float result = eightbyte_parse_float(BIG_ENDIAN_TEST_DATA, 2, 4, 1001.0, -30000.0); float correctResult = 0xA * 1001.0 - 30000.0; fail_unless(result == correctResult, @@ -16,7 +16,7 @@ END_TEST START_TEST (test_parse_bool) { - float result = bitfield_parse_bool(BIG_ENDIAN_TEST_DATA, 0, 1, 1.0, 0); + float result = eightbyte_parse_bool(BIG_ENDIAN_TEST_DATA, 0, 1, 1.0, 0); float correctResult = true; fail_unless(result == correctResult, "parse is incorrect: %d but should be %d", result, correctResult); diff --git a/tests/write_tests.c b/tests/write_tests.c index 4091ac4f..8f34a468 100644 --- a/tests/write_tests.c +++ b/tests/write_tests.c @@ -4,26 +4,26 @@ START_TEST (test_encode_can_signal) { - uint64_t value = bitfield_encode_float(0, 1, 3, 1, 0); + uint64_t value = eightbyte_encode_float(0, 1, 3, 1, 0); ck_assert_int_eq(value, 0); - value = bitfield_encode_float(1, 1, 3, 1, 0); + value = eightbyte_encode_float(1, 1, 3, 1, 0); ck_assert_int_eq(value, 0x1000000000000000LLU); } END_TEST START_TEST (test_encode_can_signal_rounding_precision) { - uint64_t value = bitfield_encode_float(50, 2, 19, 0.001, 0); + uint64_t value = eightbyte_encode_float(50, 2, 19, 0.001, 0); ck_assert_int_eq(value, 0x061a800000000000LLU); } END_TEST START_TEST (test_encode_bool) { - uint64_t value = bitfield_encode_bool(true, 1, 3); + uint64_t value = eightbyte_encode_bool(true, 1, 3); ck_assert_int_eq(value, 0x1000000000000000LLU); - value = bitfield_encode_bool(false, 1, 3); + value = eightbyte_encode_bool(false, 1, 3); ck_assert_int_eq(value, 0x0000000000000000LLU); } END_TEST -- 2.16.6