WebSVN - FlightCtrl - Diff - Rev 2156 and 2157 - /branches/dongfang_FC


#ifndef EEMEM
#define EEMEM __attribute__ ((section (".eeprom")))
#endif
 
#include "eeprom.h"
#include "printf_P.h"
#include "output.h"
#include "configuration.h"
#include <avr/wdt.h>
#include <avr/eeprom.h>
 
// byte array in eeprom
uint8_t EEPromArray[E2END + 1] EEMEM;
 
/***************************************************/
/*       Read Parameter from EEPROM as byte        */
/***************************************************/
uint8_t getParamByte(uint16_t param_id) {
  return eeprom_read_byte(&EEPromArray[EEPROM_ADR_PARAM_BEGIN + param_id]);
}
 
/***************************************************/
/*       Write Parameter to EEPROM as byte         */
/***************************************************/
void setParamByte(uint16_t param_id, uint8_t value) {
  eeprom_write_byte(&EEPromArray[EEPROM_ADR_PARAM_BEGIN + param_id], value);
}
 
/***************************************************/
/*       Read Parameter from EEPROM as word        */
/***************************************************/
/*
uint16_t getParamWord(uint16_t param_id) {
  return eeprom_read_word((uint16_t *) &EEPromArray[EEPROM_ADR_PARAM_BEGIN
                                                    + param_id]);
}
*/
 
/***************************************************/
/*       Write Parameter to EEPROM as word         */
/***************************************************/
/*
void setParamWord(uint16_t param_id, uint16_t value) {
  eeprom_write_word((uint16_t *) &EEPromArray[EEPROM_ADR_PARAM_BEGIN + param_id], value);
}
*/
 
uint16_t CRC16(uint8_t* data, uint16_t length) {
  uint16_t crc = 0;
  for (uint16_t i=0; i<length; i++) {
    crc  = (uint8_t)(crc >> 8) | (crc << 8);
    crc ^= data[i];
    crc ^= (uint8_t)(crc & 0xff) >> 4;
    crc ^= (crc << 8) << 4;
    crc ^= ((crc & 0xff) << 4) << 1;
  }
  return crc;
}
 
// offset is where the checksum is stored, offset+1 is the revision number, and offset+2... are the data.
// length is the length of the pure data not including checksum and revision number.
void writeChecksummedBlock(uint8_t revisionNumber, uint8_t* data, uint16_t offset, uint16_t length) {
  uint16_t CRC = CRC16(data, length);
  eeprom_write_byte(&EEPromArray[offset], CRC&0xff);
  eeprom_write_byte(&EEPromArray[offset+1], CRC>>8);
  eeprom_write_byte(&EEPromArray[offset+2], revisionNumber);
  eeprom_write_block(data, &EEPromArray[offset+3], length);
}
 
// offset is where the checksum is stored, offset+1 is the revision number, and offset+2... are the data.
// length is the length of the pure data not including checksum and revision number.
uint8_t readChecksummedBlock(uint8_t revisionNumber, uint8_t* target, uint16_t offset, uint16_t length) {
  uint16_t CRCRead = eeprom_read_byte(&EEPromArray[offset]) | (eeprom_read_byte(&EEPromArray[offset+1])<<8);
  uint8_t revisionNumberRead = eeprom_read_byte(&EEPromArray[offset+2]);
  eeprom_read_block(target, &EEPromArray[offset+3], length);
  uint16_t CRCCalculated = CRC16(target, length);
 
  uint8_t CRCError = (CRCRead != CRCCalculated);
  uint8_t revisionMismatch = (revisionNumber != revisionNumberRead);
 
  if (CRCError && revisionMismatch) printf("\n\rEEPROM CRC error and revision mismatch; ");
  else if (CRCError) printf("\n\rEEPROM CRC error; ");
  else if (revisionMismatch) printf("\n\rEEPROM revision mismatch; ");
  return (CRCError || revisionMismatch);
}
 
