WebSVN - FlightCtrl - Diff - Rev 2157 and 2158 - /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 motorMixer_writeToEEProm(void) {
  writeChecksummedBlock(EEMIXER_REVISION, (uint8_t*)&motorMixer, EEPROM_ADR_MIXER_TABLE, sizeof(MotorMixer_t));
}
 
void motorMixer_readOrDefault(void) {
  // load mixer table
  if (readChecksummedBlock(EEMIXER_REVISION, (uint8_t*)&motorMixer, EEPROM_ADR_MIXER_TABLE, sizeof(MotorMixer_t))) {
    printf("\n\rwriting default motor mixer");
    motorMixer_default(); // Quadro
    motorMixer_writeToEEProm();
  }
  // determine motornumber
  requiredMotors = 0;
  for (uint8_t i=0; i<MAX_MOTORS; i++) {
    if (motorMixer.matrix[i][MIX_THROTTLE])
      requiredMotors++;
  }
 
  printf("\n\rMixer-Config: '%s' (%u Motors)", motorMixer.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 @ 2117 - Rev 2157 → 2158

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