├── .gitignore ├── LICENSE ├── Makefile ├── README.md ├── include └── libwecan.h ├── src └── libwecan.c └── tests ├── Makefile └── src └── tests.c /.gitignore: -------------------------------------------------------------------------------- 1 | lib/ 2 | bin/ 3 | obj/ 4 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2018 nisennenmondai 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | SRC_DIR += src 2 | OBJ_DIR += obj 3 | LIB_DIR += lib 4 | 5 | LIB += $(LIB_DIR)/libwecan.so 6 | SRC += $(wildcard $(SRC_DIR)/*.c) 7 | OBJ += $(SRC:$(SRC_DIR)/%.c=$(OBJ_DIR)/%.o) 8 | 9 | CFLAGS += -g 10 | CFLAGS += -Wall 11 | CFLAGS += -fPIC 12 | CFLAGS += -Iinclude/ 13 | CFLAGS += -MD 14 | 15 | LDFLAGS += -shared 16 | 17 | .PHONY: all clean 18 | 19 | all: $(LIB) build-tests 20 | 21 | $(LIB): $(OBJ) | $(LIB_DIR) 22 | $(CC) $(LDFLAGS) -o $@ $^ 23 | 24 | $(OBJ_DIR)/%.o: $(SRC_DIR)/%.c | $(OBJ_DIR) 25 | $(CC) $(CFLAGS) -o $@ -c $< 26 | 27 | $(LIB_DIR) $(OBJ_DIR): 28 | mkdir -p $@ 29 | 30 | build-tests: 31 | cd tests/; make 32 | 33 | run-tests: 34 | cd tests/bin/; ./tests 35 | 36 | clean: 37 | @$(RM) -rv $(LIB_DIR) $(OBJ_DIR) 38 | cd tests/; make clean 39 | 40 | -include $(OBJ:.o=.d) 41 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # libwecan 2 | 3 | Library in C to encode/decode CAN signals. 4 | 5 | ### Install 6 | ```sh 7 | make 8 | make run-tests 9 | ``` 10 | -------------------------------------------------------------------------------- /include/libwecan.h: -------------------------------------------------------------------------------- 1 | #ifndef LIBWECAN_H 2 | #define LIBWECAN_H 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | #define FALSE 0 9 | #define TRUE 1 10 | #define UNSIGNED 2 11 | #define SIGNED 3 12 | #define INTEL 4 13 | #define MOTOROLA 5 14 | 15 | /* 16 | * @brief extract a signal value from a CAN frame 17 | * @param frame frame data address 18 | * @param startbit signal start bit 19 | * @param len signal len in bits 20 | * @param signedness 21 | * @param endianness 22 | * @return signal value as uint64 ready for decoding by using Factor and Offset 23 | * If the signal value is signed (and negative), just cast the extracted 24 | * value to int64 to get its value thanks to the algo of sign bit 25 | * extension 26 | */ 27 | uint64_t extract(const uint8_t *frame, const uint16_t startbit, 28 | const uint8_t len, uint8_t signedness, uint8_t endianness); 29 | 30 | /* 31 | * @brief insert a signal value into a CAN frame 32 | * @param frame [In/Out] frame data address 33 | * @param startbit signal start bit 34 | * @param len signal len in bits 35 | * @param value signal value 36 | * @param endianness 37 | */ 38 | void insert(uint8_t *frame, uint16_t startbit, uint8_t len, 39 | uint64_t can_value, uint8_t endianness); 40 | 41 | /* 42 | * @brief encode a physical value into CAN format and insert it into a frame 43 | */ 44 | void encode_uint64_t(uint8_t *frame, uint64_t phy_value, uint16_t startbit, 45 | uint8_t len, uint8_t endianness, 46 | double factor, double offset); 47 | 48 | void encode_int64_t(uint8_t *frame, int64_t phy_value, uint16_t startbit, 49 | uint8_t len, uint8_t endianness, 50 | double factor, double offset); 51 | 52 | void encode_double(uint8_t *frame, double phy_value, uint16_t startbit, 53 | uint8_t len, uint8_t endianness, 54 | double factor, double offset); 55 | 56 | void encode_float(uint8_t *frame, float phy_value, uint16_t startbit, 57 | uint8_t len, uint8_t endianness, 58 | double factor, double offset); 59 | 60 | /* 61 | * @brief extract a signal and decode it into a physical value 62 | */ 63 | uint64_t decode_uint64_t(uint8_t *frame, uint16_t startbit, uint8_t len, 64 | uint8_t endianness, double factor, double offset); 65 | 66 | int64_t decode_int64_t(uint8_t *frame, uint16_t startbit, uint8_t len, 67 | uint8_t endianness, double factor, double offset); 68 | 69 | double decode_double(uint8_t *frame, uint16_t startbit, uint8_t len, 70 | uint8_t endianness, double factor, double offset); 71 | 72 | float decode_float(uint8_t *frame, uint16_t startbit, uint8_t len, 73 | uint8_t endianness, double factor, double offset); 74 | 75 | #endif /* LIBWECAN_H */ 76 | -------------------------------------------------------------------------------- /src/libwecan.c: -------------------------------------------------------------------------------- 1 | #include "libwecan.h" 2 | 3 | /* 4 | * @brief return byte indexes of msb, lsb and lsb bit offset from signal params 5 | * @param startbit [In] signal startbit = lsb in case of little-endian, msb else 6 | * @param len [In] signal len in bits 7 | * @param endianness INTEL if signal data is in little endian format 8 | * @param offset_lsb [Out] offset (0..7) of the lsb in its containing byte 9 | * @param byte_idx_lsb [Out] byte index of the lsb from the matrix start 10 | * @param byte_idx_msb [Out] byte index of the msb from the matrix start 11 | */ 12 | static void compute_indexes(const uint16_t startbit, const uint8_t len, 13 | uint8_t endianness, uint16_t *offset_lsb, 14 | uint16_t *byte_idx_lsb, uint16_t *byte_idx_msb) 15 | { 16 | int i = 0; 17 | uint16_t msb = 0; 18 | uint16_t lsb = 0; 19 | uint16_t current_bit_nr = 0; 20 | 21 | if (endianness == MOTOROLA) { 22 | /* 23 | * big-endian, compute lsb from msb using dbc bit numbering 24 | * definition from signal msb count down len-1 time, if bit 25 | * reachs bit_0 of current byte jump to bit_7 of next byte 26 | * (left to right bit numbering from msb to lsb) 27 | */ 28 | msb = startbit; 29 | current_bit_nr = startbit; 30 | 31 | for (i = 0; i < len - 1; i++) { 32 | if (current_bit_nr % 8 == 0) { 33 | current_bit_nr = current_bit_nr + 15; 34 | 35 | } else { 36 | current_bit_nr--; 37 | } 38 | } 39 | lsb = current_bit_nr; 40 | *byte_idx_lsb = lsb / 8; 41 | *byte_idx_msb = msb / 8; 42 | *offset_lsb = lsb % 8; 43 | 44 | } else { 45 | /* little-endian, right to left bit numbering from lsb to msb */ 46 | lsb = startbit; 47 | msb = lsb + len - 1; 48 | *byte_idx_msb = msb / 8; 49 | *byte_idx_lsb = lsb / 8; 50 | *offset_lsb = lsb % 8; 51 | } 52 | } 53 | 54 | /* 55 | * @brief copy 8 bytes data chunk containing signal to a local temp var 56 | * the endianness is taken in account 57 | * @param frame frame data address 58 | * @param byte_idx_lsb byte index of the lsb from the frame[0] 59 | * @param byte_idx_msb byte index of the msb from the frame[0] 60 | * @param endianness 61 | * @return uint64 in little endian format containing the signal to extract 62 | */ 63 | static uint64_t frame_to_local(const uint8_t *frame, uint16_t byte_idx_lsb, 64 | uint16_t byte_idx_msb, uint8_t endianness) 65 | { 66 | int i = 0; 67 | uint64_t target = 0; 68 | uint8_t *dest = NULL; 69 | target = frame[byte_idx_lsb]; 70 | dest = (uint8_t*) ⌖ 71 | 72 | /* big-endian => do a reverse copy of bytes (aka copy and swap) */ 73 | if (endianness == MOTOROLA) { 74 | for (i = byte_idx_lsb - 1; i >= byte_idx_msb; i--) { 75 | dest++; 76 | *dest = frame[i]; 77 | } 78 | 79 | } else { 80 | /* simple bytes copy little-endian -> little-endian */ 81 | for (i = byte_idx_lsb + 1; i <= byte_idx_msb; i++) { 82 | dest++; 83 | *dest = frame[i]; 84 | } 85 | } 86 | return target; 87 | } 88 | 89 | uint64_t extract(const uint8_t *frame, const uint16_t startbit, 90 | const uint8_t len, uint8_t signedness, uint8_t endianness) 91 | { 92 | uint16_t byte_idx_msb = 0; 93 | uint16_t byte_idx_lsb = 0; 94 | uint16_t offset_lsb = 0; 95 | uint64_t target = 0; 96 | uint64_t mask = 0; 97 | uint64_t sign_ext_mask = 0; 98 | 99 | compute_indexes(startbit, len, endianness, &offset_lsb, 100 | &byte_idx_lsb, &byte_idx_msb); 101 | 102 | target = frame_to_local(frame, byte_idx_lsb, byte_idx_msb, 103 | endianness); 104 | 105 | #ifdef VERBOSE_DEBUG_ 106 | printf("len: %d\n", len); 107 | printf("offset_lsb: %d\n", offset_lsb); 108 | printf("startbit: %d\n", startbit); 109 | printf("byte_idx_lsb: %d\nbyte_idx_msb: %d\n", 110 | byte_idx_lsb, byte_idx_msb); 111 | #endif 112 | 113 | /* remove lower bits not in signal (lower than offset lsb) */ 114 | target = target >> offset_lsb; 115 | 116 | /* clear higher bits not in signal (higher than msb) */ 117 | mask = ((uint64_t)1 << len) - 1; 118 | target = target & mask; 119 | 120 | /* sign extension */ 121 | if (signedness == SIGNED) { 122 | /* 123 | * we test if msb has value 1 (negative number), do sign bit 124 | * extension all bits higher than msb set to 1, so that a cast 125 | * of target to int64 will provide a correct negative value 126 | */ 127 | if (((uint64_t)1 << (len - 1)) & target) { 128 | sign_ext_mask = ~mask; 129 | target = target | sign_ext_mask; 130 | } 131 | } 132 | return target; 133 | } 134 | 135 | void insert(uint8_t *frame, uint16_t startbit, uint8_t len, 136 | uint64_t can_value, uint8_t endianness) 137 | { 138 | int i = 0; 139 | uint8_t *src = NULL; 140 | uint16_t byte_idx_msb = 0; 141 | uint16_t byte_idx_lsb = 0; 142 | uint16_t offset_lsb = 0; 143 | uint64_t target = 0; 144 | uint64_t mask = 0; 145 | uint64_t erase_mask = 0; 146 | 147 | compute_indexes(startbit, len, endianness, &offset_lsb, 148 | &byte_idx_lsb, &byte_idx_msb); 149 | 150 | target = frame_to_local(frame, byte_idx_lsb, byte_idx_msb, 151 | endianness); 152 | 153 | /* create mask to erase current signal value */ 154 | mask = ((uint64_t)1 << len) - 1; 155 | erase_mask = ~(mask << offset_lsb); 156 | 157 | /* erase and insert signal value into local data chunk */ 158 | target = (target & erase_mask) | (can_value << offset_lsb); 159 | 160 | #ifdef VERBOSE_DEBUG_ 161 | printf("len: %d\n", len); 162 | printf("offset_lsb: %d\n", offset_lsb); 163 | printf("startbit: %d\n", startbit); 164 | printf("byte_idx_lsb: %d\nbyte_idx_msb: %d\n", 165 | byte_idx_lsb, byte_idx_msb); 166 | #endif 167 | /* 168 | * copy back data chunk containing signal into CAN frame by taken into 169 | * account endianess 170 | */ 171 | src = (uint8_t*)⌖ 172 | if (endianness == MOTOROLA) { 173 | /* big-endian, reverse order copy (copy and swap) */ 174 | for (i = byte_idx_lsb; i >= byte_idx_msb; i--) { 175 | frame[i] = *src; 176 | src++; 177 | } 178 | 179 | } else { 180 | /* little-endian, simple bytes copy */ 181 | for (i = byte_idx_lsb; i <= byte_idx_msb; i++) { 182 | frame[i] = *src; 183 | src++; 184 | } 185 | } 186 | } 187 | 188 | void encode_uint64_t(uint8_t *frame, uint64_t phy_value, uint16_t startbit, 189 | uint8_t len, uint8_t endianness, 190 | double factor, double offset) 191 | { 192 | uint64_t can_value = 0; 193 | can_value = (uint64_t)((phy_value - offset) / factor); 194 | insert(frame, startbit, len, can_value, endianness); 195 | } 196 | 197 | void encode_int64_t(uint8_t *frame, int64_t phy_value, uint16_t startbit, 198 | uint8_t len, uint8_t endianness, 199 | double factor, double offset) 200 | { 201 | uint64_t can_value = 0; 202 | can_value = (int64_t)((phy_value - offset) / factor); 203 | insert(frame, startbit, len, can_value, endianness); 204 | } 205 | 206 | void encode_double(uint8_t *frame, double phy_value, uint16_t startbit, 207 | uint8_t len, uint8_t endianness, 208 | double factor, double offset) 209 | { 210 | uint64_t can_value = 0; 211 | can_value = (int64_t)((phy_value - offset) / factor); 212 | insert(frame, startbit, len, can_value, endianness); 213 | } 214 | 215 | void encode_float(uint8_t *frame, float phy_value, uint16_t startbit, 216 | uint8_t len, uint8_t endianness, 217 | double factor, double offset) 218 | { 219 | uint64_t can_value = 0; 220 | can_value = (int64_t)((phy_value - offset) / factor); 221 | insert(frame, startbit, len, can_value, endianness); 222 | } 223 | 224 | /* 225 | * @brief extract a signal and decode it into a physical value 226 | */ 227 | uint64_t decode_uint64_t(uint8_t *frame, uint16_t startbit, uint8_t len, 228 | uint8_t endianness, double factor, double offset) 229 | { 230 | uint64_t can_value = 0; 231 | can_value = extract(frame, startbit, len, UNSIGNED, endianness); 232 | return (uint64_t)((can_value * factor) + offset); 233 | } 234 | 235 | int64_t decode_int64_t(uint8_t *frame, uint16_t startbit, uint8_t len, 236 | uint8_t endianness, double factor, double offset) 237 | { 238 | int64_t can_value = 0; 239 | can_value = (int64_t)extract(frame, startbit, len, SIGNED, endianness); 240 | return (int64_t)((can_value * factor) + offset); 241 | } 242 | 243 | double decode_double(uint8_t *frame, uint16_t startbit, uint8_t len, 244 | uint8_t endianness, double factor, double offset) 245 | { 246 | int64_t can_value = 0; 247 | can_value = (int64_t)extract(frame, startbit, len, SIGNED, endianness); 248 | return (double)((can_value * factor) + offset); 249 | } 250 | 251 | float decode_float(uint8_t *frame, uint16_t startbit, uint8_t len, 252 | uint8_t endianness, double factor, double offset) 253 | { 254 | int64_t can_value = 0; 255 | can_value = (int64_t)extract(frame, startbit, len, SIGNED, endianness); 256 | return (float)((can_value * factor) + offset); 257 | } 258 | -------------------------------------------------------------------------------- /tests/Makefile: -------------------------------------------------------------------------------- 1 | SRC_DIR += src 2 | OBJ_DIR += obj 3 | BIN_DIR += bin 4 | 5 | EXE += $(BIN_DIR)/tests 6 | SRC += $(wildcard $(SRC_DIR)/*.c) 7 | 8 | OBJ += $(SRC:$(SRC_DIR)/%.c=$(OBJ_DIR)/%.o) 9 | 10 | CFLAGS += -Wall 11 | CFLAGS += -MD 12 | CFLAGS += -I../include/ 13 | 14 | LDLIBS += -L../lib/ -lwecan 15 | LDLIBS += -Wl,-rpath=../../lib 16 | 17 | 18 | .PHONY: all clean 19 | 20 | all: $(EXE) 21 | 22 | $(EXE): $(OBJ) | $(BIN_DIR) 23 | $(CXX) -o $@ $^ $(LDLIBS) 24 | 25 | $(OBJ_DIR)/%.o: $(SRC_DIR)/%.c | $(OBJ_DIR) 26 | $(CC) $(CFLAGS) -c $< -o $@ 27 | 28 | $(BIN_DIR) $(OBJ_DIR): 29 | mkdir -p $@ 30 | 31 | clean: 32 | @$(RM) -rv $(BIN_DIR) $(OBJ_DIR) 33 | 34 | -include $(OBJ:.o=.d) 35 | -------------------------------------------------------------------------------- /tests/src/tests.c: -------------------------------------------------------------------------------- 1 | #include "libwecan.h" 2 | #include 3 | #include 4 | 5 | #define PRECISION 0.00001 6 | 7 | static void display_one(uint8_t *frame, uint8_t dlc) 8 | { 9 | int i; 10 | 11 | printf("\n"); 12 | printf("encoded frame: "); 13 | for (i = 0; i < dlc; i++) { 14 | printf("%02x ", frame[i]); 15 | } 16 | printf("\n"); 17 | } 18 | 19 | static void display_two(uint8_t *expected_frame, uint8_t *frame, uint8_t dlc) 20 | { 21 | int i; 22 | 23 | printf("\n"); 24 | printf("expected frame: "); 25 | for (i = 0; i < dlc; i++) { 26 | printf("%02x ", expected_frame[i]); 27 | } 28 | printf("\n"); 29 | 30 | printf("frame: "); 31 | for (i = 0; i < dlc; i++) { 32 | printf("%02x ", frame[i]); 33 | } 34 | printf("\n"); 35 | } 36 | 37 | static int cmp_float(float f1, float f2) 38 | { 39 | if (((f1 - PRECISION) < f2) && ((f1 + PRECISION) > f2)) 40 | return TRUE; 41 | else 42 | return FALSE; 43 | } 44 | 45 | static int cmp_double(double d1, double d2) 46 | { 47 | if (((d1 - PRECISION) < d2) && ((d1 + PRECISION) > d2)) 48 | return TRUE; 49 | else 50 | return FALSE; 51 | } 52 | 53 | static int asserteq(uint8_t *expected_frame, uint8_t *frame, uint8_t dlc) 54 | { 55 | int i; 56 | 57 | for (i = 0; i < dlc; i++) { 58 | if (expected_frame[i] == frame[i]) 59 | continue; 60 | else 61 | return FALSE; 62 | } 63 | return TRUE; 64 | } 65 | 66 | int main(void) 67 | { 68 | int64_t sphy_value = 0; 69 | int64_t value_signed = 0; 70 | int64_t expected_value_signed = 0; 71 | int64_t value_one_byte_signed = 0; 72 | int64_t value_two_bytes_signed = 0; 73 | int64_t value_four_bytes_signed = 0; 74 | 75 | uint16_t startbit = 0; 76 | uint64_t uphy_value = 0; 77 | uint64_t value_unsigned = 0; 78 | uint64_t expected_value_unsigned = 0; 79 | uint64_t value_one_byte_unsigned = 0; 80 | uint64_t value_two_bytes_unsigned = 0; 81 | uint64_t value_seven_bytes_unsigned = 0; 82 | 83 | float fphy_value = 0.0; 84 | double factor = 0.0; 85 | double offset = 0.0; 86 | double dphy_value = 0.0; 87 | 88 | uint8_t len = 0; 89 | uint8_t frame[8] = {0}; 90 | uint8_t frame_fd0[40] = {0}; 91 | uint8_t frame_fd1[56] = {0}; 92 | uint8_t frame_fd2[48] = {0}; 93 | uint8_t frame_fd3[64] = {0}; 94 | uint8_t frame_fd4[24] = {0}; 95 | uint8_t expected_frame[8] = {0}; 96 | /* 97 | *********************************************************************** 98 | * EXTRACT MOTOROLA 99 | *********************************************************************** 100 | */ 101 | printf("===========================================================\n"); 102 | printf("EXTRACT MOTOROLA\n"); 103 | printf("===========================================================\n"); 104 | 105 | /* 106 | * step 1 (1 byte) 107 | * step 1.1 all signal on 1 byte, unsigned 108 | */ 109 | startbit = 7; 110 | len = 8; 111 | expected_value_unsigned = 255; 112 | frame[0] = 0xFF; 113 | value_unsigned = extract(frame, startbit, len, UNSIGNED, MOTOROLA); 114 | printf("step 1.1\n"); 115 | printf("expected_value_unsigned: %ld\n", expected_value_unsigned); 116 | printf("current_value: %ld\n", value_unsigned); 117 | assert(expected_value_unsigned == value_unsigned); 118 | 119 | /* step 1.2 all signal on 1 byte, signed */ 120 | startbit = 15; 121 | len = 8; 122 | expected_value_signed = -3; 123 | frame[1] = 0xFD; 124 | value_signed = (int64_t)extract(frame, startbit, len, SIGNED, MOTOROLA); 125 | printf("\nstep 1.2\n"); 126 | printf("expected_value_signed: %ld\n", expected_value_signed); 127 | printf("current_value: %ld\n", value_signed); 128 | assert(expected_value_signed == value_signed); 129 | 130 | /* step 1.3 (lsb middle of byte), unsigned */ 131 | startbit = 27; 132 | len = 3; 133 | expected_value_unsigned = 7; 134 | frame[3] = 0x0E; 135 | value_unsigned = extract(frame, startbit, len, UNSIGNED, MOTOROLA); 136 | printf("\nstep 1.3\n"); 137 | printf("expected_value_unsigned: %ld\n", expected_value_unsigned); 138 | printf("current_value: %ld\n", value_unsigned); 139 | assert(expected_value_unsigned == value_unsigned); 140 | 141 | /* 142 | * step x.x (lsb middle of byte), signed , signed signals always encoded on 143 | * start of byte 144 | */ 145 | 146 | /* step 1.4 (lsb start of byte), unsigned */ 147 | startbit = 21; 148 | len = 6; 149 | expected_value_unsigned = 63; 150 | frame[2] = 0x3F; 151 | value_unsigned = extract(frame, startbit, len, UNSIGNED, MOTOROLA); 152 | printf("\nstep 1.4\n"); 153 | printf("expected_value_unsigned: %ld\n", expected_value_unsigned); 154 | printf("current_value: %ld\n", value_unsigned); 155 | assert(expected_value_unsigned == value_unsigned); 156 | 157 | /* step 1.5 (lsb start of byte), signed */ 158 | startbit = 35; 159 | len = 4; 160 | expected_value_signed = -5; 161 | frame[4] = 0x0B; 162 | value_signed = (int64_t)extract(frame, startbit, len, SIGNED, MOTOROLA); 163 | printf("\nstep 1.5\n"); 164 | printf("expected_value_signed: %ld\n", expected_value_signed); 165 | printf("current_value: %ld\n", value_signed); 166 | assert(expected_value_signed == value_signed); 167 | 168 | /* step 2 (2 bytes) */ 169 | /* step 2.1 (all signal on 2 bytes), unsigned */ 170 | startbit = 55; 171 | len = 16; 172 | expected_value_unsigned = 52651; 173 | frame[6] = 0xCD; 174 | frame[7] = 0xAB; 175 | value_unsigned = extract(frame, startbit, len, UNSIGNED, MOTOROLA); 176 | printf("\nstep 2.1\n"); 177 | printf("expected_value_unsigned: %ld\n", expected_value_unsigned); 178 | printf("current_value: %ld\n", value_unsigned); 179 | assert(expected_value_unsigned == value_unsigned); 180 | 181 | /* step 2.2 (all signal on 2 bytes), signed */ 182 | startbit = 39; 183 | len = 16; 184 | expected_value_signed = -9; 185 | frame[4] = 0xFF; 186 | frame[5] = 0xF7; 187 | value_signed = (int64_t)extract(frame, startbit, len, SIGNED, MOTOROLA); 188 | printf("\nstep 2.2\n"); 189 | printf("expected_value_signed: %ld\n", expected_value_signed); 190 | printf("current_value: %ld\n", value_signed); 191 | assert(expected_value_signed == value_signed); 192 | 193 | /* step 2.3 (lsb middle of byte), unsigned */ 194 | startbit = 26; 195 | len = 9; 196 | expected_value_unsigned = 511; 197 | frame[3] = 0x07; 198 | frame[4] = 0xFC; 199 | value_unsigned = extract(frame, startbit, len, UNSIGNED, MOTOROLA); 200 | printf("\nstep 2.3\n"); 201 | printf("expected_value_unsigned: %ld\n", expected_value_unsigned); 202 | printf("current_value: %ld\n", value_unsigned); 203 | assert(expected_value_unsigned == value_unsigned); 204 | 205 | /* 206 | * step x.x (lsb middle of byte), signed , signed signals always encoded 207 | * on start of byte 208 | */ 209 | 210 | /* step 2.4 (lsb start of byte), unsigned */ 211 | startbit = 29; 212 | len = 14; 213 | expected_value_unsigned = 16383; 214 | frame[3] = 0x3F; 215 | frame[4] = 0xFF; 216 | value_unsigned = extract(frame, startbit, len, UNSIGNED, MOTOROLA); 217 | printf("\nstep 2.4\n"); 218 | printf("expected_value_unsigned: %ld\n", expected_value_unsigned); 219 | printf("current_value: %ld\n", value_unsigned); 220 | assert(expected_value_unsigned == value_unsigned); 221 | 222 | /* step 2.5 (lsb start of byte), signed */ 223 | startbit = 18; 224 | len = 11; 225 | expected_value_signed = -789; 226 | frame[2] = 0x04; 227 | frame[3] = 0xEB; 228 | value_signed = (int64_t)extract(frame, startbit, len, SIGNED, MOTOROLA); 229 | printf("\nstep 2.5\n"); 230 | printf("expected_value_signed: %ld\n", expected_value_signed); 231 | printf("current_value: %ld\n", value_signed); 232 | assert(expected_value_signed == value_signed); 233 | 234 | /* step 2.6 (signal on 7 bytes, lsb start of byte), unsigned */ 235 | startbit = 7; 236 | len = 56; 237 | expected_value_unsigned = 72057594037927935; 238 | frame[0] = 0xFF; 239 | frame[1] = 0xFF; 240 | frame[2] = 0xFF; 241 | frame[3] = 0xFF; 242 | frame[4] = 0xFF; 243 | frame[5] = 0xFF; 244 | frame[6] = 0xFF; 245 | value_unsigned = extract(frame, startbit, len, UNSIGNED, MOTOROLA); 246 | printf("\nstep 2.6\n"); 247 | printf("expected_value_unsigned: %ld\n", 248 | expected_value_unsigned); 249 | printf("current_value: %ld\n", value_unsigned); 250 | assert(expected_value_unsigned == value_unsigned); 251 | 252 | /* step 2.7 (signal on 4 bytes, lsb start of byte), signed */ 253 | startbit = 39; 254 | len = 32; 255 | expected_value_signed = -2345634; 256 | frame[4] = 0xFF; 257 | frame[5] = 0xDC; 258 | frame[6] = 0x35; 259 | frame[7] = 0x5E; 260 | value_signed = (int64_t)extract(frame, startbit, len, SIGNED, MOTOROLA); 261 | printf("\nstep 2.7\n"); 262 | printf("expected_value_signed: %ld\n", expected_value_signed); 263 | printf("current_value: %ld\n", value_signed); 264 | assert(expected_value_signed == value_signed); 265 | 266 | /* 267 | *********************************************************************** 268 | * EXTRACT INTEL 269 | *********************************************************************** 270 | */ 271 | printf("\n\n\n"); 272 | printf("===========================================================\n"); 273 | printf("EXTRACT INTEL\n"); 274 | printf("===========================================================\n"); 275 | 276 | /* step 3 (1 byte) 277 | * step 3.1 all signal on 1 byte, unsigned */ 278 | startbit = 0; 279 | len = 8; 280 | expected_value_unsigned = 255; 281 | frame[0] = 0xFF; 282 | value_unsigned = extract(frame, startbit, len, UNSIGNED, INTEL); 283 | printf("\nstep 3.1\n"); 284 | printf("expected_value_unsigned: %ld\n", 285 | expected_value_unsigned); 286 | printf("current_value: %ld\n", value_unsigned); 287 | assert(expected_value_unsigned == value_unsigned); 288 | 289 | /* step 3.2 all signal on 1 byte, signed */ 290 | startbit = 40; 291 | len = 8; 292 | expected_value_signed = -33; 293 | frame[5] = 0xDF; 294 | value_signed = (int64_t)extract(frame, startbit, len, SIGNED, INTEL); 295 | printf("\nstep 3.2\n"); 296 | printf("expected_value_signed: %ld\n", expected_value_signed); 297 | printf("current_value: %ld\n", value_signed); 298 | assert(expected_value_signed == value_signed); 299 | 300 | /* step 3.3 (lsb middle of byte), unsigned */ 301 | startbit = 17; 302 | len = 7; 303 | expected_value_unsigned = 47; 304 | frame[2] = 0x5E; 305 | value_unsigned = extract(frame, startbit, len, UNSIGNED, INTEL); 306 | printf("\nstep 3.3\n"); 307 | printf("expected_value_unsigned: %ld\n", 308 | expected_value_unsigned); 309 | printf("current_value: %ld\n", value_unsigned); 310 | assert(expected_value_unsigned == value_unsigned); 311 | 312 | /* 313 | * step x.x (lsb middle of byte), signed , signed signals always encoded 314 | * on start of byte 315 | */ 316 | 317 | /* step 3.4 (lsb start of byte), unsigned */ 318 | startbit = 48; 319 | len = 7; 320 | expected_value_unsigned = 118; 321 | frame[6] = 0x76; 322 | value_unsigned = extract(frame, startbit, len, UNSIGNED, INTEL); 323 | printf("\nstep 3.4\n"); 324 | printf("expected_value_unsigned: %ld\n", 325 | expected_value_unsigned); 326 | printf("current_value: %ld\n", value_unsigned); 327 | assert(expected_value_unsigned == value_unsigned); 328 | 329 | /* step 3.5 (lsb start of byte), signed */ 330 | startbit = 32; 331 | len = 8; 332 | expected_value_signed = -45; 333 | frame[4] = 0xD3; 334 | value_signed = (int64_t)extract(frame, startbit, len, SIGNED, INTEL); 335 | printf("\nstep 3.5\n"); 336 | printf("expected_value_signed: %ld\n", expected_value_signed); 337 | printf("current_value: %ld\n", value_signed); 338 | assert(expected_value_signed == value_signed); 339 | 340 | /* step 4 (2 bytes) */ 341 | /* step 4.1 (all signal on 2 bytes), unsigned */ 342 | startbit = 24; 343 | len = 16; 344 | expected_value_unsigned = 53754; 345 | frame[3] = 0xFA; 346 | frame[4] = 0xD1; 347 | value_unsigned = extract(frame, startbit, len, UNSIGNED, INTEL); 348 | printf("\nstep 4.1\n"); 349 | printf("expected_value_unsigned: %ld\n", 350 | expected_value_unsigned); 351 | printf("current_value: %ld\n", value_unsigned); 352 | assert(expected_value_unsigned == value_unsigned); 353 | 354 | /* step 4.2 (all signal on 2 bytes), signed */ 355 | startbit = 48; 356 | len = 16; 357 | expected_value_signed = -999; 358 | frame[6] = 0x19; 359 | frame[7] = 0xFC; 360 | value_signed = (int64_t)extract(frame, startbit, len, SIGNED, INTEL); 361 | printf("\nstep 4.2\n"); 362 | printf("expected_value_signed: %ld\n", expected_value_signed); 363 | printf("current_value: %ld\n", value_signed); 364 | assert(expected_value_signed == value_signed); 365 | 366 | /* step 4.3 (lsb middle of byte), unsigned */ 367 | startbit = 2; 368 | len = 12; 369 | expected_value_unsigned = 3387; 370 | frame[0] = 0xEC; 371 | frame[1] = 0x34; 372 | value_unsigned = extract(frame, startbit, len, UNSIGNED, INTEL); 373 | printf("\nstep 4.3\n"); 374 | printf("expected_value_unsigned: %ld\n", 375 | expected_value_unsigned); 376 | printf("current_value: %ld\n", value_unsigned); 377 | assert(expected_value_unsigned == value_unsigned); 378 | 379 | /* 380 | * step x.x (lsb middle of byte), signed , signed signals always encoded 381 | * on start of byte 382 | */ 383 | 384 | /* step 4.4 (lsb start of byte), unsigned */ 385 | startbit = 16; 386 | len = 11; 387 | expected_value_unsigned = 885; 388 | frame[2] = 0x75; 389 | frame[3] = 0x03; 390 | value_unsigned = extract(frame, startbit, len, UNSIGNED, INTEL); 391 | printf("\nstep 4.4\n"); 392 | printf("expected_value_unsigned: %ld\n", 393 | expected_value_unsigned); 394 | printf("current_value: %ld\n", value_unsigned); 395 | assert(expected_value_unsigned == value_unsigned); 396 | 397 | /* step 4.5 (lsb start of byte), signed */ 398 | startbit = 40; 399 | len = 16; 400 | expected_value_signed = -6666; 401 | frame[5] = 0xF6; 402 | frame[6] = 0xE5; 403 | value_signed = (int64_t)extract(frame, startbit, len, SIGNED, INTEL); 404 | printf("\nstep 4.5\n"); 405 | printf("expected_value_signed: %ld\n", expected_value_signed); 406 | printf("current_value: %ld\n", value_signed); 407 | assert(expected_value_signed == value_signed); 408 | 409 | /* step 4.6 (signal on 7 bytes, lsb start of byte), unsigned */ 410 | startbit = 0; 411 | len = 56; 412 | expected_value_unsigned = 48413335211474859; 413 | frame[0] = 0xAB; 414 | frame[1] = 0xFF; 415 | frame[2] = 0xAB; 416 | frame[3] = 0xFF; 417 | frame[4] = 0xAB; 418 | frame[5] = 0xFF; 419 | frame[6] = 0xAB; 420 | value_unsigned = extract(frame, startbit, len, UNSIGNED, INTEL); 421 | printf("\nstep 4.6\n"); 422 | printf("expected_value_unsigned: %ld\n", 423 | expected_value_unsigned); 424 | printf("current_value: %ld\n", value_unsigned); 425 | assert(expected_value_unsigned == value_unsigned); 426 | 427 | /* step 4.7 (signal on 4 bytes, lsb start of byte), signed */ 428 | startbit = 0; 429 | len = 32; 430 | expected_value_signed = -1666666; 431 | frame[0] = 0x96; 432 | frame[1] = 0x91; 433 | frame[2] = 0xE6; 434 | frame[3] = 0xFF; 435 | value_signed = (int64_t)extract(frame, startbit, len, SIGNED, INTEL); 436 | printf("\nstep 4.7\n"); 437 | printf("expected_value_signed: %ld\n", expected_value_signed); 438 | printf("current_value: %ld\n", value_signed); 439 | assert(expected_value_signed == value_signed); 440 | 441 | /* 442 | *********************************************************************** 443 | * INSERT MOTOROLA 444 | *********************************************************************** 445 | */ 446 | printf("\n\n\n"); 447 | printf("===========================================================\n"); 448 | printf("INSERT MOTOROLA\n"); 449 | printf("===========================================================\n"); 450 | 451 | /* step 5 (1 byte) 452 | * step 5.1 all signal on 1 byte, unsigned */ 453 | memset(frame, 0, 8); 454 | memset(expected_frame, 0, 8); 455 | value_one_byte_unsigned = 6; 456 | startbit = 31; 457 | len = 8; 458 | expected_frame[3] = 0x06; 459 | insert(frame, startbit, len, value_one_byte_unsigned, MOTOROLA); 460 | printf("\nstep 5.1"); 461 | display_two(expected_frame, frame, 8); 462 | assert(asserteq(expected_frame, frame, 8)); 463 | 464 | /* step 5.2 all signal on 1 byte, signed */ 465 | memset(frame, 0, 8); 466 | memset(expected_frame, 0, 8); 467 | value_one_byte_signed = -15; 468 | startbit = 31; 469 | len = 8; 470 | expected_frame[3] = 0xF1; 471 | insert(frame, startbit, len, value_one_byte_signed, MOTOROLA); 472 | printf("\nstep 5.2"); 473 | display_two(expected_frame, frame, 8); 474 | assert(asserteq(expected_frame, frame, 8)); 475 | 476 | /* step 5.3 (lsb middle of byte), unsigned */ 477 | memset(frame, 0, 8); 478 | memset(expected_frame, 0, 8); 479 | value_one_byte_unsigned = 63; 480 | startbit = 7; 481 | len = 6; 482 | expected_frame[0] = 0xFC; 483 | insert(frame, startbit, len, value_one_byte_unsigned, MOTOROLA); 484 | printf("\nstep 5.3"); 485 | display_two(expected_frame, frame, 8); 486 | assert(asserteq(expected_frame, frame, 8)); 487 | 488 | /* 489 | * step x.x (lsb middle of byte), signed , signed signals always encoded 490 | * on start of byte 491 | */ 492 | 493 | /* step 5.4 (lsb start of byte), unsigned */ 494 | memset(frame, 0, 8); 495 | memset(expected_frame, 0, 8); 496 | value_one_byte_unsigned = 113; 497 | startbit = 47; 498 | len = 8; 499 | expected_frame[5] = 0x71; 500 | insert(frame, startbit, len, value_one_byte_unsigned, MOTOROLA); 501 | printf("\nstep 5.4"); 502 | display_two(expected_frame, frame, 8); 503 | assert(asserteq(expected_frame, frame, 8)); 504 | 505 | /* step 5.5 (lsb start of byte), signed */ 506 | memset(frame, 0, 8); 507 | memset(expected_frame, 0, 8); 508 | value_one_byte_signed = -113; 509 | startbit = 23; 510 | len = 8; 511 | expected_frame[2] = 0x8F; 512 | insert(frame, startbit, len, value_one_byte_signed, MOTOROLA); 513 | printf("\nstep 5.5"); 514 | display_two(expected_frame, frame, 8); 515 | assert(asserteq(expected_frame, frame, 8)); 516 | 517 | /* step 6 (2 bytes) */ 518 | /* step 6.1 (all signal on 2 bytes), unsigned */ 519 | memset(frame, 0, 8); 520 | memset(expected_frame, 0, 8); 521 | value_two_bytes_unsigned = 30126; 522 | startbit = 55; 523 | len = 16; 524 | expected_frame[6] = 0x75; 525 | expected_frame[7] = 0xAE; 526 | insert(frame, startbit, len, value_two_bytes_unsigned, MOTOROLA); 527 | printf("\nstep 6.1"); 528 | display_two(expected_frame, frame, 8); 529 | assert(asserteq(expected_frame, frame, 8)); 530 | 531 | /* step 6.2 (all signal on 2 bytes), signed */ 532 | memset(frame, 0, 8); 533 | memset(expected_frame, 0, 8); 534 | value_two_bytes_signed = -59595; 535 | startbit = 39; 536 | len = 16; 537 | expected_frame[4] = 0x17; 538 | expected_frame[5] = 0x35; 539 | insert(frame, startbit, len, value_two_bytes_signed, MOTOROLA); 540 | printf("\nstep 6.2"); 541 | display_two(expected_frame, frame, 8); 542 | assert(asserteq(expected_frame, frame, 8)); 543 | 544 | /* step 6.3 (lsb middle of byte), unsigned */ 545 | memset(frame, 0, 8); 546 | memset(expected_frame, 0, 8); 547 | value_two_bytes_unsigned = 189; 548 | startbit = 21; 549 | len = 9; 550 | expected_frame[2] = 0x17; 551 | expected_frame[3] = 0xA0; 552 | insert(frame, startbit, len, value_two_bytes_unsigned, MOTOROLA); 553 | printf("\nstep 6.3"); 554 | display_two(expected_frame, frame, 8); 555 | assert(asserteq(expected_frame, frame, 8)); 556 | 557 | /* 558 | * step x.x (lsb middle of byte), signed , signed signals always encoded 559 | * on start of byte 560 | */ 561 | 562 | /* step 6.4 (lsb start of byte), unsigned */ 563 | memset(frame, 0, 8); 564 | memset(expected_frame, 0, 8); 565 | value_two_bytes_unsigned = 1390; 566 | startbit = 34; 567 | len = 11; 568 | expected_frame[4] = 0x05; 569 | expected_frame[5] = 0x6E; 570 | insert(frame, startbit, len, value_two_bytes_unsigned, MOTOROLA); 571 | printf("\nstep 6.4"); 572 | display_two(expected_frame, frame, 8); 573 | assert(asserteq(expected_frame, frame, 8)); 574 | 575 | /* step 6.5 (lsb start of byte), signed */ 576 | memset(frame, 0, 8); 577 | memset(expected_frame, 0, 8); 578 | value_two_bytes_signed = -24244; 579 | startbit = 7; 580 | len = 16; 581 | expected_frame[0] = 0xA1; 582 | expected_frame[1] = 0x4C; 583 | insert(frame, startbit, len, value_two_bytes_signed, MOTOROLA); 584 | printf("\nstep 6.5"); 585 | display_two(expected_frame, frame, 8); 586 | assert(asserteq(expected_frame, frame, 8)); 587 | 588 | /* step 6.6 (signal on 7 bytes, lsb start of byte), unsigned */ 589 | memset(frame, 0, 8); 590 | memset(expected_frame, 0, 8); 591 | value_seven_bytes_unsigned = 48413335211474859; 592 | startbit = 7; 593 | len = 56; 594 | expected_frame[0] = 0xAB; 595 | expected_frame[1] = 0xFF; 596 | expected_frame[2] = 0xAB; 597 | expected_frame[3] = 0xFF; 598 | expected_frame[4] = 0xAB; 599 | expected_frame[5] = 0xFF; 600 | expected_frame[6] = 0xAB; 601 | insert(frame, startbit, len, value_seven_bytes_unsigned, MOTOROLA); 602 | printf("\nstep 6.6"); 603 | display_two(expected_frame, frame, 8); 604 | assert(asserteq(expected_frame, frame, 8)); 605 | 606 | /* step 6.7 (signal on 4 bytes, lsb start of byte), signed */ 607 | memset(frame, 0, 8); 608 | memset(expected_frame, 0, 8); 609 | value_four_bytes_signed = -489; 610 | startbit = 39; 611 | len = 32; 612 | expected_frame[4] = 0xFF; 613 | expected_frame[5] = 0xFF; 614 | expected_frame[6] = 0xFE; 615 | expected_frame[7] = 0x17; 616 | insert(frame, startbit, len, value_four_bytes_signed, MOTOROLA); 617 | printf("\nstep 6.7"); 618 | display_two(expected_frame, frame, 8); 619 | assert(asserteq(expected_frame, frame, 8)); 620 | 621 | /* 622 | *********************************************************************** 623 | * INSERT INTEL 624 | *********************************************************************** 625 | */ 626 | printf("\n\n\n"); 627 | printf("===========================================================\n"); 628 | printf("INSERT INTEL\n"); 629 | printf("===========================================================\n"); 630 | 631 | /* step 7 (1 byte) 632 | * step 7.1 all signal on 1 byte, unsigned */ 633 | memset(frame, 0, 8); 634 | memset(expected_frame, 0, 8); 635 | value_one_byte_unsigned = 240; 636 | startbit = 16; 637 | len = 8; 638 | expected_frame[2] = 0xF0; 639 | insert(frame, startbit, len, value_one_byte_unsigned, INTEL); 640 | printf("\nstep 7.1"); 641 | display_two(expected_frame, frame, 8); 642 | assert(asserteq(expected_frame, frame, 8)); 643 | 644 | /* step 7.2 all signal on 1 byte, signed */ 645 | memset(frame, 0, 8); 646 | memset(expected_frame, 0, 8); 647 | value_one_byte_signed = -202; 648 | startbit = 32; 649 | len = 8; 650 | expected_frame[4] = 0x36; 651 | insert(frame, startbit, len, value_one_byte_signed, INTEL); 652 | printf("\nstep 7.2"); 653 | display_two(expected_frame, frame, 8); 654 | assert(asserteq(expected_frame, frame, 8)); 655 | 656 | /* step 7.3 (lsb middle of byte), unsigned */ 657 | memset(frame, 0, 8); 658 | memset(expected_frame, 0, 8); 659 | value_one_byte_unsigned = 7; 660 | startbit = 29; 661 | len = 3; 662 | expected_frame[3] = 0xE0; 663 | insert(frame, startbit, len, value_one_byte_unsigned, INTEL); 664 | printf("\nstep 7.3"); 665 | display_two(expected_frame, frame, 8); 666 | assert(asserteq(expected_frame, frame, 8)); 667 | 668 | /* 669 | * step x.x (lsb middle of byte), signed , signed signals always encoded 670 | * on start of byte 671 | */ 672 | 673 | /* step 7.4 (lsb start of byte), unsigned */ 674 | memset(frame, 0, 8); 675 | memset(expected_frame, 0, 8); 676 | value_one_byte_unsigned = 23; 677 | startbit = 56; 678 | len = 5; 679 | expected_frame[7] = 0x17; 680 | insert(frame, startbit, len, value_one_byte_unsigned, INTEL); 681 | printf("\nstep 7.4"); 682 | display_two(expected_frame, frame, 8); 683 | assert(asserteq(expected_frame, frame, 8)); 684 | 685 | /* step 7.5 (lsb start of byte), signed */ 686 | memset(frame, 0, 8); 687 | memset(expected_frame, 0, 8); 688 | value_one_byte_signed = -199; 689 | startbit = 40; 690 | len = 8; 691 | expected_frame[5] = 0x39; 692 | insert(frame, startbit, len, value_one_byte_signed, INTEL); 693 | printf("\nstep 7.5"); 694 | display_two(expected_frame, frame, 8); 695 | assert(asserteq(expected_frame, frame, 8)); 696 | 697 | /* step 8 (2 bytes) */ 698 | /* step 8.1 (all signal on 2 bytes), unsigned */ 699 | memset(frame, 0, 8); 700 | memset(expected_frame, 0, 8); 701 | value_two_bytes_unsigned = 52077; 702 | startbit = 16; 703 | len = 16; 704 | expected_frame[2] = 0x6D; 705 | expected_frame[3] = 0xCB; 706 | insert(frame, startbit, len, value_two_bytes_unsigned, INTEL); 707 | printf("\nstep 8.1"); 708 | display_two(expected_frame, frame, 8); 709 | assert(asserteq(expected_frame, frame, 8)); 710 | 711 | /* step 8.2 (all signal on 2 bytes), signed */ 712 | memset(frame, 0, 8); 713 | memset(expected_frame, 0, 8); 714 | value_two_bytes_signed = -48666; 715 | startbit = 32; 716 | len = 16; 717 | expected_frame[4] = 0xE6; 718 | expected_frame[5] = 0x41; 719 | insert(frame, startbit, len, value_two_bytes_signed, INTEL); 720 | printf("\nstep 8.2"); 721 | display_two(expected_frame, frame, 8); 722 | assert(asserteq(expected_frame, frame, 8)); 723 | 724 | /* step 8.3 (lsb middle of byte), unsigned */ 725 | memset(frame, 0, 8); 726 | memset(expected_frame, 0, 8); 727 | value_two_bytes_unsigned = 1707; 728 | startbit = 44; 729 | len = 11; 730 | expected_frame[5] = 0xB0; 731 | expected_frame[6] = 0x6A; 732 | insert(frame, startbit, len, value_two_bytes_unsigned, INTEL); 733 | printf("\nstep 8.3"); 734 | display_two(expected_frame, frame, 8); 735 | assert(asserteq(expected_frame, frame, 8)); 736 | 737 | /* 738 | * step x.x (lsb middle of byte), signed , signed signals always encoded 739 | * on start of byte 740 | */ 741 | 742 | /* step 8.4 (lsb start of byte), unsigned */ 743 | memset(frame, 0, 8); 744 | memset(expected_frame, 0, 8); 745 | value_two_bytes_unsigned = 1023; 746 | startbit = 8; 747 | len = 10; 748 | expected_frame[1] = 0xFF; 749 | expected_frame[2] = 0x03; 750 | insert(frame, startbit, len, value_two_bytes_unsigned, INTEL); 751 | printf("\nstep 8.4"); 752 | display_two(expected_frame, frame, 8); 753 | assert(asserteq(expected_frame, frame, 8)); 754 | 755 | /* step 8.5 (lsb start of byte), signed */ 756 | memset(frame, 0, 8); 757 | memset(expected_frame, 0, 8); 758 | value_two_bytes_signed = -59821; 759 | startbit = 48; 760 | len = 16; 761 | expected_frame[6] = 0x53; 762 | expected_frame[7] = 0x16; 763 | insert(frame, startbit, len, value_two_bytes_signed, INTEL); 764 | printf("\nstep 8.5"); 765 | display_two(expected_frame, frame, 8); 766 | assert(asserteq(expected_frame, frame, 8)); 767 | 768 | /* step 8.6 (signal on 7 bytes, lsb start of byte), unsigned */ 769 | memset(frame, 0, 8); 770 | memset(expected_frame, 0, 8); 771 | value_seven_bytes_unsigned = 48413335211474859; 772 | startbit = 0; 773 | len = 56; 774 | expected_frame[0] = 0xAB; 775 | expected_frame[1] = 0xFF; 776 | expected_frame[2] = 0xAB; 777 | expected_frame[3] = 0xFF; 778 | expected_frame[4] = 0xAB; 779 | expected_frame[5] = 0xFF; 780 | expected_frame[6] = 0xAB; 781 | insert(frame, startbit, len, value_seven_bytes_unsigned, INTEL); 782 | printf("\nstep 8.6"); 783 | display_two(expected_frame, frame, 8); 784 | assert(asserteq(expected_frame, frame, 8)); 785 | 786 | /* step 8.7 (signal on 4 bytes, lsb start of byte), signed */ 787 | memset(frame, 0, 8); 788 | memset(expected_frame, 0, 8); 789 | value_four_bytes_signed = -1339; 790 | startbit = 7; 791 | len = 32; 792 | expected_frame[0] = 0xFF; 793 | expected_frame[1] = 0xFF; 794 | expected_frame[2] = 0xFA; 795 | expected_frame[3] = 0xC5; 796 | insert(frame, startbit, len, value_four_bytes_signed, MOTOROLA); 797 | printf("\nstep 8.7"); 798 | display_two(expected_frame, frame, 8); 799 | assert(asserteq(expected_frame, frame, 8)); 800 | 801 | /* 802 | *********************************************************************** 803 | * ENCODE DECODE MOTOROLA double value 804 | *********************************************************************** 805 | */ 806 | printf("\n\n\n"); 807 | printf("===========================================================\n"); 808 | printf("ENCODE DECODE MOTOROLA double value\n"); 809 | printf("===========================================================\n"); 810 | 811 | memset(frame, 0, 8); 812 | dphy_value = 66.66666; 813 | startbit = 7; 814 | len = 32; 815 | factor = 0.0000001; 816 | offset = 0; 817 | printf("\nstep 9.1\n\n"); 818 | printf("value to be encoded: %.5lf\n", dphy_value); 819 | encode_double(frame, dphy_value, startbit, len, MOTOROLA, 820 | factor, offset); 821 | display_one(frame, 8); 822 | printf("\ndecoded value: %.5lf\n", 823 | decode_double(frame, startbit, len, MOTOROLA, 824 | factor, offset)); 825 | assert(cmp_double(decode_double(frame, startbit, len, MOTOROLA, 826 | factor, offset), dphy_value)); 827 | 828 | /* 829 | *********************************************************************** 830 | * ENCODE DECODE MOTOROLA double float negative value 831 | *********************************************************************** 832 | */ 833 | printf("\n\n\n"); 834 | printf("===========================================================\n"); 835 | printf("ENCODE DECODE MOTOROLA double negative value\n"); 836 | printf("===========================================================\n"); 837 | 838 | memset(frame, 0, 8); 839 | dphy_value = -50.6164129; 840 | startbit = 7; 841 | len = 32; 842 | factor = 0.0000001; 843 | offset = 0; 844 | printf("\nstep 9.2\n\n"); 845 | printf("value to be encoded: %.7lf\n", dphy_value); 846 | encode_double(frame, dphy_value, startbit, len, MOTOROLA, 847 | factor, offset); 848 | display_one(frame, 8); 849 | printf("\ndecoded value: %.7lf\n", 850 | decode_double(frame, startbit, len, MOTOROLA, 851 | factor, offset)); 852 | assert(cmp_double(decode_double(frame, startbit, len, MOTOROLA, 853 | factor, offset), dphy_value)); 854 | 855 | /* 856 | *********************************************************************** 857 | * ENCODE DECODE MOTOROLA unsigned int value 858 | *********************************************************************** 859 | */ 860 | printf("\n\n\n"); 861 | printf("===========================================================\n"); 862 | printf("ENCODE DECODE MOTOROLA unsigned int value\n"); 863 | printf("===========================================================\n"); 864 | 865 | memset(frame, 0, 8); 866 | uphy_value = 666666666; 867 | startbit = 7; 868 | len = 32; 869 | factor = 1; 870 | offset = 0; 871 | printf("\nstep 9.3\n\n"); 872 | printf("value to be encoded: %ld\n", uphy_value); 873 | encode_uint64_t(frame, uphy_value, startbit, len, MOTOROLA, 874 | factor, offset); 875 | display_one(frame, 8); 876 | printf("\ndecoded value: %ld\n", 877 | decode_uint64_t(frame, startbit, len, MOTOROLA, 878 | factor, offset)); 879 | assert(uphy_value == decode_uint64_t(frame, startbit, len, MOTOROLA, 880 | factor, offset)); 881 | 882 | /* 883 | *********************************************************************** 884 | * ENCODE DECODE INTEL double value 885 | *********************************************************************** 886 | */ 887 | printf("\n\n\n"); 888 | printf("===========================================================\n"); 889 | printf("ENCODE DECODE INTEL double value\n"); 890 | printf("===========================================================\n"); 891 | 892 | memset(frame, 0, 8); 893 | dphy_value = 8.4939123; 894 | startbit = 0; 895 | len = 32; 896 | factor = 0.0000001; 897 | offset = 0; 898 | printf("\nstep 9.4\n\n"); 899 | printf("value to be encoded: %.7lf\n", dphy_value); 900 | encode_double(frame, dphy_value, startbit, len, INTEL, factor, offset); 901 | display_one(frame, 8); 902 | printf("\ndecoded value: %.7lf\n", 903 | decode_double(frame, startbit, len, INTEL, 904 | factor, offset)); 905 | assert(cmp_double(decode_double(frame, startbit, len, INTEL, 906 | factor, offset), dphy_value)); 907 | 908 | /* 909 | *********************************************************************** 910 | * ENCODE DECODE INTEL double negative value 911 | *********************************************************************** 912 | */ 913 | printf("\n\n\n"); 914 | printf("===========================================================\n"); 915 | printf("ENCODE DECODE INTEL double negative value\n"); 916 | printf("===========================================================\n"); 917 | 918 | memset(frame, 0, 8); 919 | dphy_value = -7.7979897; 920 | startbit = 0; 921 | len = 32; 922 | factor = 0.0000001; 923 | offset = 0; 924 | printf("\nstep 9.5\n\n"); 925 | printf("value to be encoded: %.7lf\n", dphy_value); 926 | encode_double(frame, dphy_value, startbit, len, INTEL, factor, offset); 927 | display_one(frame, 8); 928 | printf("\ndecoded value: %.7lf\n", 929 | decode_double(frame, startbit, len, INTEL, 930 | factor, offset)); 931 | assert(cmp_double(decode_double(frame, startbit, len, INTEL, 932 | factor, offset), dphy_value)); 933 | 934 | /* 935 | *********************************************************************** 936 | * ENCODE DECODE INTEL unsigned int value 937 | *********************************************************************** 938 | */ 939 | printf("\n\n\n"); 940 | printf("===========================================================\n"); 941 | printf("ENCODE DECODE INTEL unsigned int value\n"); 942 | printf("===========================================================\n"); 943 | 944 | memset(frame, 0, 8); 945 | uphy_value = 999999999; 946 | startbit = 0; 947 | len = 32; 948 | factor = 1; 949 | offset = 0; 950 | printf("\nstep 9.6\n\n"); 951 | printf("value to be encoded: %ld\n", uphy_value); 952 | encode_uint64_t(frame, uphy_value, startbit, len, INTEL, 953 | factor, offset); 954 | display_one(frame, 8); 955 | printf("\ndecoded value: %ld\n", 956 | decode_uint64_t(frame, startbit, len, INTEL, 957 | factor, offset)); 958 | assert(uphy_value == decode_uint64_t(frame, startbit, len, INTEL, 959 | factor, offset)); 960 | 961 | /* 962 | *********************************************************************** 963 | * ENCODE DECODE INTEL signed int negative value 964 | *********************************************************************** 965 | */ 966 | printf("\n\n\n"); 967 | printf("===========================================================\n"); 968 | printf("ENCODE DECODE INTEL signed int negative value\n"); 969 | printf("===========================================================\n"); 970 | 971 | memset(frame, 0, 8); 972 | sphy_value = -1029384756; 973 | startbit = 0; 974 | len = 32; 975 | factor = 1; 976 | offset = 0; 977 | printf("\nstep 9.7\n\n"); 978 | printf("value to be encoded: %ld\n", sphy_value); 979 | encode_int64_t(frame, sphy_value, startbit, len, INTEL, factor, offset); 980 | display_one(frame, 8); 981 | printf("\ndecoded value: %ld\n", 982 | decode_int64_t(frame, startbit, len, INTEL, 983 | factor, offset)); 984 | assert(sphy_value == decode_int64_t(frame, startbit, len, INTEL, 985 | factor, offset)); 986 | 987 | /* 988 | *********************************************************************** 989 | * ENCODE DECODE MOTOROLA float negative value 990 | *********************************************************************** 991 | */ 992 | printf("\n\n\n"); 993 | printf("===========================================================\n"); 994 | printf("ENCODE DECODE MOTOROLA float negative value\n"); 995 | printf("===========================================================\n"); 996 | 997 | memset(frame, 0, 8); 998 | fphy_value = -2938.345666; 999 | startbit = 7; 1000 | len = 40; 1001 | factor = 0.0000001; 1002 | offset = 0; 1003 | printf("\nstep 9.8\n\n"); 1004 | printf("value to be encoded: %.6f\n", fphy_value); 1005 | encode_float(frame, fphy_value, startbit, len, MOTOROLA, 1006 | factor, offset); 1007 | display_one(frame, 8); 1008 | printf("\ndecoded value: %.6f\n", 1009 | decode_float(frame, startbit, len, MOTOROLA, 1010 | factor, offset)); 1011 | assert(cmp_float(decode_float(frame, startbit, len, MOTOROLA, 1012 | factor, offset), fphy_value)); 1013 | 1014 | /* 1015 | *********************************************************************** 1016 | * ENCODE DECODE INTEL unsigned int value FDFRAME 1017 | *********************************************************************** 1018 | */ 1019 | printf("\n\n\n"); 1020 | printf("===========================================================\n"); 1021 | printf("ENCODE DECODE INTEL unsigned int value FDFRAME\n"); 1022 | printf("===========================================================\n"); 1023 | 1024 | memset(frame_fd0, 0, 40); /* 40 bytes fdframe */ 1025 | uphy_value = 999999999; 1026 | startbit = 288; /* start of byte */ 1027 | len = 32; 1028 | factor = 1; 1029 | offset = 0; 1030 | printf("\nstep 9.9\n\n"); 1031 | printf("value to be encoded: %ld\n", uphy_value); 1032 | encode_uint64_t(frame_fd0, uphy_value, startbit, len, INTEL, 1033 | factor, offset); 1034 | display_one(frame_fd0, 40); 1035 | printf("\ndecoded value: %ld\n", 1036 | decode_uint64_t(frame_fd0, startbit, len, INTEL, 1037 | factor, offset)); 1038 | assert(uphy_value == decode_uint64_t(frame_fd0, startbit, len, INTEL, 1039 | factor, offset)); 1040 | 1041 | /* 1042 | *********************************************************************** 1043 | * ENCODE DECODE MOTOROLA signed int value FDFRAME 1044 | *********************************************************************** 1045 | */ 1046 | printf("\n\n\n"); 1047 | printf("===========================================================\n"); 1048 | printf("ENCODE DECODE MOTOROLA signed int value FDFRAME\n"); 1049 | printf("===========================================================\n"); 1050 | 1051 | memset(frame_fd1, 0, 56); /* 56 bytes fdframe */ 1052 | sphy_value = -7777; 1053 | startbit = 431; /* start of byte */ 1054 | len = 16; 1055 | factor = 1; 1056 | offset = 0; 1057 | printf("\nstep 10.0\n\n"); 1058 | printf("value to be encoded: %ld\n", sphy_value); 1059 | encode_int64_t(frame_fd1, sphy_value, startbit, len, MOTOROLA, 1060 | factor, offset); 1061 | display_one(frame_fd1, 56); 1062 | printf("\ndecoded value: %ld\n", 1063 | decode_int64_t(frame_fd1, startbit, len, MOTOROLA, 1064 | factor, offset)); 1065 | assert(sphy_value == decode_int64_t(frame_fd1, startbit, len, MOTOROLA, 1066 | factor, offset)); 1067 | 1068 | /* 1069 | *********************************************************************** 1070 | * ENCODE DECODE INTEL signed negative int value FDFRAME 1071 | *********************************************************************** 1072 | */ 1073 | printf("\n\n\n"); 1074 | printf("===========================================================\n"); 1075 | printf("ENCODE DECODE INTEL signed negative int value FDFRAME\n"); 1076 | printf("===========================================================\n"); 1077 | 1078 | memset(frame_fd2, 0, 48); /* 48 bytes fdframe */ 1079 | sphy_value = -1029384756; 1080 | startbit = 184; /* start of byte */ 1081 | len = 32; 1082 | factor = 1; 1083 | offset = 0; 1084 | printf("\nstep 10.1\n\n"); 1085 | printf("value to be encoded: %ld\n", sphy_value); 1086 | encode_int64_t(frame_fd2, sphy_value, startbit, len, INTEL, 1087 | factor, offset); 1088 | display_one(frame_fd2, 48); 1089 | printf("\ndecoded value: %ld\n", 1090 | decode_int64_t(frame_fd2, startbit, len, INTEL, 1091 | factor, offset)); 1092 | assert(sphy_value == decode_int64_t(frame_fd2, startbit, len, INTEL, 1093 | factor, offset)); 1094 | 1095 | /* 1096 | *********************************************************************** 1097 | * ENCODE DECODE MOTOROLA float value FDFRAME 1098 | ************************************************************************ 1099 | */ 1100 | printf("\n\n\n"); 1101 | printf("===========================================================\n"); 1102 | printf("ENCODE DECODE MOTOROLA float value FDFRAME\n"); 1103 | printf("===========================================================\n"); 1104 | 1105 | memset(frame_fd3, 0, 64); /* 64 bytes fdframe */ 1106 | fphy_value = 8.49391; 1107 | startbit = 383; /* start of byte */ 1108 | len = 32; 1109 | factor = 0.0000001; 1110 | offset = 0; 1111 | printf("\nstep 10.2\n\n"); 1112 | printf("value to be encoded: %f\n", fphy_value); 1113 | encode_float(frame_fd3, fphy_value, startbit, len, MOTOROLA, 1114 | factor, offset); 1115 | display_one(frame_fd3, 64); 1116 | printf("\ndecoded value: %f\n", 1117 | decode_float(frame_fd3, startbit, len, MOTOROLA, 1118 | factor, offset)); 1119 | assert(cmp_float(decode_float(frame_fd3, startbit, len, MOTOROLA, 1120 | factor, offset), fphy_value)); 1121 | 1122 | /* 1123 | *********************************************************************** 1124 | * ENCODE DECODE INTEL double negative value FDFRAME 1125 | *********************************************************************** 1126 | */ 1127 | printf("\n\n\n"); 1128 | printf("===========================================================\n"); 1129 | printf("ENCODE DECODE INTEL double negative value FDFRAME\n"); 1130 | printf("===========================================================\n"); 1131 | 1132 | memset(frame_fd4, 0, 24); /* 24 bytes fdframe */ 1133 | dphy_value = -7.7979897; 1134 | startbit = 32; /* start of byte */ 1135 | len = 32; 1136 | factor = 0.0000001; 1137 | offset = 0; 1138 | printf("\nstep 10.3\n\n"); 1139 | printf("value to be encoded: %.7lf\n", dphy_value); 1140 | encode_double(frame_fd4, dphy_value, startbit, len, INTEL, 1141 | factor, offset); 1142 | display_one(frame_fd4, 24); 1143 | printf("\ndecoded value: %.7lf\n", 1144 | decode_double(frame_fd4, startbit, len, INTEL, 1145 | factor, offset)); 1146 | assert(cmp_double(decode_double(frame_fd4, startbit, len, INTEL, 1147 | factor, offset), dphy_value)); 1148 | 1149 | return 0; 1150 | } 1151 | --------------------------------------------------------------------------------