/***************************************************/
/*       Read Parameter Set from EEPROM            */
/***************************************************/
// setnumber [1..5]
uint8_t paramSet_readFromEEProm(uint8_t setnumber) {
  uint16_t offset = EEPROM_ADR_PARAMSET_BEGIN + (setnumber-1)*(sizeof(ParamSet_t)+EEPROM_CHECKSUMMED_BLOCK_OVERHEAD);
  uint8_t result = readChecksummedBlock(EEPARAM_REVISION, (uint8_t*)&staticParams, offset, sizeof(ParamSet_t));
  configuration_paramSetDidChange();
  return result;
}
 
/***************************************************/
/*        Write Parameter Set to EEPROM            */
/***************************************************/
void paramSet_writeToEEProm(uint8_t setnumber) {
  uint16_t offset = EEPROM_ADR_PARAMSET_BEGIN + (setnumber-1)*(sizeof(ParamSet_t)+EEPROM_CHECKSUMMED_BLOCK_OVERHEAD);
  writeChecksummedBlock(EEPARAM_REVISION, (uint8_t*)&staticParams, offset, sizeof(ParamSet_t));
  // set this parameter set to active set
}
 
void paramSet_readOrDefault() {
  uint8_t setnumber = getActiveParamSet();
  // parameter version  check
  if (setnumber<1 ||setnumber>5 || paramSet_readFromEEProm(setnumber)) {
    // if version check faild
    printf("\n\rwriting default parameter sets");
    for (uint8_t i=5; i>0; i--) {
      paramSet_default(i);
      paramSet_writeToEEProm(i);
    }
    // default-Setting is parameter set 1
    setActiveParamSet(1);
    paramSet_readFromEEProm(getActiveParamSet());
    // For some strange reason, the read will have no effect.
    // Lets reset...
    // wdt_enable(WDTO_500MS);
  }
  printf("\n\r\rUsing Parameter Set %d", getActiveParamSet());
}
 
/***************************************************/
/*          Read IMU Config from EEPROM            */
/***************************************************/
uint8_t IMUConfig_readFromEEprom(void) {
  return readChecksummedBlock(IMUCONFIG_REVISION, (uint8_t*)&IMUConfig, EEPROM_ADR_IMU_CONFIG, sizeof(IMUConfig_t));
}
 
/***************************************************/
/*          Write IMU Config to EEPROM             */
/***************************************************/
void IMUConfig_writeToEEprom(void) {
  writeChecksummedBlock(IMUCONFIG_REVISION, (uint8_t*)&IMUConfig, EEPROM_ADR_IMU_CONFIG, sizeof(IMUConfig_t));
}
 
void IMUConfig_readOrDefault(void) {
    if(IMUConfig_readFromEEprom()) {
      printf("\n\rwriting default IMU config");
      IMUConfig_default();
      IMUConfig_writeToEEprom();
    }
}
 
/***************************************************/
/* MixerTable                                      */
/***************************************************/
void mixerMatrix_writeToEEProm(void) {
  writeChecksummedBlock(EEMIXER_REVISION, (uint8_t*)&mixerMatrix, EEPROM_ADR_MIXER_TABLE, sizeof(MixerMatrix_t));
}
 
void mixerMatrix_readOrDefault(void) {
  // load mixer table
  if (readChecksummedBlock(EEMIXER_REVISION, (uint8_t*)&mixerMatrix, EEPROM_ADR_MIXER_TABLE, sizeof(MixerMatrix_t))) {
    printf("\n\rwriting default mixerMatrix");
    mixerMatrix_default(); // Quadro
    mixerMatrix_writeToEEProm();
  }
  // determine motornumber
  requiredMotors = 0;
  for (uint8_t i=0; i<MAX_MOTORS; i++) {
    if (mixerMatrix.motor[i][MIX_THROTTLE])
      requiredMotors++;
  }
 
  printf("\n\rMixer-Config: '%s' (%u Motors)",mixerMatrix.name, requiredMotors);
  printf("\n\r===================================");
}
 
/***************************************************/
/* ChannelMap                                      */
/***************************************************/
void channelMap_writeToEEProm(void) {
  writeChecksummedBlock(CHANNELMAP_REVISION, (uint8_t*)&channelMap, EEPROM_ADR_CHANNELMAP, sizeof(ChannelMap_t));
}
 
