1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
#ifndef __8BYTE_H__
#define __8BYTE_H__
#include <stdint.h>
#include <stdbool.h>
#ifdef __cplusplus
extern "C" {
#endif
// TODO using uint64_t everywhere for CAN message payload is kind of cute, but
// in actuality a CAN message may have a smaller payload, and it makes all of
// these functions not applicable to other data sizes. It's also fairly
// inefficient on 32-bit platforms. how much work is it to switch vi-firmware
// to using uint8_t*?
/* Public: Reads a subset of bits into a uint64_t.
*
* source - the bytes in question.
* offset - the starting index of the bit field (beginning from 0).
* bit_count - the width of the bit field to extract.
* big_endian - if the data passed in is little endian, set this to false and it
* will be flipped before grabbing the bit field.
*
* Bit fields are positioned according to big-endian bit layout, but inside the
* bit field, values are represented as little-endian. Therefore, to get the bit
* field, we swap the overall byte order if big_endian == false and
* use the value we find in the field (assuming the embedded platform is little
* endian).
*
* For example, the bit layout of the value "42" (i.e. 00101010 set at position
* 14 with length 6 is:
*
* 000000000000001010100000000000000000000000000000000000000000000
*
* and the same value and position but with length 8 is:
*
* 000000000000000010101000000000000000000000000000000000000000000
*
* If the architecture where is code is running is little-endian, the input data
* will be swapped before grabbing the bit field.
*
* Examples
*
* uint64_t value = get_bit_field(data, 2, 4);
*
* 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,
const uint16_t bit_count, const bool big_endian);
/* Public: Return a single nibble from the payload, with range checking.
*
* source - the source payload.
* nibble_index - the index of the nibble to retreive. The leftmost nibble is
* index 0.
* big_endian - if the data passed in is little endian, set this to false and it
* will be flipped before grabbing the bit field.
*
* 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 big_endian);
/* Public: Return a single byte from the payload, with range checking.
*
* source - the source byte array.
* byte_index - the index of the byte to retreive. The leftmost byte is index 0.
* big_endian - if the data passed in is little endian, set this to false and it
* will be flipped before grabbing the bit field.
*
* Returns the retreived byte.
*/
uint8_t eightbyte_get_byte(const uint64_t source, const uint8_t byte_index,
const bool big_endian);
/* Public: Set the bit field in the given data array to the new value.
*
* destination - a byte array with size at least offset + bit_count.
* value - the value to set in the bit field.
* offset - the starting index of the bit field (beginning from 0).
* bit_count - the number of bits to set in the data.
*
* 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);
/* Public: Retreive the nth byte out of 8 bytes in a uint64_t.
*
* source - the source data to retreive the byte from.
* byte_index - the index of the byte, starting at 0 and assuming big-endian order.
*
* Returns the requested byte from the source bytes.
*/
uint8_t nth_byte(const uint64_t source, const uint16_t byte_index);
/* Private: Determine the index of the last bit used.
*/
uint8_t find_end_bit(const uint16_t num_bits);
#ifdef __cplusplus
}
#endif
#endif // __8BYTE_H__
|
