rubyfit 0.0.5 → 0.0.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: 105f4f3b3bf24cf21007a2bf83e2b2d09119f575
4
- data.tar.gz: 2486ded9e5f267ea18c455048a789f0c7c948a3f
3
+ metadata.gz: 33df17859113bfabf926430108e48e832a16609d
4
+ data.tar.gz: 67bf9d1069e605c1bd4fe8402c442a3eb9d55531
5
5
  SHA512:
6
- metadata.gz: 33ffdd1af14d01745ed3f8c118f27d888693fb4b9692a26db99546c98855f058c7ea05e8b45811b456be50255368e6dc69ccd6eb13f0f1087a62fee648a51fad
7
- data.tar.gz: db5a2fec83c9b6217d4365afbf48a57e19e347f67f37a5e86b6ce97a007ff90ffd6e0f63c461a5106e166bc6c209af7761a25786e4821e5d575b1de520261e06
6
+ metadata.gz: c79dd06cb89f79330f458b2a7aae56cbd9dd7dbd30a1bfc7054931c960623b66097226a8c6a729e75dda582c4928d652438eadc4c82f631fbde07636652739f7
7
+ data.tar.gz: 5ba13d8485c785f17f2e25a90e940b04eb54272e099eea0f1167615acf432813e5b7023eb702c04679b62b2d098ee6cbdf03271151ff00ec309a6467570e0469
@@ -7,18 +7,17 @@
7
7
  // warranties of merchantability, non-infringement, or fitness for a particular
8
8
  // purpose, are specifically disclaimed.
9
9
  //
10
- // Copyright 2014 Dynastream Innovations Inc.
10
+ // Copyright 2016 Dynastream Innovations Inc.
11
11
  ////////////////////////////////////////////////////////////////////////////////
12
12
  // ****WARNING**** This file is auto-generated! Do NOT edit this file.
13
- // Profile Version = 11.0Release
14
- // Tag = $Name: AKW11_000 $
13
+ // Profile Version = 20.16Release
14
+ // Tag = production/akw/20.16.00-0-gce20b51
15
15
  // Product = EXAMPLE
16
16
  // Alignment = 4 bytes, padding disabled.
17
17
  ////////////////////////////////////////////////////////////////////////////////
18
18
 
19
19
 
20
20
  #include "string.h"
21
- #include "fit.h"
22
21
  #include "fit_example.h"
23
22
 
24
23
 
@@ -42,8 +41,33 @@ const FIT_UINT8 fit_base_type_sizes[FIT_BASE_TYPES] =
42
41
  sizeof(FIT_UINT16Z),
43
42
  sizeof(FIT_UINT32Z),
44
43
  sizeof(FIT_BYTE),
44
+ sizeof(FIT_SINT64),
45
+ sizeof(FIT_UINT64),
46
+ sizeof(FIT_UINT64Z),
45
47
  };
46
48
 
49
+
50
+ typedef union
51
+ {
52
+ FIT_UINT8 uint8_value[8];
53
+ FIT_FLOAT64 float64_value;
54
+ FIT_FLOAT32 float32_value;
55
+ } FIT_INVALID_FLOAT;
56
+
57
+ static const FIT_INVALID_FLOAT invalid_float =
58
+ {
59
+ {
60
+ 0xFF,
61
+ 0xFF,
62
+ 0xFF,
63
+ 0xFF,
64
+ 0xFF,
65
+ 0xFF,
66
+ 0xFF,
67
+ 0xFF
68
+ }
69
+ };
70
+
47
71
  const FIT_ENUM fit_enum_invalid = FIT_ENUM_INVALID;
48
72
  const FIT_SINT8 fit_sint8_invalid = FIT_SINT8_INVALID;
49
73
  const FIT_UINT8 fit_uint8_invalid = FIT_UINT8_INVALID;
@@ -52,12 +76,13 @@ const FIT_UINT16 fit_uint16_invalid = FIT_UINT16_INVALID;
52
76
  const FIT_SINT32 fit_sint32_invalid = FIT_SINT32_INVALID;
53
77
  const FIT_UINT32 fit_uint32_invalid = FIT_UINT32_INVALID;
54
78
  const FIT_STRING fit_string_invalid = FIT_STRING_INVALID;
55
- const FIT_FLOAT32 fit_float32_invalid = FIT_FLOAT32_INVALID;
56
- const FIT_FLOAT64 fit_float64_invalid = FIT_FLOAT64_INVALID;
57
79
  const FIT_UINT8Z fit_uint8z_invalid = FIT_UINT8Z_INVALID;
58
80
  const FIT_UINT16Z fit_uint16z_invalid = FIT_UINT16Z_INVALID;
59
81
  const FIT_UINT32Z fit_uint32z_invalid = FIT_UINT32Z_INVALID;
60
82
  const FIT_BYTE fit_byte_invalid = FIT_BYTE_INVALID;
83
+ const FIT_SINT64 fit_sint64_invalid = FIT_SINT64_INVALID;
84
+ const FIT_UINT64 fit_uint64_invalid = FIT_UINT64_INVALID;
85
+ const FIT_UINT64Z fit_uint64z_invalid = FIT_UINT64Z_INVALID;
61
86
 