void channelMap_readOrDefault(void) {
  if (readChecksummedBlock(CHANNELMAP_REVISION, (uint8_t*)&channelMap, EEPROM_ADR_CHANNELMAP, sizeof(ChannelMap_t))) {
    printf("\n\rwriting default channel map");
    channelMap_default();
    channelMap_writeToEEProm();
        wdt_enable(WDTO_500MS);
  }
}
 
/***************************************************/
/* Sensor offsets                                  */
/***************************************************/
uint8_t gyroAmplifierOffset_readFromEEProm(void) {
  return readChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&gyroAmplifierOffset, EEPROM_ADR_GYROAMPLIFIER, sizeof(sensorOffset_t));
}
 
void gyroAmplifierOffset_writeToEEProm(void) {
  return writeChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&gyroAmplifierOffset, EEPROM_ADR_GYROAMPLIFIER, sizeof(sensorOffset_t));
}
 
uint8_t gyroOffset_readFromEEProm(void) {
  return readChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&gyroOffset, EEPROM_ADR_GYROOFFSET, sizeof(sensorOffset_t));
}
 
void gyroOffset_writeToEEProm(void) {
  writeChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&gyroOffset, EEPROM_ADR_GYROOFFSET, sizeof(sensorOffset_t));
}
 
uint8_t accOffset_readFromEEProm(void) {
  return readChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&accOffset, EEPROM_ADR_ACCOFFSET, sizeof(sensorOffset_t));
}
 
void accOffset_writeToEEProm(void) {
  writeChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&accOffset, EEPROM_ADR_ACCOFFSET, sizeof(sensorOffset_t));
}
 
/***************************************************/
/*       Get active parameter set                  */
/***************************************************/
uint8_t getActiveParamSet(void) {
  uint8_t setnumber;
  setnumber = eeprom_read_byte(&EEPromArray[PID_ACTIVE_SET]);
  if (setnumber > 5) {
    setActiveParamSet(setnumber = 1);
  }
  return setnumber;
}
 
/***************************************************/
/*       Set active parameter set                  */
/***************************************************/
void setActiveParamSet(uint8_t setnumber) {
  eeprom_write_byte(&EEPromArray[PID_ACTIVE_SET], setnumber);
}
 
 

Subversion Repositories FlightCtrl

(root)/branches/dongfang_FC_rewrite/eeprom.c @ 2076 - Rev 2156 → 2157

