Mercurial > public > ostc4

comparison OtherSources/data_central_mini.c @ 5:e65d01b6a17e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
MOVE files for other applications
author JeanDo
date Fri, 15 Dec 2017 01:45:20 +0100
parents
children 7801c5d8a562
comparison
equal deleted inserted replaced
4:89a87ddc2e47 5:e65d01b6a17e
1 /**
2 ******************************************************************************
3 * @copyright heinrichs weikamp
4 * @file data_central_mini.c - bootloader only -
5 * @author heinrichs/weikamp, Christian Weikamp
6 * @date 10-November-2014
7 * @version V1.0.3
8 * @since 10-Nov-2014
9 * @brief
10 * @bug
11 * @warning
12 @verbatim
13
14 @endverbatim
15 ******************************************************************************
16 * @attention
17 *
18 * <h2><center>&copy; COPYRIGHT(c) 2015 heinrichs weikamp</center></h2>
19 *
20 ******************************************************************************
21 */
22
23 /* Includes ------------------------------------------------------------------*/
24 #include <string.h>
25 #include "data_central.h"
26 #include "stm32f4xx_hal.h"
27 #include "crcmodel.h"
28
29 void translateDate(uint32_t datetmpreg, RTC_DateTypeDef *sDate)
30 {
31 datetmpreg = (uint32_t)(datetmpreg & RTC_DR_RESERVED_MASK);
32
33 /* Fill the structure fields with the read parameters */
34 sDate->Year = (uint8_t)((datetmpreg & (RTC_DR_YT | RTC_DR_YU)) >> 16);
35 sDate->Month = (uint8_t)((datetmpreg & (RTC_DR_MT | RTC_DR_MU)) >> 8);
36 sDate->Date = (uint8_t)(datetmpreg & (RTC_DR_DT | RTC_DR_DU));
37 sDate->WeekDay = (uint8_t)((datetmpreg & (RTC_DR_WDU)) >> 13);
38
39 /* Convert the date structure parameters to Binary format */
40 sDate->Year = (uint8_t)RTC_Bcd2ToByte(sDate->Year);
41 sDate->Month = (uint8_t)RTC_Bcd2ToByte(sDate->Month);
42 sDate->Date = (uint8_t)RTC_Bcd2ToByte(sDate->Date);
43 }
44
45 void translateTime(uint32_t tmpreg, RTC_TimeTypeDef *sTime)
46 {
47 tmpreg = (uint32_t)(tmpreg & RTC_TR_RESERVED_MASK);
48
49 /* Fill the structure fields with the read parameters */
50 sTime->Hours = (uint8_t)((tmpreg & (RTC_TR_HT | RTC_TR_HU)) >> 16);
51 sTime->Minutes = (uint8_t)((tmpreg & (RTC_TR_MNT | RTC_TR_MNU)) >>8);
52 sTime->Seconds = (uint8_t)(tmpreg & (RTC_TR_ST | RTC_TR_SU));
53 sTime->TimeFormat = (uint8_t)((tmpreg & (RTC_TR_PM)) >> 16);
54
55 /* Convert the time structure parameters to Binary format */
56 sTime->Hours = (uint8_t)RTC_Bcd2ToByte(sTime->Hours);
57 sTime->Minutes = (uint8_t)RTC_Bcd2ToByte(sTime->Minutes);
58 sTime->Seconds = (uint8_t)RTC_Bcd2ToByte(sTime->Seconds);
59 sTime->SubSeconds = 0;
60 }
61
62
63 /* This is derived from crc32b but does table lookup. First the table
64 itself is calculated, if it has not yet been set up.
65 Not counting the table setup (which would probably be a separate
66 function), when compiled to Cyclops with GCC, this function executes in
67 7 + 13n instructions, where n is the number of bytes in the input
68 message. It should be doable in 4 + 9n instructions. In any case, two
69 of the 13 or 9 instrucions are load byte.
70 This is Figure 14-7 in the text. */
71
72 /* http://www.hackersdelight.org/ i guess ;-) *chsw */
73
74 uint32_t crc32c_checksum(uint8_t* message, uint16_t length, uint8_t* message2, uint16_t length2) {
75 int i, j;
76 uint32_t byte, crc, mask;
77 static unsigned int table[256] = {0};
78
79 /* Set up the table, if necessary. */
80 if (table[1] == 0) {
81 for (byte = 0; byte <= 255; byte++) {
82 crc = byte;
83 for (j = 7; j >= 0; j--) { // Do eight times.
84 mask = -(crc & 1);
85 crc = (crc >> 1) ^ (0xEDB88320 & mask);
86 }
87 table[byte] = crc;
88 }
89 }
90
91 /* Through with table setup, now calculate the CRC. */
92 i = 0;
93 crc = 0xFFFFFFFF;
94 while (length--) {
95 byte = message[i];
96 crc = (crc >> 8) ^ table[(crc ^ byte) & 0xFF];
97 i = i + 1;
98 }
99 if(length2)
100 {
101 i = 0;
102 while (length2--) {
103 byte = message2[i];
104 crc = (crc >> 8) ^ table[(crc ^ byte) & 0xFF];
105 i = i + 1;
106 }
107 }
108 return ~crc;
109 }
110
111
112 uint32_t CRC_CalcBlockCRC_moreThan768000(uint32_t *buffer1, uint32_t *buffer2, uint32_t words)
113 {
114 cm_t crc_model;
115 uint32_t word_to_do;
116 uint8_t byte_to_do;
117 int i;
118
119 // Values for the STM32F generator.
120
121 crc_model.cm_width = 32; // 32-bit CRC
122 crc_model.cm_poly = 0x04C11DB7; // CRC-32 polynomial
123 crc_model.cm_init = 0xFFFFFFFF; // CRC initialized to 1's
124 crc_model.cm_refin = FALSE; // CRC calculated MSB first
125 crc_model.cm_refot = FALSE; // Final result is not bit-reversed
126 crc_model.cm_xorot = 0x00000000; // Final result XOR'ed with this
127
128 cm_ini(&crc_model);
129
130 while (words--)
131 {
132 // The STM32F10x hardware does 32-bit words at a time!!!
133 if(words > (768000/4))
134 word_to_do = *buffer2++;
135 else
136 word_to_do = *buffer1++;
137
138 // Do all bytes in the 32-bit word.
139
140 for (i = 0; i < sizeof(word_to_do); i++)
141 {
142 // We calculate a *byte* at a time. If the CRC is MSB first we
143 // do the next MS byte and vica-versa.
144
145 if (crc_model.cm_refin == FALSE)
146 {
147 // MSB first. Do the next MS byte.
148
149 byte_to_do = (uint8_t) ((word_to_do & 0xFF000000) >> 24);
150 word_to_do <<= 8;
151 }
152 else
153 {
154 // LSB first. Do the next LS byte.
155
156 byte_to_do = (uint8_t) (word_to_do & 0x000000FF);
157 word_to_do >>= 8;
158 }
159
160 cm_nxt(&crc_model, byte_to_do);
161 }
162 }
163
164 // Return the final result.
165
166 return (cm_crc(&crc_model));
167 }
168
169
170 uint32_t CRC_CalcBlockCRC(uint32_t *buffer, uint32_t words)
171 {
172 cm_t crc_model;
173 uint32_t word_to_do;
174 uint8_t byte_to_do;
175 int i;
176
177 // Values for the STM32F generator.
178
179 crc_model.cm_width = 32; // 32-bit CRC
180 crc_model.cm_poly = 0x04C11DB7; // CRC-32 polynomial
181 crc_model.cm_init = 0xFFFFFFFF; // CRC initialized to 1's
182 crc_model.cm_refin = FALSE; // CRC calculated MSB first
183 crc_model.cm_refot = FALSE; // Final result is not bit-reversed
184 crc_model.cm_xorot = 0x00000000; // Final result XOR'ed with this
185
186 cm_ini(&crc_model);
187
188 while (words--)
189 {
190 // The STM32F10x hardware does 32-bit words at a time!!!
191
192 word_to_do = *buffer++;
193
194 // Do all bytes in the 32-bit word.
195
196 for (i = 0; i < sizeof(word_to_do); i++)
197 {
198 // We calculate a *byte* at a time. If the CRC is MSB first we
199 // do the next MS byte and vica-versa.
200
201 if (crc_model.cm_refin == FALSE)
202 {
203 // MSB first. Do the next MS byte.
204
205 byte_to_do = (uint8_t) ((word_to_do & 0xFF000000) >> 24);
206 word_to_do <<= 8;
207 }
208 else
209 {
210 // LSB first. Do the next LS byte.
211
212 byte_to_do = (uint8_t) (word_to_do & 0x000000FF);
213 word_to_do >>= 8;
214 }
215
216 cm_nxt(&crc_model, byte_to_do);
217 }
218 }
219
220 // Return the final result.
221
222 return (cm_crc(&crc_model));
223 }
224