62
87
  const FIT_CONST_UINT8_PTR fit_base_type_invalids[FIT_BASE_TYPES] =
63
88
  {
@@ -69,12 +94,15 @@ const FIT_CONST_UINT8_PTR fit_base_type_invalids[FIT_BASE_TYPES] =
69
94
  (FIT_CONST_UINT8_PTR)&fit_sint32_invalid,
70
95
  (FIT_CONST_UINT8_PTR)&fit_uint32_invalid,
71
96
  (FIT_CONST_UINT8_PTR)&fit_string_invalid,
72
- (FIT_CONST_UINT8_PTR)&fit_float32_invalid,
73
- (FIT_CONST_UINT8_PTR)&fit_float64_invalid,
97
+ (FIT_CONST_UINT8_PTR)&invalid_float.float32_value,
98
+ (FIT_CONST_UINT8_PTR)&invalid_float.float64_value,
74
99
  (FIT_CONST_UINT8_PTR)&fit_uint8z_invalid,
75
100
  (FIT_CONST_UINT8_PTR)&fit_uint16z_invalid,
76
101
  (FIT_CONST_UINT8_PTR)&fit_uint32z_invalid,
77
102
  (FIT_CONST_UINT8_PTR)&fit_byte_invalid,
103
+ (FIT_CONST_UINT8_PTR)&fit_sint64_invalid,
104
+ (FIT_CONST_UINT8_PTR)&fit_uint64_invalid,
105
+ (FIT_CONST_UINT8_PTR)&fit_uint64z_invalid,
78
106
  };
79
107
 
80
108
 
@@ -101,6 +129,17 @@ const FIT_MESG_DEF *Fit_GetMesgDef(FIT_UINT16 global_mesg_num)
101
129
  return (FIT_MESG_DEF *) FIT_NULL;
102
130
  }
103
131
 
132
+ const FIT_MESG_DEF *Fit_GetMesgDefFromEnum(FIT_UINT32 fit_mesg_num)
133
+ {
134
+ //Verify enum in range
135
+ if (FIT_MESGS > fit_mesg_num)
136
+ {
137
+ return fit_mesg_defs[fit_mesg_num];
138
+ }
139
+
140
+ return (FIT_MESG_DEF *)FIT_NULL;
141
+ }
142
+
104
143
  FIT_UINT16 Fit_GetMesgDefSize(const FIT_MESG_DEF *mesg_def)
105
144
  {
106
145
  if (mesg_def == FIT_NULL)
@@ -128,6 +167,25 @@ FIT_UINT8 Fit_GetMesgSize(FIT_UINT16 global_mesg_num)
128
167
  return size;
129
168
  }
130
169
 
170
+ FIT_UINT8 Fit_GetMesgSizeFromEnum(FIT_UINT32 fit_mesg_num)
171
+ {
172
+ const FIT_MESG_DEF *mesg_def;
173
+ FIT_UINT8 field;
174
+ FIT_UINT8 size = 0;
175
+
176
+ mesg_def = Fit_GetMesgDefFromEnum(fit_mesg_num);
177
+
178
+ if (mesg_def == FIT_NULL)
179
+ return 0;
180
+
181
+ for (field = 0; field < mesg_def->num_fields; field++)
182
+ {
183
+ size += mesg_def->fields[FIT_MESG_DEF_FIELD_OFFSET(size, field)];
184
+ }
185
+
186
+ return size;
187
+ }
188
+
131
189
  FIT_BOOL Fit_InitMesg(const FIT_MESG_DEF *mesg_def, void *mesg)
