WebSVN - FlightCtrl - Diff - Rev 2158 and 2164 - /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>
#include <avr/interrupt.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);
  uint8_t sreg = SREG;
  cli();
  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);
  SREG = sreg;
}
 
// 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));
 
}
 
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 @ 1877 - Rev 2158 → 2164

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