WebSVN - FlightCtrl - Diff - Rev 2132 and 2141 - /branches/dongfang_FC


#ifndef EEMEM
#define EEMEM __attribute__ ((section (".eeprom")))
#endif
 
#include "eeprom.h"
#include "printf_P.h"
#include "output.h"
#include "rc.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() {
  // parameter version  check
  if (paramSet_readFromEEProm(1)) {
    // 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
    paramSet_readFromEEProm(1);
    // For some strange reason, the read will have no effect.
    // Lets reset...
    // wdt_enable(WDTO_500MS);
  }
  printf("\n\r\rUsing Parameter Set %d", 1);
}
 
/***************************************************/
/*          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();
    }
}
 
/***************************************************/
/* ChannelMap and R/C trim                         */
/***************************************************/
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();
  }
}
 
void rcTrim_writeToEEProm(void) {
  writeChecksummedBlock(0, (uint8_t*)&rcTrim, EEPROM_ADR_RCTRIM, sizeof(RCTrim_t));
}
 
void rcTrim_readOrDefault(void) {
  if (readChecksummedBlock(0, (uint8_t*)&rcTrim, EEPROM_ADR_RCTRIM, sizeof(RCTrim_t))) {
    printf("\n\rwriting zero RC trim");
    RC_setZeroTrim();
    rcTrim_writeToEEProm();
  }
}
 
/***************************************************/
/* Sensor offsets                                  */
/***************************************************/
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 airpressureOffset_readFromEEProm(void) {
  return readChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&airpressureOffset, EEPROM_ADR_AIRSPEEDOFFSET, sizeof(uint16_t));
}
 
void airpressureOffset_writeToEEProm(void) {
  writeChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&airpressureOffset, EEPROM_ADR_AIRSPEEDOFFSET, sizeof(uint16_t));
}
 

Subversion Repositories FlightCtrl

(root)/branches/dongfang_FC_fixedwing/eeprom.c @ 2207 - Rev 2132 → 2141

