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


#ifndef EEMEM
#define EEMEM __attribute__ ((section (".eeprom")))
#endif
 
#include "eeprom.h"
#include "printf_P.h"
#include "output.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 @ 2751 - Rev 2092 → 2156

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