132
190
  {
133
191
  FIT_UINT8 *mesg_buf = (FIT_UINT8 *) mesg;
@@ -183,12 +241,13 @@ FIT_FIELD_DEF Fit_GetFieldDef(const FIT_MESG_DEF *mesg_def, FIT_UINT8 field_def_
183
241
  FIT_UINT8 field;
184
242
 
185
243
  field_def.field_def_num = FIT_FIELD_NUM_INVALID;
244
+ field_def.size = 0;
245
+ field_def.base_type = FIT_BASE_TYPE_UINT8;
186
246
 
187
247
  if (mesg_def != FIT_NULL)
188
248
  {
189
249
  for (field = 0; field < mesg_def->num_fields; field++)
190
250
  {
191
-
192
251
  if (mesg_def->fields[FIT_MESG_DEF_FIELD_OFFSET(field_def_num, field)] == field_def_num)
193
252
  {
194
253
  memcpy(&field_def, field_def_ptr, FIT_FIELD_DEF_SIZE);
@@ -213,24 +272,27 @@ FIT_UINT8 Fit_LookupMessage(FIT_UINT16 global_mesg_num, FIT_UINT16 message_index
213
272
  FIT_UINT8 i;
214
273
 
215
274
  *offset = 0;
216
-
275
+
217
276
  if (read_header)
218
- {
219
- if(read_bytes_func(offset, FIT_STRUCT_OFFSET(header_size, FIT_FILE_HDR), sizeof(FIT_UINT8)) != sizeof(FIT_UINT8))
220
- return FIT_UINT8_INVALID;
277
+ {
278
+ if(read_bytes_func(offset, FIT_STRUCT_OFFSET(header_size, FIT_FILE_HDR), sizeof(FIT_UINT8)) != sizeof(FIT_UINT8))
279
+ return FIT_UINT8_INVALID;
221
280
  }
222
281
 
223
282
  for (i = 0; i < FIT_MAX_LOCAL_MESGS; i++)
283
+ {
224
284
  global_mesg_nums[i] = FIT_UINT16_INVALID;
285
+ sizes[i] = 0;
286
+ }
225
287
 
226
- while (1)
288
+ for (;;)
227
289
  {
228
290
  FIT_UINT8 header;
229
291
  FIT_UINT8 local_mesg_num;
230
292
 
231
293
  if (read_bytes_func(&header, *offset, sizeof(header)) != sizeof(header))
232
294
  return FIT_UINT8_INVALID;
233
-
295
+
234
296
  *offset += sizeof(header);
235
297
 
236
298
  if ((header & (FIT_HDR_TIME_REC_BIT | FIT_HDR_TYPE_DEF_BIT)) == FIT_HDR_TYPE_DEF_BIT)
@@ -298,7 +360,7 @@ FIT_UINT8 Fit_LookupMessage(FIT_UINT16 global_mesg_num, FIT_UINT16 message_index
298
360
  {
299
361
  current_message_index++;
300
362
  }
301
-
363
+
302
364
  #if defined(FIT_MESSAGE_INDEX)
303
365
  if ((message_index & FIT_MESSAGE_INDEX_MASK) == (current_message_index & FIT_MESSAGE_INDEX_MASK))
304
366
  #else
@@ -320,7 +382,7 @@ FIT_UINT8 Fit_LookupMessage(FIT_UINT16 global_mesg_num, FIT_UINT16 message_index
320
382
 
321
383
  FIT_UINT32 Fit_GetFileMesgOffset(const FIT_FILE_DEF *file_def, FIT_UINT16 mesg_num, FIT_UINT16 mesg_index)
322
384
  {
323
- FIT_UINT32 offset;
385
+ FIT_UINT32 offset = 0;
324
386
  FIT_UINT16 i = 0;
325
387
 
326
388
  while (i < file_def->mesg_count)
@@ -336,15 +398,13 @@ FIT_UINT32 Fit_GetFileMesgOffset(const FIT_FILE_DEF *file_def, FIT_UINT16 mesg_n
336
398
 
337
399
  if (i >= file_def->mesg_count)
338
400
  return FIT_UINT32_INVALID;
339
-
401
+
340
402
  // Make sure mesg_index is valid for this mesg num and file definition
341
403
  if (mesg_index >= file_def->mesgs[i].count)
342
404
  return FIT_UINT32_INVALID;
343
-
344
- i = 1 + Fit_GetMesgSize(mesg_num); // Message header byte + data.
345
405
 
346
- if (FIT_ALIGNMENT > FIT_HDR_SIZE)
347
- i += FIT_ALIGNMENT - FIT_HDR_SIZE;
406
+ // Compute size of each message (header byte + data)
407
+ i = FIT_HDR_SIZE + Fit_GetMesgSize(mesg_num);
348
408
 
349
409
  offset += mesg_index * i;
350
410
 
@@ -7,11 +7,11 @@
7
7
  // warranties of merchantability, non-infringement, or fitness for a particular
8
8
  // purpose, are specifically disclaimed.
9
9
  //
10
- // Copyright 2014 Dynastream Innovations Inc.
10
+ // Copyright 2016 Dynastream Innovations Inc.
11
11
  ////////////////////////////////////////////////////////////////////////////////
12
12
  // ****WARNING**** This file is auto-generated! Do NOT edit this file.
13
- // Profile Version = 11.0Release
14
- // Tag = $Name: AKW11_000 $
13
+ // Profile Version = 20.16Release
14
+ // Tag = production/akw/20.16.00-0-gce20b51
15
15
  // Product = EXAMPLE
16
16
  // Alignment = 4 bytes, padding disabled.
17
17
  ////////////////////////////////////////////////////////////////////////////////
@@ -31,6 +31,8 @@
31
31
  typedef signed short int16_t;
32
32
  typedef unsigned long uint32_t;
33
33
  typedef signed long int32_t;
34
+ typedef signed long long int64_t;
35
+ typedef unsigned long long uint64_t;
34
36
  #endif
35
37
 
36
38
  #if defined(__cplusplus)
@@ -42,18 +44,26 @@
42
44
  // Version
43
45
  ///////////////////////////////////////////////////////////////////////
44
46
 
45
- #define FIT_PROTOCOL_VERSION_MAJOR 1 // Non-backwards compatible changes. Decode compatible with this version and earlier.
46
- #define FIT_PROTOCOL_VERSION_MINOR 0 // Backwards compatible changes.
47
- #define FIT_PROTOCOL_VERSION_MAJOR_SHIFT 4
48
- #define FIT_PROTOCOL_VERSION_MAJOR_MASK ((FIT_UINT8) (0x0F << FIT_PROTOCOL_VERSION_MAJOR_SHIFT))
49
- #define FIT_PROTOCOL_VERSION_MINOR_MASK ((FIT_UINT8) 0x0F)
50
- #define FIT_PROTOCOL_VERSION ((FIT_UINT8) (FIT_PROTOCOL_VERSION_MAJOR << FIT_PROTOCOL_VERSION_MAJOR_SHIFT) | FIT_PROTOCOL_VERSION_MINOR)
47
+ #define FIT_PROTOCOL_VERSION_10 ( ( FIT_UINT8 )( 1 << FIT_PROTOCOL_VERSION_MAJOR_SHIFT ) | 0 )
48
+ #define FIT_PROTOCOL_VERSION_20 ( ( FIT_UINT8 )( 2 << FIT_PROTOCOL_VERSION_MAJOR_SHIFT ) | 0 )
51
49
 
52
- #define FIT_PROFILE_VERSION_MAJOR 11
53
- #define FIT_PROFILE_VERSION_MINOR 0
54
- #define FIT_PROFILE_VERSION_SCALE 100
55
- #define FIT_PROFILE_VERSION ((FIT_UINT16) (FIT_PROFILE_VERSION_MAJOR * 100 + FIT_PROFILE_VERSION_MINOR))
50
+ #if !defined(FIT_CPP_INCLUDE_C)
51
+ #define FIT_PROTOCOL_VERSION_MAJOR(version) ( ( FIT_UINT8 )( version >> FIT_PROTOCOL_VERSION_MAJOR_SHIFT ) )
52
+ #define FIT_PROTOCOL_VERSION_MINOR(version) ( ( FIT_UINT8 )( version & FIT_PROTOCOL_VERSION_MINOR_MASK ) )
53
+ #define FIT_PROTOCOL_VERSION_MAJOR_SHIFT 4
54
+ #define FIT_PROTOCOL_VERSION_MAJOR_MASK ((FIT_UINT8) (0x0F << FIT_PROTOCOL_VERSION_MAJOR_SHIFT))
55
+ #define FIT_PROTOCOL_VERSION_MINOR_MASK ((FIT_UINT8) 0x0F)
56
56
 
57
+ // Deprecated.
58
+ #define FIT_PROTOCOL_VERSION FIT_PROTOCOL_VERSION_10
59
+
60
+ #define FIT_PROTOCOL_VERSION_MAX FIT_PROTOCOL_VERSION_20
61
+
62
+ #define FIT_PROFILE_VERSION_MAJOR 20
63
+ #define FIT_PROFILE_VERSION_MINOR 16
64
+ #define FIT_PROFILE_VERSION_SCALE 100
65
+ #define FIT_PROFILE_VERSION ((FIT_UINT16) (FIT_PROFILE_VERSION_MAJOR * 100 + FIT_PROFILE_VERSION_MINOR))
66
+ #endif // !defined(FIT_CPP_INCLUDE_C)
57
67
 
58
68
  ///////////////////////////////////////////////////////////////////////
59
69
  // Type Definitions
@@ -99,25 +109,23 @@ typedef uint32_t FIT_UINT32;
99
109
  typedef const FIT_UINT32 * FIT_CONST_UINT32_PTR;
100
110
  #define FIT_UINT32_INVALID ((FIT_UINT32)0xFFFFFFFF)
101
111
  #define FIT_BASE_TYPE_UINT32 ((FIT_UINT8)0x86)
102
-
112
+
103
113
  typedef char FIT_STRING; // UTF-8 null terminated string
104
114
  typedef const FIT_STRING * FIT_CONST_STRING_PTR;
105
115
  #define FIT_STRING_INVALID ((FIT_STRING)0x00)
106
116
  #define FIT_BASE_TYPE_STRING ((FIT_UINT8)0x07)
107
117
 
108
- typedef float FIT_FLOAT32;
109
- typedef const FIT_FLOAT32 * FIT_CONST_FLOAT32_PTR;
110
- #define FIT_FLOAT32_INVALID ((FIT_FLOAT32)0xFFFFFFFF)
111
- #define FIT_BASE_TYPE_FLOAT32 ((FIT_UINT8)0x88)
118
+ #if !defined(FIT_CPP_INCLUDE_C)
119
+ typedef float FIT_FLOAT32;
120
+ typedef const FIT_FLOAT32 * FIT_CONST_FLOAT32_PTR;
121
+ #define FIT_FLOAT32_INVALID ((FIT_FLOAT32)*((FIT_FLOAT32*)fit_base_type_invalids[FIT_BASE_TYPE_FLOAT32 & FIT_BASE_TYPE_NUM_MASK]))
122
+ #define FIT_BASE_TYPE_FLOAT32 ((FIT_UINT8)0x88)
112
123
 
113
- typedef double FIT_FLOAT64;
114
- typedef const FIT_FLOAT64 * FIT_CONST_FLOAT64_PTR;
115
- #if defined (_BORLANDC_)
116
- #define FIT_FLOAT64_INVALID ((FIT_FLOAT64)0xFFFFFFFFFFFFFFFFui64)
117
- #else
118
- #define FIT_FLOAT64_INVALID ((FIT_FLOAT64)0xFFFFFFFFFFFFFFFFull)
119
- #endif
120
- #define FIT_BASE_TYPE_FLOAT64 ((FIT_UINT8)0x89)
124
+ typedef double FIT_FLOAT64;
125
+ typedef const FIT_FLOAT64 * FIT_CONST_FLOAT64_PTR;
126
+ #define FIT_FLOAT64_INVALID ((FIT_FLOAT64)*((FIT_FLOAT64*)fit_base_type_invalids[FIT_BASE_TYPE_FLOAT64 & FIT_BASE_TYPE_NUM_MASK]))
127
+ #define FIT_BASE_TYPE_FLOAT64 ((FIT_UINT8)0x89)
128
+ #endif // !defined(FIT_CPP_INCLUDE_C)
121
129
 
122
130
  typedef uint8_t FIT_UINT8Z;
123
131
  typedef const FIT_UINT8Z * FIT_CONST_UINT8Z_PTR;
@@ -139,7 +147,22 @@ typedef const FIT_BYTE * FIT_CONST_BYTE_PTR;
139
147
  #define FIT_BYTE_INVALID ((FIT_BYTE)0xFF) // Field is invalid if all bytes are invalid.
140
148
  #define FIT_BASE_TYPE_BYTE ((FIT_UINT8)0x0D)
141
149
 
142
- #define FIT_BASE_TYPES 14
150
+ typedef int64_t FIT_SINT64;
151
+ typedef const FIT_SINT64 * FIT_CONST_SINT64_PTR;
152
+ #define FIT_SINT64_INVALID ((FIT_SINT64)0x7FFFFFFFFFFFFFFFL)
153
+ #define FIT_BASE_TYPE_SINT64 ((FIT_UINT8)0x8E)
154
+
155
+ typedef uint64_t FIT_UINT64;
156
+ typedef const FIT_UINT64 * FIT_CONST_UINT64_PTR;
157
+ #define FIT_UINT64_INVALID ((FIT_UINT64)0xFFFFFFFFFFFFFFFFL)
158
+ #define FIT_BASE_TYPE_UINT64 ((FIT_UINT8)0x8F)
159
+
160
+ typedef uint64_t FIT_UINT64Z;
161
+ typedef const FIT_UINT64Z * FIT_CONST_UINT64Z_PTR;
162
+ #define FIT_UINT64Z_INVALID ((FIT_UINT64Z)0x0000000000000000L)
163
+ #define FIT_BASE_TYPE_UINT64Z ((FIT_UINT8)0x90)
164
+
165
+ #define FIT_BASE_TYPES 17
143
166
 
144
167
  typedef FIT_ENUM FIT_BOOL;
145
168
  #define FIT_BOOL_INVALID FIT_ENUM_INVALID
@@ -168,6 +191,7 @@ typedef struct
168
191
  } FIT_FILE_HDR;
169
192
 
170
193
  #define FIT_FILE_HDR_SIZE 14
194
+ #define FIT_FILE_CRC_SIZE 2
171
195
 
172
196
 
173
197
  ///////////////////////////////////////////////////////////////////////
@@ -180,6 +204,7 @@ typedef struct
180
204
  #define FIT_HDR_TIME_TYPE_SHIFT 5
181
205
  #define FIT_HDR_TIME_OFFSET_MASK ((FIT_UINT8) 0x1F)
182
206
  #define FIT_HDR_TYPE_DEF_BIT ((FIT_UINT8) 0x40)
207
+ #define FIT_HDR_DEV_DATA_BIT ((FIT_UINT8) 0x20)
183
208
  #define FIT_HDR_TYPE_MASK ((FIT_UINT8) 0x0F)
184
209
  #define FIT_MAX_LOCAL_MESGS (FIT_HDR_TYPE_MASK + 1)
185
210
 
@@ -187,7 +212,7 @@ typedef struct
187
212
  // File Definitions
188
213
  ///////////////////////////////////////////////////////////////////////
189
214
 
190
- typedef struct
215
+ typedef struct
191
216
  {
192
217
  FIT_UINT32 def_file_offset;
193
218
  FIT_UINT32 data_file_offset;
@@ -196,7 +221,7 @@ typedef struct
196
221
  FIT_UINT16 mesg;
197
222
  } FIT_FILE_MESG;
198
223
 
199
- typedef struct
224
+ typedef struct
200
225
  {
201
226
  FIT_UINT32 data_size;
202
227
  const FIT_FILE_MESG *mesgs;
@@ -219,6 +244,15 @@ typedef struct
219
244
 
220
245
  #define FIT_FIELD_DEF_SIZE 3
221
246
 
247
+ typedef struct
248
+ {
249
+ FIT_UINT8 def_num;
250
+ FIT_UINT8 size;
251
+ FIT_UINT8 dev_index;
252
+ } FIT_DEV_FIELD_DEF;
253
+
254
+ #define FIT_DEV_FIELD_DEF_SIZE 3
255
+
222
256
  typedef struct
223
257
  {
224
258
  FIT_UINT8 reserved_1;
@@ -270,8 +304,8 @@ typedef struct
270
304
  // Public Constants
271
305
  ///////////////////////////////////////////////////////////////////////
272
306
 
273
- const extern FIT_UINT8 fit_base_type_sizes[FIT_BASE_TYPES];
274
- const extern FIT_CONST_UINT8_PTR fit_base_type_invalids[FIT_BASE_TYPES];
307
+ extern const FIT_UINT8 fit_base_type_sizes[FIT_BASE_TYPES];
308
+ extern const FIT_CONST_UINT8_PTR fit_base_type_invalids[FIT_BASE_TYPES];
275
309
 
276
310
 
277
311
  ///////////////////////////////////////////////////////////////////////
@@ -290,6 +324,11 @@ FIT_UINT8 Fit_GetArch(void);
290
324
  ///////////////////////////////////////////////////////////////////////
291
325
  const FIT_MESG_DEF *Fit_GetMesgDef(FIT_UINT16 global_mesg_num);
292
326
 
327
+ ///////////////////////////////////////////////////////////////////////
328
+ // Returns message definition corresponding to FIT_MESG enum.
329
+ ///////////////////////////////////////////////////////////////////////
330
+ const FIT_MESG_DEF *Fit_GetMesgDefFromEnum(FIT_UINT32 fit_mesg_enum);
331
+
293
332
  ///////////////////////////////////////////////////////////////////////
294
333
  // Returns the size of message definition.
295
334
  ///////////////////////////////////////////////////////////////////////
@@ -300,6 +339,11 @@ FIT_UINT16 Fit_GetMesgDefSize(const FIT_MESG_DEF *mesg_def);
300
339
  ///////////////////////////////////////////////////////////////////////
301
340
  FIT_UINT8 Fit_GetMesgSize(FIT_UINT16 global_mesg_num);
302
341
 
342
+ ///////////////////////////////////////////////////////////////////////
343
+ // Returns the size of message corresponding to FIT_MESG enum.
344
+ ///////////////////////////////////////////////////////////////////////
345
+ FIT_UINT8 Fit_GetMesgSizeFromEnum(FIT_UINT32 fit_mesg_enum);
346
+
303
347
  ///////////////////////////////////////////////////////////////////////
304
348
  // Initializes message with invalids.
305
349
  // Returns 1 if successful, otherwise 0.
@@ -7,7 +7,7 @@
7
7
  // warranties of merchantability, non-infringement, or fitness for a particular
8
8
  // purpose, are specifically disclaimed.
9
9
  //
10
- // Copyright 2014 Dynastream Innovations Inc.
10
+ // Copyright 2016 Dynastream Innovations Inc.
11
11
  ////////////////////////////////////////////////////////////////////////////////
12
12
 
13
13
 
@@ -19,9 +19,9 @@
19
19
  extern "C" {
20
20
  #endif
21
21
 
22
- #define FIT_USE_STDINT_H // Define to use stdint.h types. By default size in bytes of integer types assumed to be char=1, short=2, long=4.
22
+ #define FIT_USE_STDINT_H // Define to use stdint.h types. By default size in bytes of integer types assumed to be char=1, short=2, long=4.
23
23
 
24
- #define FIT_LOCAL_MESGS 16 // 1-16. Sets maximum number of local messages that can be decoded. Lower to minimize RAM requirements.
24
+ #define FIT_LOCAL_MESGS 16 // 1-16. Sets maximum number of local messages that can be decoded. Lower to minimize RAM requirements.
25
25
  #define FIT_ARCH_ENDIAN FIT_ARCH_ENDIAN_LITTLE // Set to correct endian for build architecture.
26
26
 
27
27
  #define FIT_CONVERT_CHECK_CRC // Define to check file crc.
@@ -7,11 +7,11 @@
7
7
  // warranties of merchantability, non-infringement, or fitness for a particular
8
8
  // purpose, are specifically disclaimed.
9
9
  //
10
- // Copyright 2014 Dynastream Innovations Inc.
10
+ // Copyright 2016 Dynastream Innovations Inc.
11
11
  ////////////////////////////////////////////////////////////////////////////////
12
12
  // ****WARNING**** This file is auto-generated! Do NOT edit this file.
13
- // Profile Version = 11.0Release
14
- // Tag = $Name: AKW11_000 $
13
+ // Profile Version = 20.16Release
14
+ // Tag = production/akw/20.16.00-0-gce20b51
15
15
  // Product = EXAMPLE
16
16
  // Alignment = 4 bytes, padding disabled.
17
17
  ////////////////////////////////////////////////////////////////////////////////
@@ -71,6 +71,20 @@
71
71
  #else
72
72
  FIT_CONVERT_RETURN FitConvert_Read(const void *data, FIT_UINT32 size)
73
73
  #endif
74
+ {
75
+ #if defined(FIT_CONVERT_MULTI_THREAD)
76
+ return FitConvert_ReadExt(state, data, size, FIT_FALSE);
77
+ #else
78
+ return FitConvert_ReadExt(data, size, FIT_FALSE);
79
+ #endif
80
+ }
81
+
82
+ ///////////////////////////////////////////////////////////////////////
83
+ #if defined(FIT_CONVERT_MULTI_THREAD)
84
+ FIT_CONVERT_RETURN FitConvert_ReadExt(FIT_CONVERT_STATE *state, const void *data, FIT_UINT32 size, FIT_BOOL return_message_numbers)
85
+ #else
86
+ FIT_CONVERT_RETURN FitConvert_ReadExt(const void *data, FIT_UINT32 size, FIT_BOOL return_message_numbers)
87
+ #endif
74
88
  {
75
89
  while (state->data_offset < size)
76
90
  {
@@ -129,9 +143,10 @@
129
143
  return FIT_CONVERT_DATA_TYPE_NOT_SUPPORTED;
130
144
  #endif
131
145
 
132
- if ((state->u.file_hdr.protocol_version & FIT_PROTOCOL_VERSION_MAJOR_MASK) > (FIT_PROTOCOL_VERSION_MAJOR << FIT_PROTOCOL_VERSION_MAJOR_SHIFT))
146
+ if (FIT_PROTOCOL_VERSION_MAJOR(state->u.file_hdr.protocol_version) >
147
+ FIT_PROTOCOL_VERSION_MAJOR(FIT_PROTOCOL_VERSION_MAX))
133
148
  return FIT_CONVERT_PROTOCOL_VERSION_NOT_SUPPORTED;
134
-
149
+
135
150
  state->decode_state = FIT_CONVERT_DECODE_RECORD;
136
151
  }
137
152
  break;
@@ -163,8 +178,16 @@
163
178
  }
164
179
  else
165
180
  {
181
+ state->has_dev_data = FIT_FALSE;
166
182
  // This is a message definition record.
183
+ if ((datum & FIT_HDR_DEV_DATA_BIT) != 0)
184
+ {
185
+ // This message has Dev Data
186
+ state->has_dev_data = FIT_TRUE;
187
+ }
188
+
167
189
  state->mesg_sizes[state->mesg_index] = 0;
190
+ state->dev_data_sizes[state->mesg_index] = 0;
168
191
  state->decode_state = FIT_CONVERT_DECODE_RESERVED1;
169
192
  }
170
193
  }
@@ -242,12 +265,22 @@
242
265
 
243
266
  if (state->num_fields == 0)
244
267
  {
245
- state->decode_state = FIT_CONVERT_DECODE_RECORD;
268
+ state->decode_state = state->has_dev_data ?
269
+ FIT_CONVERT_DECODE_NUM_DEV_FIELDS : FIT_CONVERT_DECODE_RECORD;
246
270
  break;
247
271
  }
248
272
 
249
273
  state->field_index = 0;
250
274
  state->decode_state = FIT_CONVERT_DECODE_FIELD_DEF;
275
+
276
+ //Return That a message number has been found (The user can then optionally over-ride the mesg_def property on the state object
277
+ //to use the alternate message definition if needed.
278
+ if ( return_message_numbers )
279
+ {
280
+ //When this event is received, the consuming application can call "FitConvert_SetMessageDefinition"
281
+ //to override the message definition to use (for alternate message definitions).
282
+ return FIT_CONVERT_MESSAGE_NUMBER_FOUND;
283
+ }
251
284
  break;
252
285
 
253
286
  case FIT_CONVERT_DECODE_FIELD_DEF:
@@ -292,9 +325,9 @@
292
325
  if (datum < state->convert_table[state->mesg_index].fields[state->convert_table[state->mesg_index].num_fields].size)
293
326
  state->convert_table[state->mesg_index].fields[state->convert_table[state->mesg_index].num_fields].size = datum;
294
327
  }
295
- }
296
328
 
297
- state->mesg_sizes[state->mesg_index] += datum;
329
+ state->mesg_sizes[state->mesg_index] += datum;
330
+ }
298
331
 
299
332
  state->decode_state = FIT_CONVERT_DECODE_FIELD_BASE_TYPE;
300
333
  break;
@@ -309,9 +342,48 @@
309
342
  state->field_index++;
310
343
 
311
344
  if (state->field_index >= state->num_fields)
312
- state->decode_state = FIT_CONVERT_DECODE_RECORD;
345
+ {
346
+ state->decode_state = state->has_dev_data ?
347
+ FIT_CONVERT_DECODE_NUM_DEV_FIELDS : FIT_CONVERT_DECODE_RECORD;
348
+ }
313
349
  else
350
+ {
314
351
  state->decode_state = FIT_CONVERT_DECODE_FIELD_DEF;
352
+ }
353
+ break;
354
+
355
+ case FIT_CONVERT_DECODE_NUM_DEV_FIELDS:
356
+ state->num_fields = datum;
357
+
358
+ if (state->num_fields == 0)
359
+ {
360
+ state->decode_state = FIT_CONVERT_DECODE_RECORD;
361
+ break;
362
+ }
363
+
364
+ state->field_index = 0;
365
+ state->decode_state = FIT_CONVERT_DECODE_DEV_FIELD_DEF;
366
+ break;
367
+
368
+ case FIT_CONVERT_DECODE_DEV_FIELD_DEF:
369
+ // Doesn't matter yet
370
+ state->decode_state = FIT_CONVERT_DECODE_DEV_FIELD_SIZE;
371
+ break;
372
+
373
+ case FIT_CONVERT_DECODE_DEV_FIELD_SIZE:
374
+ // Just keep track of the amount of data that we need to ignore
375
+ state->dev_data_sizes[state->mesg_index] += datum;
376
+ state->decode_state = FIT_CONVERT_DECODE_DEV_FIELD_INDEX;
377
+ break;
378
+
379
+ case FIT_CONVERT_DECODE_DEV_FIELD_INDEX:
380
+ // Increment the number of fields that we have read
381
+ state->field_index++;
382
+
383
+ if (state->field_index >= state->num_fields)
384
+ state->decode_state = FIT_CONVERT_DECODE_RECORD;
385
+ else
386
+ state->decode_state = FIT_CONVERT_DECODE_DEV_FIELD_DEF;
315
387
  break;
316
388
 
317
389
  case FIT_CONVERT_DECODE_FIELD_DATA:
@@ -319,7 +391,15 @@
319
391
 
320
392
  if (state->mesg_offset >= state->mesg_sizes[state->mesg_index])
321
393
  {
322
- state->decode_state = FIT_CONVERT_DECODE_RECORD;
394
+ if (state->dev_data_sizes[state->mesg_index] > 0)
395
+ {
396
+ // There is dev data to read
397
+ state->decode_state = FIT_CONVERT_DECODE_DEV_FIELD_DATA;
398
+ }
399
+ else
400
+ {
401
+ state->decode_state = FIT_CONVERT_DECODE_RECORD;
402
+ }
323
403
  }
324
404
 
325
405
  if (state->mesg_index < FIT_LOCAL_MESGS)
@@ -368,13 +448,13 @@
368
448
  if (state->convert_table[state->mesg_index].fields[state->field_index].base_type == FIT_BASE_TYPE_STRING)
369
449
  {
370
450
  FIT_UINT8 length = state->convert_table[state->mesg_index].fields[state->field_index].size;
371
- FIT_UINT8 index = 0;
372
-
451
+ FIT_UINT8 index = 0;
452
+
373
453
  while (index < length)
374
454
  {
375
455
  FIT_UINT8 char_size;
376
456
  FIT_UINT8 size_mask = 0x80;
377
-
457
+
378
458
  if (field[index] & size_mask)
379
459
  {
380
460
  char_size = 0;
@@ -389,7 +469,7 @@
389
469
  {
390
470
  char_size = 1;
391
471
  }
392
-
472
+
393
473
  if ((FIT_UINT16)(index + char_size) > length)
394
474
  {
395
475
  while (index < length)
@@ -398,11 +478,11 @@
398
478
  }
399
479
  break;
400
480
  }
401
-
481
+
402
482
  index += char_size;
403
483
  }
404
484
  }
405
-
485
+
406
486
  state->field_offset = 0; // Reset the offset.
407
487
  state->field_index++; // Move on to the next field.
408
488
 
@@ -423,8 +503,12 @@
423
503
  }
424
504
  #endif
425
505
 
426
- // We have successfully decoded a mesg.
427
- return FIT_CONVERT_MESSAGE_AVAILABLE;
506
+ state->field_index = 0;
507
+ if ( state->dev_data_sizes[state->mesg_index] == 0 )
508
+ {
509
+ // We have successfully decoded a mesg and there is no dev data to read.
510
+ return FIT_CONVERT_MESSAGE_AVAILABLE;
511
+ }
428
512
  }
429
513
  }
430
514
  }
@@ -432,6 +516,18 @@
432
516
  }
433
517
  break;
434
518
 
519
+ case FIT_CONVERT_DECODE_DEV_FIELD_DATA:
520
+ state->field_offset++;
521
+ if (state->field_offset >= state->dev_data_sizes[state->mesg_index])
522
+ {
523
+ // Done Parsing Dev Field Data
524
+ state->decode_state = FIT_CONVERT_DECODE_RECORD;
525
+
526
+ // We have successfully decoded a mesg and there is no dev data to read.
527
+ return FIT_CONVERT_MESSAGE_AVAILABLE;
528
+ }
529
+ break;
530
+
435
531
  default:
436
532
  // This shouldn't happen.
437
533
  return FIT_CONVERT_ERROR;
@@ -442,6 +538,14 @@
442
538
  return FIT_CONVERT_CONTINUE;
443
539
  }
444
540
 
541
+ ///////////////////////////////////////////////////////////////////////
542
+ #if !defined(FIT_CONVERT_MULTI_THREAD)
543
+ void FitConvert_SetMessageDefinition(FIT_MESG_DEF *mesg_def)
544
+ {
545
+ state->mesg_def = mesg_def;
546
+ }
547
+ #endif
548
+
445
549
  ///////////////////////////////////////////////////////////////////////
446
550
  #if defined(FIT_CONVERT_MULTI_THREAD)
447
551
  FIT_UINT16 FitConvert_GetMessageNumber(FIT_CONVERT_STATE *state)