Rev 2132		Rev 2141
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 "rc.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	// parameter version check	108	// parameter version check
108	if (paramSet_readFromEEProm(1)) {	109	if (paramSet_readFromEEProm(1)) {
109	// if version check faild	110	// if version check faild
110	printf("\n\rwriting default parameter sets");	111	printf("\n\rwriting default parameter sets");
111	for (uint8_t i=5; i>0; i--) {	112	for (uint8_t i=5; i>0; i--) {
112	paramSet_default(i);	113	paramSet_default(i);
113	paramSet_writeToEEProm(i);	114	paramSet_writeToEEProm(i);
114	}	115	}
115	// default-Setting is parameter set 1	116	// default-Setting is parameter set 1
116	paramSet_readFromEEProm(1);	117	paramSet_readFromEEProm(1);
117	// For some strange reason, the read will have no effect.	118	// For some strange reason, the read will have no effect.
118	// Lets reset...	119	// Lets reset...
119	// wdt_enable(WDTO_500MS);	120	// wdt_enable(WDTO_500MS);
120	}	121	}
121	printf("\n\r\rUsing Parameter Set %d", 1);	122	printf("\n\r\rUsing Parameter Set %d", 1);
122	}	123	}
123		124
124	/***************************************************/	125	/***************************************************/
125	/* Read IMU Config from EEPROM */	126	/* Read IMU Config from EEPROM */
126	/***************************************************/	127	/***************************************************/
127	uint8_t IMUConfig_readFromEEprom(void) {	128	uint8_t IMUConfig_readFromEEprom(void) {
128	return readChecksummedBlock(IMUCONFIG_REVISION, (uint8_t*)&IMUConfig, EEPROM_ADR_IMU_CONFIG, sizeof(IMUConfig_t));	129	return readChecksummedBlock(IMUCONFIG_REVISION, (uint8_t*)&IMUConfig, EEPROM_ADR_IMU_CONFIG, sizeof(IMUConfig_t));
129	}	130	}
130		131
131	/***************************************************/	132	/***************************************************/
132	/* Write IMU Config to EEPROM */	133	/* Write IMU Config to EEPROM */
133	/***************************************************/	134	/***************************************************/
134	void IMUConfig_writeToEEprom(void) {	135	void IMUConfig_writeToEEprom(void) {
135	writeChecksummedBlock(IMUCONFIG_REVISION, (uint8_t*)&IMUConfig, EEPROM_ADR_IMU_CONFIG, sizeof(IMUConfig_t));	136	writeChecksummedBlock(IMUCONFIG_REVISION, (uint8_t*)&IMUConfig, EEPROM_ADR_IMU_CONFIG, sizeof(IMUConfig_t));
136	}	137	}
137		138
138	void IMUConfig_readOrDefault(void) {	139	void IMUConfig_readOrDefault(void) {
139	if(IMUConfig_readFromEEprom()) {	140	if(IMUConfig_readFromEEprom()) {
140	printf("\n\rwriting default IMU config");	141	printf("\n\rwriting default IMU config");
141	IMUConfig_default();	142	IMUConfig_default();
142	IMUConfig_writeToEEprom();	143	IMUConfig_writeToEEprom();
143	}	144	}
144	}	145	}
145		146
146	/***************************************************/	147	/***************************************************/
147	/* ChannelMap and R/C trim */	148	/* ChannelMap and R/C trim */
148	/***************************************************/	149	/***************************************************/
149	void channelMap_writeToEEProm(void) {	150	void channelMap_writeToEEProm(void) {
150	writeChecksummedBlock(CHANNELMAP_REVISION, (uint8_t*)&channelMap, EEPROM_ADR_CHANNELMAP, sizeof(ChannelMap_t));	151	writeChecksummedBlock(CHANNELMAP_REVISION, (uint8_t*)&channelMap, EEPROM_ADR_CHANNELMAP, sizeof(ChannelMap_t));
151	}	152	}
152		153
153	void channelMap_readOrDefault(void) {	154	void channelMap_readOrDefault(void) {
154	if (readChecksummedBlock(CHANNELMAP_REVISION, (uint8_t*)&channelMap, EEPROM_ADR_CHANNELMAP, sizeof(ChannelMap_t))) {	155	if (readChecksummedBlock(CHANNELMAP_REVISION, (uint8_t*)&channelMap, EEPROM_ADR_CHANNELMAP, sizeof(ChannelMap_t))) {
155	printf("\n\rwriting default channel map");	156	printf("\n\rwriting default channel map");
156	channelMap_default();	157	channelMap_default();
157	channelMap_writeToEEProm();	158	channelMap_writeToEEProm();
158	}	159	}
159	}	160	}
160		161
161	void rcTrim_writeToEEProm(void) {	162	void rcTrim_writeToEEProm(void) {
162	writeChecksummedBlock(0, (uint8_t*)&rcTrim, EEPROM_ADR_RCTRIM, sizeof(RCTrim_t));	163	writeChecksummedBlock(0, (uint8_t*)&rcTrim, EEPROM_ADR_RCTRIM, sizeof(RCTrim_t));
163	}	164	}
164		165
165	void rcTrim_readOrDefault(void) {	166	void rcTrim_readOrDefault(void) {
166	if (readChecksummedBlock(0, (uint8_t*)&rcTrim, EEPROM_ADR_RCTRIM, sizeof(RCTrim_t))) {	167	if (readChecksummedBlock(0, (uint8_t*)&rcTrim, EEPROM_ADR_RCTRIM, sizeof(RCTrim_t))) {
167	printf("\n\rwriting zero RC trim");	168	printf("\n\rwriting zero RC trim");
168	RC_setZeroTrim();	169	RC_setZeroTrim();
169	rcTrim_writeToEEProm();	170	rcTrim_writeToEEProm();
170	}	171	}
171	}	172	}
172		173
173	/***************************************************/	174	/***************************************************/
174	/* Sensor offsets */	175	/* Sensor offsets */
175	/***************************************************/	176	/***************************************************/
176	uint8_t gyroOffset_readFromEEProm(void) {	177	uint8_t gyroOffset_readFromEEProm(void) {
177	return readChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&gyroOffset, EEPROM_ADR_GYROOFFSET, sizeof(sensorOffset_t));	178	return readChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&gyroOffset, EEPROM_ADR_GYROOFFSET, sizeof(sensorOffset_t));
178	}	179	}
179		180
180	void gyroOffset_writeToEEProm(void) {	181	void gyroOffset_writeToEEProm(void) {
181	writeChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&gyroOffset, EEPROM_ADR_GYROOFFSET, sizeof(sensorOffset_t));	182	writeChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&gyroOffset, EEPROM_ADR_GYROOFFSET, sizeof(sensorOffset_t));
182	}	183	}
183		184
184	uint8_t airpressureOffset_readFromEEProm(void) {	185	uint8_t airpressureOffset_readFromEEProm(void) {
185	return readChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&airpressureOffset, EEPROM_ADR_AIRSPEEDOFFSET, sizeof(uint16_t));	186	return readChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&airpressureOffset, EEPROM_ADR_AIRSPEEDOFFSET, sizeof(uint16_t));
186	}	187	}
187		188
188	void airpressureOffset_writeToEEProm(void) {	189	void airpressureOffset_writeToEEProm(void) {
189	writeChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&airpressureOffset, EEPROM_ADR_AIRSPEEDOFFSET, sizeof(uint16_t));	190	writeChecksummedBlock(SENSOROFFSET_REVISION, (uint8_t*)&airpressureOffset, EEPROM_ADR_AIRSPEEDOFFSET, sizeof(uint16_t));
190	}	191	}
191		192