Rev 2156		Rev 2157
1	#ifndef EEMEM	1	#ifndef EEMEM
2	#define EEMEM __attribute__ ((section (".eeprom")))	2	#define EEMEM __attribute__ ((section (".eeprom")))
3	#endif	3	#endif
4		4
5	#include "eeprom.h"	5	#include "eeprom.h"
6	#include "printf_P.h"	6	#include "printf_P.h"
7	#include "output.h"	7	#include "output.h"
-		8	#include "configuration.h"
8	#include <avr/wdt.h>	9	#include <avr/wdt.h>
9	#include <avr/eeprom.h>	10	#include <avr/eeprom.h>
10		11
11	// byte array in eeprom	12	// byte array in eeprom
12	uint8_t EEPromArray[E2END + 1] EEMEM;	13	uint8_t EEPromArray[E2END + 1] EEMEM;
13		14
14	/***************************************************/	15	/***************************************************/
15	/* Read Parameter from EEPROM as byte */	16	/* Read Parameter from EEPROM as byte */
16	/***************************************************/	17	/***************************************************/
17	uint8_t getParamByte(uint16_t param_id) {	18	uint8_t getParamByte(uint16_t param_id) {
18	return eeprom_read_byte(&EEPromArray[EEPROM_ADR_PARAM_BEGIN + param_id]);	19	return eeprom_read_byte(&EEPromArray[EEPROM_ADR_PARAM_BEGIN + param_id]);
19	}	20	}
20		21
21	/***************************************************/	22	/***************************************************/
22	/* Write Parameter to EEPROM as byte */	23	/* Write Parameter to EEPROM as byte */
23	/***************************************************/	24	/***************************************************/
24	void setParamByte(uint16_t param_id, uint8_t value) {	25	void setParamByte(uint16_t param_id, uint8_t value) {
25	eeprom_write_byte(&EEPromArray[EEPROM_ADR_PARAM_BEGIN + param_id], value);	26	eeprom_write_byte(&EEPromArray[EEPROM_ADR_PARAM_BEGIN + param_id], value);
26	}	27	}
27		28
28	/***************************************************/	29	/***************************************************/
29	/* Read Parameter from EEPROM as word */	30	/* Read Parameter from EEPROM as word */
30	/***************************************************/	31	/***************************************************/
31	/*	32	/*
32	uint16_t getParamWord(uint16_t param_id) {	33	uint16_t getParamWord(uint16_t param_id) {
33	return eeprom_read_word((uint16_t *) &EEPromArray[EEPROM_ADR_PARAM_BEGIN	34	return eeprom_read_word((uint16_t *) &EEPromArray[EEPROM_ADR_PARAM_BEGIN
34	+ param_id]);	35	+ param_id]);
35	}	36	}
36	*/	37	*/
37		38
38	/***************************************************/	39	/***************************************************/
39	/* Write Parameter to EEPROM as word */	40	/* Write Parameter to EEPROM as word */
40	/***************************************************/	41	/***************************************************/
41	/*	42	/*
42	void setParamWord(uint16_t param_id, uint16_t value) {	43	void setParamWord(uint16_t param_id, uint16_t value) {
43	eeprom_write_word((uint16_t *) &EEPromArray[EEPROM_ADR_PARAM_BEGIN + param_id], value);	44	eeprom_write_word((uint16_t *) &EEPromArray[EEPROM_ADR_PARAM_BEGIN + param_id], value);
44	}	45	}
45	*/	46	*/
46		47
47	uint16_t CRC16(uint8_t* data, uint16_t length) {	48	uint16_t CRC16(uint8_t* data, uint16_t length) {
48	uint16_t crc = 0;	49	uint16_t crc = 0;
49	for (uint16_t i=0; i<length; i++) {	50	for (uint16_t i=0; i<length; i++) {
50	crc = (uint8_t)(crc >> 8) \| (crc << 8);	51	crc = (uint8_t)(crc >> 8) \| (crc << 8);
51	crc ^= data[i];	52	crc ^= data[i];
52	crc ^= (uint8_t)(crc & 0xff) >> 4;	53	crc ^= (uint8_t)(crc & 0xff) >> 4;
53	crc ^= (crc << 8) << 4;	54	crc ^= (crc << 8) << 4;
54	crc ^= ((crc & 0xff) << 4) << 1;	55	crc ^= ((crc & 0xff) << 4) << 1;
55	}	56	}
56	return crc;	57	return crc;
57	}	58	}
58		59
59	// offset is where the checksum is stored, offset+1 is the revision number, and offset+2... are the data.	60	// offset is where the checksum is stored, offset+1 is the revision number, and offset+2... are the data.
60	// length is the length of the pure data not including checksum and revision number.	61	// length is the length of the pure data not including checksum and revision number.
61	void writeChecksummedBlock(uint8_t revisionNumber, uint8_t* data, uint16_t offset, uint16_t length) {	62	void writeChecksummedBlock(uint8_t revisionNumber, uint8_t* data, uint16_t offset, uint16_t length) {
62	uint16_t CRC = CRC16(data, length);	63	uint16_t CRC = CRC16(data, length);
63	eeprom_write_byte(&EEPromArray[offset], CRC&0xff);	64	eeprom_write_byte(&EEPromArray[offset], CRC&0xff);
64	eeprom_write_byte(&EEPromArray[offset+1], CRC>>8);	65	eeprom_write_byte(&EEPromArray[offset+1], CRC>>8);
65	eeprom_write_byte(&EEPromArray[offset+2], revisionNumber);	66	eeprom_write_byte(&EEPromArray[offset+2], revisionNumber);
66	eeprom_write_block(data, &EEPromArray[offset+3], length);	67	eeprom_write_block(data, &EEPromArray[offset+3], length);
67	}	68	}
68		69
69	// offset is where the checksum is stored, offset+1 is the revision number, and offset+2... are the data.	70	// offset is where the checksum is stored, offset+1 is the revision number, and offset+2... are the data.
70	// length is the length of the pure data not including checksum and revision number.	71	// length is the length of the pure data not including checksum and revision number.
71	uint8_t readChecksummedBlock(uint8_t revisionNumber, uint8_t* target, uint16_t offset, uint16_t length) {	72	uint8_t readChecksummedBlock(uint8_t revisionNumber, uint8_t* target, uint16_t offset, uint16_t length) {
72	uint16_t CRCRead = eeprom_read_byte(&EEPromArray[offset]) \| (eeprom_read_byte(&EEPromArray[offset+1])<<8);	73	uint16_t CRCRead = eeprom_read_byte(&EEPromArray[offset]) \| (eeprom_read_byte(&EEPromArray[offset+1])<<8);
73	uint8_t revisionNumberRead = eeprom_read_byte(&EEPromArray[offset+2]);	74	uint8_t revisionNumberRead = eeprom_read_byte(&EEPromArray[offset+2]);
74	eeprom_read_block(target, &EEPromArray[offset+3], length);	75	eeprom_read_block(target, &EEPromArray[offset+3], length);
75	uint16_t CRCCalculated = CRC16(target, length);	76	uint16_t CRCCalculated = CRC16(target, length);
76		77
77	uint8_t CRCError = (CRCRead != CRCCalculated);	78	uint8_t CRCError = (CRCRead != CRCCalculated);
78	uint8_t revisionMismatch = (revisionNumber != revisionNumberRead);	79	uint8_t revisionMismatch = (revisionNumber != revisionNumberRead);
79		80
80	if (CRCError && revisionMismatch) printf("\n\rEEPROM CRC error and revision mismatch; ");	81	if (CRCError && revisionMismatch) printf("\n\rEEPROM CRC error and revision mismatch; ");
81	else if (CRCError) printf("\n\rEEPROM CRC error; ");	82	else if (CRCError) printf("\n\rEEPROM CRC error; ");
82	else if (revisionMismatch) printf("\n\rEEPROM revision mismatch; ");	83	else if (revisionMismatch) printf("\n\rEEPROM revision mismatch; ");
83	return (CRCError \|\| revisionMismatch);	84	return (CRCError \|\| revisionMismatch);
84	}	85	}
85		86
86	/***************************************************/	87	/***************************************************/
87	/* Read Parameter Set from EEPROM */	88	/* Read Parameter Set from EEPROM */
88	/***************************************************/	89	/***************************************************/
89	// setnumber [1..5]	90	// setnumber [1..5]
90	uint8_t paramSet_readFromEEProm(uint8_t setnumber) {	91	uint8_t paramSet_readFromEEProm(uint8_t setnumber) {
91	uint16_t offset = EEPROM_ADR_PARAMSET_BEGIN + (setnumber-1)*(sizeof(ParamSet_t)+EEPROM_CHECKSUMMED_BLOCK_OVERHEAD);	92	uint16_t offset = EEPROM_ADR_PARAMSET_BEGIN + (setnumber-1)*(sizeof(ParamSet_t)+EEPROM_CHECKSUMMED_BLOCK_OVERHEAD);
92	uint8_t result = readChecksummedBlock(EEPARAM_REVISION, (uint8_t*)&staticParams, offset, sizeof(ParamSet_t));	93	uint8_t result = readChecksummedBlock(EEPARAM_REVISION, (uint8_t*)&staticParams, offset, sizeof(ParamSet_t));
93	configuration_paramSetDidChange();	94	configuration_paramSetDidChange();
94	return result;	95	return result;
95	}	96	}
96		97
97	/***************************************************/	98	/***************************************************/
98	/* Write Parameter Set to EEPROM */	99	/* Write Parameter Set to EEPROM */
99	/***************************************************/	100	/***************************************************/
100	void paramSet_writeToEEProm(uint8_t setnumber) {	101	void paramSet_writeToEEProm(uint8_t setnumber) {
101	uint16_t offset = EEPROM_ADR_PARAMSET_BEGIN + (setnumber-1)*(sizeof(ParamSet_t)+EEPROM_CHECKSUMMED_BLOCK_OVERHEAD);	102	uint16_t offset = EEPROM_ADR_PARAMSET_BEGIN + (setnumber-1)*(sizeof(ParamSet_t)+EEPROM_CHECKSUMMED_BLOCK_OVERHEAD);
102	writeChecksummedBlock(EEPARAM_REVISION, (uint8_t*)&staticParams, offset, sizeof(ParamSet_t));	103	writeChecksummedBlock(EEPARAM_REVISION, (uint8_t*)&staticParams, offset, sizeof(ParamSet_t));
103	// set this parameter set to active set	104	// set this parameter set to active set
104	}	105	}
105		106
106	void paramSet_readOrDefault() {	107	void paramSet_readOrDefault() {
107	uint8_t setnumber = getActiveParamSet();	108	uint8_t setnumber = getActiveParamSet();
108	// parameter version check	109	// parameter version check
109	if (setnumber<1 \|\|setnumber>5 \|\| paramSet_readFromEEProm(setnumber)) {	110	if (setnumber<1 \|\|setnumber>5 \|\| paramSet_readFromEEProm(setnumber)) {
110	// if version check faild	111	// if version check faild
111	printf("\n\rwriting default parameter sets");	112	printf("\n\rwriting default parameter sets");
112	for (uint8_t i=5; i>0; i--) {	113	for (uint8_t i=5; i>0; i--) {
113	paramSet_default(i);	114	paramSet_default(i);
114	paramSet_writeToEEProm(i);	115	paramSet_writeToEEProm(i);
115	}	116	}
116	// default-Setting is parameter set 1	117	// default-Setting is parameter set 1
117	setActiveParamSet(1);	118	setActiveParamSet(1);
118	paramSet_readFromEEProm(getActiveParamSet());	119	paramSet_readFromEEProm(getActiveParamSet());
119	// For some strange reason, the read will have no effect.	120	// For some strange reason, the read will have no effect.
120	// Lets reset...	121	// Lets reset...
121	// wdt_enable(WDTO_500MS);	122	// wdt_enable(WDTO_500MS);
122	}	123	}
123	printf("\n\r\rUsing Parameter Set %d", getActiveParamSet());	124	printf("\n\r\rUsing Parameter Set %d", getActiveParamSet());
124	}	125	}
125		126
126	/***************************************************/	127	/***************************************************/
127	/* Read IMU Config from EEPROM */	128	/* Read IMU Config from EEPROM */
128	/***************************************************/	129	/***************************************************/
129	uint8_t IMUConfig_readFromEEprom(void) {	130	uint8_t IMUConfig_readFromEEprom(void) {
130	return readChecksummedBlock(IMUCONFIG_REVISION, (uint8_t*)&IMUConfig, EEPROM_ADR_IMU_CONFIG, sizeof(IMUConfig_t));	131	return readChecksummedBlock(IMUCONFIG_REVISION, (uint8_t*)&IMUConfig, EEPROM_ADR_IMU_CONFIG, sizeof(IMUConfig_t));
131	}	132	}
132		133
133	/***************************************************/	134	/***************************************************/
134	/* Write IMU Config to EEPROM */	135	/* Write IMU Config to EEPROM */
135	/***************************************************/	136	/***************************************************/
136	void IMUConfig_writeToEEprom(void) {	137	void IMUConfig_writeToEEprom(void) {
137	writeChecksummedBlock(IMUCONFIG_REVISION, (uint8_t*)&IMUConfig, EEPROM_ADR_IMU_CONFIG, sizeof(IMUConfig_t));	138	writeChecksummedBlock(IMUCONFIG_REVISION, (uint8_t*)&IMUConfig, EEPROM_ADR_IMU_CONFIG, sizeof(IMUConfig_t));
138	}	139	}
139		140
140	void IMUConfig_readOrDefault(void) {	141	void IMUConfig_readOrDefault(void) {
141	if(IMUConfig_readFromEEprom()) {	142	if(IMUConfig_readFromEEprom()) {
142	printf("\n\rwriting default IMU config");	143	printf("\n\rwriting default IMU config");
143	IMUConfig_default();	144	IMUConfig_default();
144	IMUConfig_writeToEEprom();	145	IMUConfig_writeToEEprom();
145	}	146	}
146	}	147	}
147		148
148	/***************************************************/	149	/***************************************************/
149	/* MixerTable */	150	/* MixerTable */
150	/***************************************************/	151	/***************************************************/
151	void mixerMatrix_writeToEEProm(void) {	152	void mixerMatrix_writeToEEProm(void) {
152	writeChecksummedBlock(EEMIXER_REVISION, (uint8_t*)&mixerMatrix, EEPROM_ADR_MIXER_TABLE, sizeof(MixerMatrix_t));	153	writeChecksummedBlock(EEMIXER_REVISION, (uint8_t*)&mixerMatrix, EEPROM_ADR_MIXER_TABLE, sizeof(MixerMatrix_t));
153	}	154	}
154		155
155	void mixerMatrix_readOrDefault(void) {	156	void mixerMatrix_readOrDefault(void) {
156	// load mixer table	157	// load mixer table
157	if (readChecksummedBlock(EEMIXER_REVISION, (uint8_t*)&mixerMatrix, EEPROM_ADR_MIXER_TABLE, sizeof(MixerMatrix_t))) {	158	if (readChecksummedBlock(EEMIXER_REVISION, (uint8_t*)&mixerMatrix, EEPROM_ADR_MIXER_TABLE, sizeof(MixerMatrix_t))) {
158	printf("\n\rwriting default mixerMatrix");	159	printf("\n\rwriting default mixerMatrix");
159	mixerMatrix_default(); // Quadro	160	mixerMatrix_default(); // Quadro
160	mixerMatrix_writeToEEProm();	161	mixerMatrix_writeToEEProm();
161	}	162	}
162	// determine motornumber	163	// determine motornumber
163	requiredMotors = 0;	164	requiredMotors = 0;
164	for (uint8_t i=0; i<MAX_MOTORS; i++) {	165	for (uint8_t i=0; i<MAX_MOTORS; i++) {
165	if (mixerMatrix.motor[i][MIX_THROTTLE])	166	if (mixerMatrix.motor[i][MIX_THROTTLE])
166	requiredMotors++;	167	requiredMotors++;
167	}	168	}
168		169
169	printf("\n\rMixer-Config: '%s' (%u Motors)",mixerMatrix.name, requiredMotors);	170	printf("\n\rMixer-Config: '%s' (%u Motors)",mixerMatrix.name, requiredMotors);
170	printf("\n\r===================================");	171	printf("\n\r===================================");
171	}	172	}
172		173
173	/***************************************************/	174	/***************************************************/
174	/* ChannelMap */	175	/* ChannelMap */
175	/***************************************************/	176	/***************************************************/
176	void channelMap_writeToEEProm(void) {	177	void channelMap_writeToEEProm(void) {
177	writeChecksummedBlock(CHANNELMAP_REVISION, (uint8_t*)&channelMap, EEPROM_ADR_CHANNELMAP, sizeof(ChannelMap_t));	178	writeChecksummedBlock(CHANNELMAP_REVISION, (uint8_t*)&channelMap, EEPROM_ADR_CHANNELMAP, sizeof(ChannelMap_t));
178	}	179	}
179		180
180	void channelMap_readOrDefault(void) {	181	void channelMap_readOrDefault(void) {
181	if (readChecksummedBlock(CHANNELMAP_REVISION, (uint8_t*)&channelMap, EEPROM_ADR_CHANNELMAP, sizeof(ChannelMap_t))) {	182	if (readChecksummedBlock(CHANNELMAP_REVISION, (uint8_t*)&channelMap, EEPROM_ADR_CHANNELMAP, sizeof(ChannelMap_t))) {
182	printf("\n\rwriting default channel map");	183	printf("\n\rwriting default channel map");
183	channelMap_default();	184	channelMap_default();
184	channelMap_writeToEEProm();	185	channelMap_writeToEEProm();
185	wdt_enable(WDTO_500MS);	186	wdt_enable(WDTO_500MS);
186	}	187	}
187	}	188	}
188		189
189	/***************************************************/	190	/***************************************************/
190	/* Sensor offsets */	191	/* Sensor offsets */
191	/***************************************************/	192	/***************************************************/
192	uint8_t gyroAmplifierOffset_readFromEEProm(void) {	193	uint8_t gyroAmplifierOffset_readFromEEProm(void) {
193	return readChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&gyroAmplifierOffset, EEPROM_ADR_GYROAMPLIFIER, sizeof(sensorOffset_t));	194	return readChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&gyroAmplifierOffset, EEPROM_ADR_GYROAMPLIFIER, sizeof(sensorOffset_t));
194	}	195	}
195		196
196	void gyroAmplifierOffset_writeToEEProm(void) {	197	void gyroAmplifierOffset_writeToEEProm(void) {
197	return writeChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&gyroAmplifierOffset, EEPROM_ADR_GYROAMPLIFIER, sizeof(sensorOffset_t));	198	return writeChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&gyroAmplifierOffset, EEPROM_ADR_GYROAMPLIFIER, sizeof(sensorOffset_t));
198	}	199	}
199		200
200	uint8_t gyroOffset_readFromEEProm(void) {	201	uint8_t gyroOffset_readFromEEProm(void) {
201	return readChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&gyroOffset, EEPROM_ADR_GYROOFFSET, sizeof(sensorOffset_t));	202	return readChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&gyroOffset, EEPROM_ADR_GYROOFFSET, sizeof(sensorOffset_t));
202	}	203	}
203		204
204	void gyroOffset_writeToEEProm(void) {	205	void gyroOffset_writeToEEProm(void) {
205	writeChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&gyroOffset, EEPROM_ADR_GYROOFFSET, sizeof(sensorOffset_t));	206	writeChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&gyroOffset, EEPROM_ADR_GYROOFFSET, sizeof(sensorOffset_t));
206	}	207	}
207		208
208	uint8_t accOffset_readFromEEProm(void) {	209	uint8_t accOffset_readFromEEProm(void) {
209	return readChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&accOffset, EEPROM_ADR_ACCOFFSET, sizeof(sensorOffset_t));	210	return readChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&accOffset, EEPROM_ADR_ACCOFFSET, sizeof(sensorOffset_t));
210	}	211	}
211		212
212	void accOffset_writeToEEProm(void) {	213	void accOffset_writeToEEProm(void) {
213	writeChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&accOffset, EEPROM_ADR_ACCOFFSET, sizeof(sensorOffset_t));	214	writeChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&accOffset, EEPROM_ADR_ACCOFFSET, sizeof(sensorOffset_t));
214	}	215	}
215		216
216	/***************************************************/	217	/***************************************************/
217	/* Get active parameter set */	218	/* Get active parameter set */
218	/***************************************************/	219	/***************************************************/
219	uint8_t getActiveParamSet(void) {	220	uint8_t getActiveParamSet(void) {
220	uint8_t setnumber;	221	uint8_t setnumber;
221	setnumber = eeprom_read_byte(&EEPromArray[PID_ACTIVE_SET]);	222	setnumber = eeprom_read_byte(&EEPromArray[PID_ACTIVE_SET]);
222	if (setnumber > 5) {	223	if (setnumber > 5) {
223	setActiveParamSet(setnumber = 1);	224	setActiveParamSet(setnumber = 1);
224	}	225	}
225	return setnumber;	226	return setnumber;
226	}	227	}
227		228
228	/***************************************************/	229	/***************************************************/
229	/* Set active parameter set */	230	/* Set active parameter set */
230	/***************************************************/	231	/***************************************************/
231	void setActiveParamSet(uint8_t setnumber) {	232	void setActiveParamSet(uint8_t setnumber) {
232	eeprom_write_byte(&EEPromArray[PID_ACTIVE_SET], setnumber);	233	eeprom_write_byte(&EEPromArray[PID_ACTIVE_SET], setnumber);
233	}	234	}
234		235
235		236