Rev 1963 | Rev 1965 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed
Rev 1963 | Rev 1964 | ||
---|---|---|---|
Line 106... | Line 106... | ||
106 | result += data[i]; |
106 | result += data[i]; |
107 | } |
107 | } |
108 | return result; |
108 | return result; |
109 | } |
109 | } |
Line -... | Line 110... | ||
- | 110 | ||
- | 111 | // offset is where the checksum is stored, offset+1 is the revision number, and offset+2... are the data. |
|
110 | 112 | // length is the length of the pure data not including checksum and revision number. |
|
111 | void writeChecksummedBlock(uint8_t revisionNumber, uint8_t* data, uint16_t length, uint16_t offset) { |
113 | void writeChecksummedBlock(uint8_t revisionNumber, uint8_t* data, uint16_t offset, uint16_t length) { |
112 | uint8_t checksum = calculateChecksum(data+1, length-1); |
114 | uint8_t checksum = calculateChecksum(data, length); |
113 | data[0] = checksum; |
115 | eeprom_write_byte(&EEPromArray[offset], checksum); |
114 | data[1] = revisionNumber; |
116 | eeprom_write_byte(&EEPromArray[offset+1], revisionNumber); |
115 | eeprom_write_block(data, &EEPromArray[offset], length); |
117 | eeprom_write_block(data, &EEPromArray[offset+2], length); |
116 | } |
118 | } |
- | 119 | ||
- | 120 | // offset is where the checksum is stored, offset+1 is the revision number, and offset+2... are the data. |
|
117 | 121 | // length is the length of the pure data not including checksum and revision number. |
|
- | 122 | uint8_t readChecksummedBlock(uint8_t revisionNumber, uint8_t* target, uint16_t offset, uint16_t length) { |
|
- | 123 | uint8_t checksumRead = eeprom_read_byte(&EEPromArray[offset]); |
|
118 | uint8_t readChecksummedBlock(uint8_t revisionNumber, uint8_t* target, uint16_t length, uint16_t offset) { |
124 | uint8_t revisionNumberRead = eeprom_read_byte(&EEPromArray[offset+1]); |
119 | eeprom_read_block(target, &EEPromArray[offset], length); |
125 | eeprom_read_block(target, &EEPromArray[offset+2], length); |
- | 126 | uint8_t checksumCalculated = calculateChecksum(target, length); |
|
- | 127 | ||
- | 128 | uint8_t checksumError = (checksumRead != checksumCalculated); |
|
- | 129 | uint8_t revisionMismatch = (revisionNumber != revisionNumberRead); |
|
- | 130 | ||
- | 131 | if (checksumError && revisionMismatch) printf("\n\rEEPROM checksum error and revision mismatch, "); |
|
- | 132 | else if (checksumError) printf("\n\rEEPROM checksum error, "); |
|
120 | uint8_t checksum = calculateChecksum(target+1, length-1); |
133 | else if (revisionMismatch) printf("\n\rEEPROM revision mismatch, "); |
121 | return (checksum != target[0] || revisionNumber != target[1]); |
134 | return (checksumError || revisionMismatch); |
Line 122... | Line 135... | ||
122 | } |
135 | } |
123 | 136 | ||
124 | /***************************************************/ |
137 | /***************************************************/ |
125 | /* Read Parameter Set from EEPROM */ |
138 | /* Read Parameter Set from EEPROM */ |
126 | /***************************************************/ |
139 | /***************************************************/ |
127 | // setnumber [1..5] |
140 | // setnumber [1..5] |
128 | uint8_t paramSet_readFromEEProm(uint8_t setnumber) { |
141 | uint8_t paramSet_readFromEEProm(uint8_t setnumber) { |
129 | uint16_t offset = EEPROM_ADR_PARAMSET_BEGIN + (setnumber-1)*sizeof(paramset_t); |
142 | uint16_t offset = EEPROM_ADR_PARAMSET_BEGIN + (setnumber-1)*(sizeof(paramset_t)+2); |
130 | output_init(); // what's that doing here?? |
143 | output_init(); // what's that doing here?? |
Line 131... | Line 144... | ||
131 | return readChecksummedBlock(EEPARAM_REVISION, (uint8_t*)&staticParams, sizeof(paramset_t), offset); |
144 | return readChecksummedBlock(EEPARAM_REVISION, (uint8_t*)&staticParams, offset, sizeof(paramset_t)); |
132 | } |
145 | } |
133 | 146 | ||
134 | /***************************************************/ |
147 | /***************************************************/ |
135 | /* Write Parameter Set to EEPROM */ |
148 | /* Write Parameter Set to EEPROM */ |
136 | /***************************************************/ |
149 | /***************************************************/ |
137 | void paramSet_writeToEEProm(uint8_t setnumber) { |
150 | void paramSet_writeToEEProm(uint8_t setnumber) { |
138 | uint16_t offset = EEPROM_ADR_PARAMSET_BEGIN + (setnumber-1)*sizeof(paramset_t); |
151 | uint16_t offset = EEPROM_ADR_PARAMSET_BEGIN + (setnumber-1)*(sizeof(paramset_t)+2); |
139 | writeChecksummedBlock(EEPARAM_REVISION, (uint8_t*)&staticParams, sizeof(paramset_t), offset); |
152 | writeChecksummedBlock(EEPARAM_REVISION, (uint8_t*)&staticParams, offset, sizeof(paramset_t)); |
140 | // set this parameter set to active set |
153 | // set this parameter set to active set |
Line 141... | Line 154... | ||
141 | setActiveParamSet(setnumber); |
154 | setActiveParamSet(setnumber); |
142 | output_init(); // what's that doing here?? |
155 | output_init(); // what's that doing here?? |
143 | } |
156 | } |
144 | 157 | ||
145 | void paramSet_readOrDefault() { |
158 | void paramSet_readOrDefault() { |
146 | uint8_t setnumber = getActiveParamSet(); |
159 | uint8_t setnumber = getActiveParamSet(); |
147 | // parameter version check |
160 | // parameter version check |
148 | if (setnumber<1 ||setnumber>5 || paramSet_readFromEEProm(setnumber)) { |
161 | if (setnumber<1 ||setnumber>5 || paramSet_readFromEEProm(setnumber)) { |
149 | // if version check faild |
162 | // if version check faild |
150 | printf("\n\rInit Parameter in EEPROM"); |
163 | printf("writing default parameter sets"); |
151 | for (uint8_t i=6; i>0; i--) { |
164 | for (uint8_t i=5; i>0; i--) { |
152 | paramSet_default(i); // Fill staticParams Structure to default parameter set 1 (Sport) |
165 | paramSet_default(i); |
153 | paramSet_writeToEEProm(i); |
166 | paramSet_writeToEEProm(i); |
Line 154... | Line 167... | ||
154 | } |
167 | } |
155 | // default-Setting is parameter set 3 |
168 | // default-Setting is parameter set 3 |
Line 156... | Line 169... | ||
156 | setActiveParamSet(1); |
169 | setActiveParamSet(1); |
157 | } |
170 | } |
158 | 171 | ||
Line 171... | Line 184... | ||
171 | } |
184 | } |
Line 172... | Line 185... | ||
172 | 185 | ||
173 | void mixerMatrix_readOrDefault(void) { |
186 | void mixerMatrix_readOrDefault(void) { |
174 | // load mixer table |
187 | // load mixer table |
175 | if (mixerMatrix_readFromEEProm()) { |
188 | if (mixerMatrix_readFromEEProm()) { |
176 | printf("\n\rGenerating default mixerMatrix"); |
189 | printf("writing default mixerMatrix"); |
177 | mixerMatrix_default(); // Quadro |
190 | mixerMatrix_default(); // Quadro |
178 | mixerMatrix_writeToEEProm(); |
191 | mixerMatrix_writeToEEProm(); |
179 | } |
192 | } |
180 | // determine motornumber |
193 | // determine motornumber |
181 | requiredMotors = 0; |
194 | requiredMotors = 0; |
182 | for (uint8_t i=0; i<MAX_MOTORS; i++) { |
195 | for (uint8_t i=0; i<MAX_MOTORS; i++) { |
183 | if (mixerMatrix.motor[i][MIX_THROTTLE]) |
196 | if (mixerMatrix.motor[i][MIX_THROTTLE]) |
184 | requiredMotors++; |
197 | requiredMotors++; |
Line 185... | Line 198... | ||
185 | } |
198 | } |
186 | 199 | ||
187 | printf("\n\rMixer-Config: '%s' (%u Motors)",mixerMatrix.name, requiredMotors); |
200 | printf("\n\r\rMixer-Config: '%s' (%u Motors)",mixerMatrix.name, requiredMotors); |
Line 188... | Line 201... | ||
188 | printf("\n\r=============================="); |
201 | printf("\n\r\r=============================="); |
189 | } |
202 | } |
190 | 203 | ||
Line 198... | Line 211... | ||
198 | void channelMap_writeToEEProm(void) { |
211 | void channelMap_writeToEEProm(void) { |
199 | writeChecksummedBlock(CHANNELMAP_REVISION, (uint8_t*)&channelMap, EEPROM_ADR_CHANNELMAP, sizeof(channelMap_t)); |
212 | writeChecksummedBlock(CHANNELMAP_REVISION, (uint8_t*)&channelMap, EEPROM_ADR_CHANNELMAP, sizeof(channelMap_t)); |
200 | } |
213 | } |
Line 201... | Line 214... | ||
201 | 214 | ||
202 | void channelMap_readOrDefault(void) { |
215 | void channelMap_readOrDefault(void) { |
203 | if (!channelMap_readFromEEProm()) { |
216 | if (channelMap_readFromEEProm()) { |
204 | printf("\n\rGenerating default channel map"); |
217 | printf("writing default channel map"); |
205 | channelMap_default(); |
218 | channelMap_default(); |
206 | channelMap_writeToEEProm(); |
219 | channelMap_writeToEEProm(); |
207 | } |
220 | } |