source: firmware/FSC/src/num_conversion.c @ 10094

Last change on this file since 10094 was 10094, checked in by neise, 9 years ago
initial commit of FSC firmware - use for FSC testing only -
File size: 8.6 KB
Line 
1//-----------------------------------------------------------------------------
2
3#include "num_conversion.h"
4//-----------------------------------------------------------------------------
5
6//__flash U08 NC_HEX_ARRAY[] = "0123456789ABCDEF";
7U08 NC_HEX_ARRAY[] = "0123456789ABCDEF";
8//-----------------------------------------------------------------------------
9
10U08 nc_buffer[NC_BUFFER_LENGTH]; // Conversion buffer
11U08 nc_format_buffer[NC_BUFFER_LENGTH]; // Format buffer
12
13static U08 nc_int_digits[8];
14static U08 nc_dec_digits[6];
15//-----------------------------------------------------------------------------
16
17pU08 nc_format(pU08 source_ptr,U08 digits)
18{
19  U08 len = strlen((const char *)source_ptr);
20  pU08 dest_ptr = (pU08)&nc_format_buffer;
21
22  // Fillup loop
23  while (digits-- > len)
24  {
25    *dest_ptr++ = NC_FILL_CHAR;
26  }
27
28  // Copy loop
29  while (len--)
30  {
31    *dest_ptr++ = *source_ptr++;
32  }
33
34  *dest_ptr = 0; // Terminate format string
35
36  return (pU08)&nc_format_buffer;
37}
38//-----------------------------------------------------------------------------
39
40pU08 nc_U08_to_str(U08 value,U08 digits)
41{
42  pU08 pstr = nc_buffer;
43
44  if (value >= 100) *pstr++ = ('0' + (value % 1000 / 100));
45  if (value >= 10) *pstr++ = ('0' + (value % 100 / 10));
46  *pstr++ = ('0' + (value % 10));
47  *pstr = 0;
48
49  if (!digits) // If digits = 0, then return buffer start
50  {
51    return nc_buffer;
52  }
53  else // Do formatted output
54  {
55    return nc_format(nc_buffer,digits);
56  }
57}
58//-----------------------------------------------------------------------------
59
60pU08 nc_S08_to_str(S08 signed_value,U08 digits)
61{
62  pU08 pstr = nc_buffer;
63  U08 value;
64
65  if (signed_value < 0)
66  {
67    *pstr++ = '-';
68    value = -signed_value;
69  }
70  else
71  {
72    value = signed_value;
73  }
74
75  if (value >= 100) *pstr++ = ('0' + (value % 1000 / 100));
76  if (value >= 10) *pstr++ = ('0' + (value % 100 / 10));
77  *pstr++ = ('0' + (value % 10));
78  *pstr = 0;
79
80  if (!digits) // If digits = 0, then return buffer start
81  {
82    return nc_buffer;
83  }
84  else // Do formatted output
85  {
86    return nc_format(nc_buffer,digits);
87  }
88}
89//-----------------------------------------------------------------------------
90
91pU08 nc_U08_to_hex(U08 value)
92{
93  pU08 pstr = nc_buffer;
94
95  *pstr++ = NC_HEX_ARRAY[value >> 4];
96  *pstr++ = NC_HEX_ARRAY[value & 0x0F];
97  *pstr = 0;
98
99  return (nc_buffer);
100}
101//-----------------------------------------------------------------------------
102
103pU08 nc_U08_to_bin(U08 value)
104{
105  pU08 pstr = nc_buffer;
106  U08 n;
107
108  for (n = 7; n < 8; n--)
109  {
110    if (value & (1 << n))
111    {
112      *pstr++ = '1';
113    }
114    else
115    {
116      *pstr++ = '0';
117    }
118  }
119
120  *pstr = 0;
121
122  return (nc_buffer);
123}
124//-----------------------------------------------------------------------------
125
126pU08 nc_U16_to_str(U16 value,U08 digits)
127{
128  pU08 pstr = nc_buffer;
129
130  if (value >= 10000) *pstr++ = ('0' + (value / 10000));
131  if (value >= 1000) *pstr++ = ('0' + (value % 10000 / 1000));
132  if (value >= 100) *pstr++ = ('0' + (value % 1000 / 100));
133  if (value >= 10)*pstr++ = ('0' + (value % 100 / 10));
134  *pstr++ = ('0' + (value % 10));
135  *pstr = 0;
136
137  if (!digits) // If digits = 0, then return buffer start
138  {
139    return nc_buffer;
140  }
141  else // Do formatted output
142  {
143    return nc_format(nc_buffer,digits);
144  }
145}
146//-----------------------------------------------------------------------------
147
148pU08 nc_S16_to_str(S16 signed_value,U08 digits)
149{
150  pU08 pstr = nc_buffer;
151  U16 value;
152
153  if (signed_value < 0)
154  {
155    *pstr++ = '-';
156    value = -signed_value;
157  }
158  else
159  {
160    value = signed_value;
161  }
162
163  if (value >= 10000) *pstr++ = ('0' + (value / 10000));
164  if (value >= 1000) *pstr++ = ('0' + (value % 10000 / 1000));
165  if (value >= 100) *pstr++ = ('0' + (value % 1000 / 100));
166  if (value >= 10) *pstr++ = ('0' + (value % 100 / 10));
167  *pstr++ = ('0' + (value % 10));
168  *pstr = 0;
169
170  if (!digits) // If digits = 0, then return buffer start
171  {
172    return nc_buffer;
173  }
174  else // Do formatted output
175  {
176    return nc_format(nc_buffer,digits);
177  }
178}
179//-----------------------------------------------------------------------------
180
181pU08 nc_U16_to_hex(U16 value)
182{
183  pU08 pstr = nc_buffer;
184  tMEM16 data;
185
186  data.word = value;
187
188  *pstr++ = NC_HEX_ARRAY[(data.byte[1]) >> 4];
189  *pstr++ = NC_HEX_ARRAY[(data.byte[1]) & 0x0F];
190
191  *pstr++ = NC_HEX_ARRAY[(data.byte[0]) >> 4];
192  *pstr++ = NC_HEX_ARRAY[(data.byte[0]) & 0x0F];
193
194  *pstr = 0;
195
196  return (nc_buffer);
197}
198//-----------------------------------------------------------------------------
199
200pU08 nc_U32_to_str(U32 value,U08 digits)
201{
202  pU08 pstr = nc_buffer;
203
204  if (value >= 1000000000) *pstr++ = ('0' + (value / 1000000000));
205  if (value >= 100000000) *pstr++ = ('0' + (value % 1000000000 / 100000000));
206  if (value >= 10000000) *pstr++ = ('0' + (value % 100000000 / 10000000));
207  if (value >= 1000000) *pstr++ = ('0' + (value % 10000000 / 1000000));
208  if (value >= 100000) *pstr++ = ('0' + (value % 1000000 / 100000));
209  if (value >= 10000) *pstr++ = ('0' + (value % 100000 / 10000));
210  if (value >= 1000) *pstr++ = ('0' + (value % 10000 / 1000));
211  if (value >= 100) *pstr++ = ('0' + (value % 1000 / 100));
212  if (value >= 10) *pstr++ = ('0' + (value % 100 / 10));
213
214  *pstr++ = ('0' + (value % 10));
215  *pstr = 0;
216
217  if (!digits) // If digits = 0, then return buffer start
218  {
219    return nc_buffer;
220  }
221  else // Do formatted output
222  {
223    return nc_format(nc_buffer,digits);
224  }
225}
226//-----------------------------------------------------------------------------
227
228pU08 nc_S32_to_str(S32 signed_value,U08 digits)
229{
230  pU08 pstr = nc_buffer;
231  U32 value;
232
233  if (signed_value < 0)
234  {
235    *pstr++ = '-';
236    value = -signed_value;
237  }
238  else
239  {
240    value = signed_value;
241  }
242
243  if (value >= 1000000000) *pstr++ = ('0' + (value / 1000000000));
244  if (value >= 100000000) *pstr++ = ('0' + (value % 1000000000 / 100000000));
245  if (value >= 10000000) *pstr++ = ('0' + (value % 100000000 / 10000000));
246  if (value >= 1000000) *pstr++ = ('0' + (value % 10000000 / 1000000));
247  if (value >= 100000) *pstr++ = ('0' + (value % 1000000 / 100000));
248  if (value >= 10000) *pstr++ = ('0' + (value % 100000 / 10000));
249  if (value >= 1000) *pstr++ = ('0' + (value % 10000 / 1000));
250  if (value >= 100) *pstr++ = ('0' + (value % 1000 / 100));
251  if (value >= 10) *pstr++ = ('0' + (value % 100 / 10));
252
253  *pstr++ = ('0' + (value % 10));
254  *pstr = 0;
255
256  if (!digits) // If digits = 0, then return buffer start
257  {
258    return nc_buffer;
259  }
260  else // Do formatted output
261  {
262    return nc_format(nc_buffer,digits);
263  }
264}
265//-----------------------------------------------------------------------------
266
267pU08 nc_U32_to_hex(U32 value)
268{
269  pU08 pstr = nc_buffer;
270  tMEM32 data;
271
272  data.dword = value;
273
274  *pstr++ = NC_HEX_ARRAY[(data.byte[3]) >> 4];
275  *pstr++ = NC_HEX_ARRAY[(data.byte[3]) & 0x0F];
276
277  *pstr++ = NC_HEX_ARRAY[(data.byte[2]) >> 4];
278  *pstr++ = NC_HEX_ARRAY[(data.byte[2]) & 0x0F];
279
280  *pstr++ = NC_HEX_ARRAY[(data.byte[1]) >> 4];
281  *pstr++ = NC_HEX_ARRAY[(data.byte[1]) & 0x0F];
282
283  *pstr++ = NC_HEX_ARRAY[(data.byte[0]) >> 4];
284  *pstr++ = NC_HEX_ARRAY[(data.byte[0]) & 0x0F];
285
286  *pstr = 0;
287
288  return (nc_buffer);
289}
290//-----------------------------------------------------------------------------
291
292pU08 nc_float_to_str(float value,U08 decimals,U08 digits)
293{
294  S08 n;
295  U08 int_count;
296  U08 dec_count;
297  float dec_part;
298  U32 int_part;
299  pU08 pstr = nc_buffer;
300
301  if (decimals > 5)
302  {
303    decimals = 5;
304  }
305
306  if (value < 0.0)
307  {
308    *pstr++ = '-';
309    value = -value;
310  }
311
312  int_part = value;
313  dec_part = value - int_part;
314  int_count = 0;
315  dec_count = 0;
316
317  if (int_part == 0)
318  {
319    *pstr++ = '0';
320  }
321
322  while (int_part > 0)
323  {
324    nc_int_digits[int_count] = int_part % 10;
325    int_part = int_part - nc_int_digits[int_count];
326
327    if (int_part > 0)
328    {
329      int_part = int_part / 10;
330    }
331
332    int_count++; // go to the next digit
333  }
334
335  while (dec_count < decimals)
336  {
337    dec_part = dec_part * 10.0;
338    nc_dec_digits[dec_count] = dec_part;
339
340    if (nc_dec_digits[dec_count] > 0)
341    {
342      dec_part = dec_part - nc_dec_digits[dec_count];
343    }
344
345    dec_count++;
346  }
347
348  for (n = int_count - 1; n > -1; n--)
349  {
350    *pstr++ = 48 + nc_int_digits[n];
351  }
352
353  *pstr++ = '.';
354
355  for (n = 0; n < dec_count; n++)
356  {
357    *pstr++ = 48 + nc_dec_digits[n];
358  }
359
360  // Terminate string
361  *pstr = 0;
362
363  if (!digits) // If digits = 0, then return buffer start
364  {
365    return nc_buffer;
366  }
367  else // Do formatted output
368  {
369    return nc_format(nc_buffer,digits);
370  }
371}
Note: See TracBrowser for help on using the repository browser.