/*
* EEPROM Quick macro reading
*/
uchar usbFunctionRead(uchar *data, uchar len)
{
uchar i = len;
usbMsgPtr_t r = usbMsgPtr;
/* EEPROM data */
/*do{
uchar c = eeprom_read_byte(r);
*data++ = c;
r++;
}while(--i);*/
eeprom_read_block(data, (void *)r, i);
usbMsgPtr = r + i;
return len;
}
void lcd_material_set_material(uint8_t nr, uint8_t e)
{
material[e].temperature = eeprom_read_word(EEPROM_MATERIAL_TEMPERATURE_OFFSET(nr));
material[e].bed_temperature = eeprom_read_word(EEPROM_MATERIAL_BED_TEMPERATURE_OFFSET(nr));
material[e].flow = eeprom_read_word(EEPROM_MATERIAL_FLOW_OFFSET(nr));
material[e].fan_speed = eeprom_read_byte(EEPROM_MATERIAL_FAN_SPEED_OFFSET(nr));
material[e].diameter = eeprom_read_float(EEPROM_MATERIAL_DIAMETER_OFFSET(nr));
eeprom_read_block(material_name[e], EEPROM_MATERIAL_NAME_OFFSET(nr), MATERIAL_NAME_LENGTH);
material_name[e][MATERIAL_NAME_LENGTH] = '\0';
if (material[e].temperature > HEATER_0_MAXTEMP - 15)
material[e].temperature = HEATER_0_MAXTEMP - 15;
if (material[e].bed_temperature > BED_MAXTEMP - 15)
material[e].bed_temperature = BED_MAXTEMP - 15;
lcd_material_store_current_material();
}
bool EeFsOpen()
{
eeprom_read_block((uint8_t *)&eeFs, 0, sizeof(eeFs));
#ifdef SIMU
if (eeFs.version != EEFS_VERS) {
printf("bad eeFs.version (%d instead of %d)\n", eeFs.version, EEFS_VERS);
fflush(stdout);
}
if (eeFs.mySize != sizeof(eeFs)) {
printf("bad eeFs.mySize (%d instead of %d)\n", (int)eeFs.mySize, (int)sizeof(eeFs));
fflush(stdout);
}
#endif
return eeFs.version == EEFS_VERS && eeFs.mySize == sizeof(eeFs);
}
static char* lcd_material_select_callback(uint8_t nr)
{
uint8_t count = eeprom_read_byte(EEPROM_MATERIAL_COUNT_OFFSET());
if (nr == 0)
strcpy_P(card.longFilename, PSTR("< RETURN"));
else if (nr == count + 1)
strcpy_P(card.longFilename, PSTR("Customize"));
else if (nr == count + 2)
strcpy_P(card.longFilename, PSTR("Export to SD"));
else if (nr == count + 3)
strcpy_P(card.longFilename, PSTR("Import from SD"));
else{
eeprom_read_block(card.longFilename, EEPROM_MATERIAL_NAME_OFFSET(nr - 1), 8);
card.longFilename[8] = '\0';
}
return card.longFilename;
}
//*******************************************************************************************
//
// Function : menu_init
// Description : initial I/O direction for all key,
// initial timer1 for countdown timer
//
//*******************************************************************************************
void menu_init ( void )
{
// setup countdown initial value
sec_count = 0;
eeprom_read_block ( count_time, ee_count_time, 3 );
count_time[3] = 0;
// setup menu and standby display
flag1.byte = 0;
flag2.byte = 0;
menu_index = 0;
submenu_index = 0;
menu_stack = 0;
submenu_stack = 0;
setting_cursor = 0;
standby_cursor = 1;
}
uint8_t MixerTable_ReadFromEEProm(void)
{
uint8_t crc;
// calculate checksum in eeprom
crc = EEProm_Checksum(EEPROM_ADR_MIXERTABLE, sizeof(Mixer) - 1);
// check crc
if( crc != eeprom_read_byte((uint8_t*)(EEPROM_ADR_MIXERTABLE + sizeof(Mixer) - 1)) ) return 0;
// check revision
if(eeprom_read_byte((uint8_t*)(EEPROM_ADR_MIXERTABLE)) != EEMIXER_REVISION) return 0;
// read mixer table
eeprom_read_block((void *) &Mixer, (void*)(EEPROM_ADR_MIXERTABLE), sizeof(Mixer));
return 1;
}
void lcd_material_read_current_material()
{
for(uint8_t e=0; e<EXTRUDERS; e++)
{
material[e].temperature = eeprom_read_word(EEPROM_MATERIAL_TEMPERATURE_OFFSET(EEPROM_MATERIAL_SETTINGS_MAX_COUNT+e));
material[e].bed_temperature = eeprom_read_word(EEPROM_MATERIAL_BED_TEMPERATURE_OFFSET(EEPROM_MATERIAL_SETTINGS_MAX_COUNT+e));
material[e].flow = eeprom_read_word(EEPROM_MATERIAL_FLOW_OFFSET(EEPROM_MATERIAL_SETTINGS_MAX_COUNT+e));
material[e].fan_speed = eeprom_read_byte(EEPROM_MATERIAL_FAN_SPEED_OFFSET(EEPROM_MATERIAL_SETTINGS_MAX_COUNT+e));
material[e].diameter = eeprom_read_float(EEPROM_MATERIAL_DIAMETER_OFFSET(EEPROM_MATERIAL_SETTINGS_MAX_COUNT+e));
strcpy_P(material_name[e],PSTR("???"));
eeprom_read_block(material_name[e], EEPROM_MATERIAL_NAME_OFFSET(EEPROM_MATERIAL_SETTINGS_MAX_COUNT+e), MATERIAL_NAME_LENGTH);
material_name[e][MATERIAL_NAME_LENGTH] = '\0';
}
}
void load_events()
{
// initialize random number generator; it has to be done only once (after reset)
srand(current_time());
events_count = eeprom_read_byte(&events_count_ee);
// initialize - for testing purposes
/*
if (events_count == 0)
{
send_string("add_default\r\n");
add_default_events();
}
*/
if (events_count == 0)
{
send_line("No events => MANUAL_MODE");
event_mode = MANUAL_MODE;
return;
}
// load events into ram
eeprom_read_block(&events, &events_ee, sizeof(struct Event) * EVENTS_SIZE);
// prepare
prepare_actual_events();
// print events
print_events();
// check current state of pins
// if the device is power off, and later power on - it doesn't know what should be current state of pins
int32_t time = current_time();
send_string(" start time: ");
char formatted_date[30];
timeToString(time, formatted_date);
send_string(formatted_date);
send_enter();
current_state();
}
int main(int argc, const char *argv[])
{
// Point stdout to serial stream (for testing to see adc value)
stdout = &mystdout;
// Initialize usart
init_usart(BAUDRATE, TRANSMIT_RATE, DATA_BITS, STOP_BITS, PARITY_BITS);
// printf("The first recipe is shown below!\n\n\n");
char recipe_name[RECIPE_NAME_LENGTH];
eeprom_read_block((void*)&recipe_name, (const void*)0x00, RECIPE_NAME_LENGTH);
printf("Recipe Name: '%s'\n", recipe_name);
return 0;
}
// declares config and config_EEPROM
CFG_DECLARATION
#define enableUsbLines() PORTD |= (1<<0)
#define disableUsbLines() PORTD &= ~(1<<0);
void readConfig(uint8_t newConfig[CONFIG_BYTE_WIDTH + 2]) {
// read config from EEPROM
eeprom_read_block(config, config_EEPROM, CONFIG_BYTE_WIDTH + 2);
if(config[0] != CONFIG_DEVICE || config[1] != CONFIG_VERSION) {
/* if EEPROM does not conform to current version and device set to default config */
CONFIG_SET_DEFAULTS(newConfig)
}
else {
for(int i = 0; i < (CONFIG_BYTE_WIDTH + 2); i++)
newConfig[i] = config[i];
}
}
// Return the key for a variable.
//
AP_Var::Key
AP_Var::key(void)
{
Var_header var_header;
if (_group) { // group members don't have keys
return k_key_none;
}
if (_key && k_key_not_located) { // if not located, key is in memory
return _key & k_key_mask;
}
// Read key from EEPROM, note that _key points to the space
// allocated for storage; the header is immediately before.
//
eeprom_read_block(&var_header, (void *)(_key - sizeof(var_header)), sizeof(var_header));
return var_header.key;
}
int
main (void)
{
term_io_init ();
// Delay a bit at startup to give use time to launch screen and watch the
// initial values of thigs after reprogramming or changing the ID.
_delay_ms (3042);
for ( ; ; ) {
void const *id_address = 0; // ID is at start of EEPROM
size_t const id_size = 8; // ID is this many bytes long
uint64_t id; // ID itself (to be read)
eeprom_read_block (&id, id_address, id_size);
// Print the ID value one byte at a time. WARNING: endianness can cause
// confusion when you interpret id as a single uint64_t. For example,
// if your ID happens to be 0x0123456789abcdef, then to declare a
// literal uint64_t that will compare equal to it you would need to write
// '0xefcdab8967452301ULL' (or 'UINT64_C (0xefcdab8967452301)' if you're
// using the better integer literal macros from stdint.h). WARNING:
// also, AVR libc doesn't support 64 bit printf/scanf conversions.
printf ("ID: ");
for ( uint8_t ii = 0 ; ii < id_size ; ii++ ) {
printf ("%02" PRIx8, ((uint8_t *) (&id))[ii] );
}
printf ("\n");
// This block is used to verify that writing the first 8 bytes of the
// flash doesn't change the others: after running this program, then
// changing the ID with the make target, then restarting this program,
// the value should still be 42 the first time we hit this point.
uint8_t *byte_8_offset = (uint8_t *) 8;
uint8_t byte_offset_8_value = eeprom_read_byte (byte_8_offset);
printf (
"Current value of byte at offset 8: %" PRIu8 "\n",
byte_offset_8_value );
eeprom_write_byte (byte_8_offset, 42);
_delay_ms (1042); // Delay a little bit between repetitions of the ID
}
}
int main(void)
{
wdt_disable();
/* Clear WDRF in MCUSR */
MCUSR &= ~(1<<WDRF);
/* Write logical one to WDCE and WDE */
/* Keep old prescaler setting to prevent unintentional time-out */
WDTCSR |= (1<<WDCE) | (1<<WDE);
/* Turn off WDT */
WDTCSR = 0x00;
//DDRA |= 0x07;
//PORTA &= ~7;
//DDRC |= 0x07;
//DDRC |= 0xC0;
eeprom_read_block(&state, &state_ee, sizeof(state));
aes_handler_init();
bus_handler_init();
serial_init();
bus_init();
cmd_init();
buttons_init();
leds_init();
timer0_init();
sei();
leds_set(0,LED_SHORT_FLASH);
while( 1 ){
if( timer0_timebase ){
timer0_timebase--;
bus_tick();
serial_tick();
buttons_tick();
leds_tick();
}
bus_process();
serial_process();
//aes128_enc(data, &ctx); /* encrypting the data block */
}
}
bool lcd_material_verify_material_settings()
{
SERIAL_ECHO_START;
uint8_t max_mats = eeprom_read_byte(EEPROM_MATERIAL_COUNT_OFFSET());
SERIAL_ECHOPAIR("Checking ", (unsigned long) max_mats);
SERIAL_ECHOPAIR(" presets and ", (unsigned long) EXTRUDERS);
SERIAL_ECHOLNPGM (" extruder settings:");
if (max_mats < 2 || max_mats > EEPROM_MATERIAL_SETTINGS_MAX_COUNT)
return false;
byte cnt =0;
while(cnt < max_mats+EXTRUDERS)
{
SERIAL_ECHOPAIR("Checking preset # ",(unsigned long) cnt);
if (eeprom_read_word(EEPROM_MATERIAL_TEMPERATURE_OFFSET(cnt)) > HEATER_0_MAXTEMP)
return false;
if (eeprom_read_word(EEPROM_MATERIAL_BED_TEMPERATURE_OFFSET(cnt)) > BED_MAXTEMP)
return false;
if (eeprom_read_byte(EEPROM_MATERIAL_FAN_SPEED_OFFSET(cnt)) > 100)
return false;
if (eeprom_read_word(EEPROM_MATERIAL_FLOW_OFFSET(cnt)) > 1000)
return false;
if (eeprom_read_float(EEPROM_MATERIAL_DIAMETER_OFFSET(cnt)) > 10.0)
return false;
if (eeprom_read_float(EEPROM_MATERIAL_DIAMETER_OFFSET(cnt)) < 0.1)
return false;
strcpy_P (material_name_buf,"???");
eeprom_read_block(material_name_buf, EEPROM_MATERIAL_NAME_OFFSET(cnt), MATERIAL_NAME_LENGTH);
material_name_buf[MATERIAL_NAME_LENGTH] = '\0';
if (cnt >= max_mats )
{ SERIAL_ECHOPAIR(".....verified extruder setting # ",(unsigned long) cnt-max_mats);}
else
{ SERIAL_ECHOPAIR(".....verified preset # ",(unsigned long) cnt);}
SERIAL_ECHO(" (");
SERIAL_ECHO(material_name_buf);
SERIAL_ECHO(")");
SERIAL_ECHOLN("");
cnt++;
}
return true;
}
void send_packet(uint8_t aes_key_nr, uint8_t data_len)
{
// set device ID (base station has ID 0 by definition)
bufx[0] = 0;
// update packet counter
packetcounter++;
if (packetcounter % PACKET_COUNTER_WRITE_CYCLE == 0)
{
eeprom_write_dword((uint32_t*)0, packetcounter);
}
setBuf32(1, packetcounter);
// set CRC32
uint32_t crc = crc32(bufx, data_len + 6);
setBuf32(data_len + 6, crc);
// load AES key (0 is first AES key)
if (aes_key_nr >= AES_KEY_EEPROM_COUNT)
{
aes_key_nr = AES_KEY_EEPROM_COUNT - 1;
}
eeprom_read_block (aes_key, (uint8_t *)(EEPROM_POS_AES_KEY + aes_key_nr * 32), 32);
// show info
decode_data(data_len + 6);
UART_PUTF(" AES key: %u\r\n", aes_key_nr);
UART_PUTF(" CRC32: %02lx\r\n", crc);
UART_PUTS(" Unencrypted: ");
printbytearray(bufx, data_len + 10);
// encrypt and send
uint8_t aes_byte_count = rfm12_sendbuf(data_len + 10);
UART_PUTS("Send encrypted: ");
printbytearray(bufx, aes_byte_count);
UART_PUTS("\r\n");
}
char GenerateStandaloneTransData(char xPumpID, char *PNozzle){//[1,2,3..16]->[1,2,3..0]
char ProductName[15];//,strPPU[7],strPVolume[8],strPMoney[8];
char iPumpID,iProdID=0,TermID;//,PPumpID[8];
char Result=GS_NONE;
char strSend[30];
char FIPAddr;
iPumpID=(xPumpID&0x0F);
FIPAddr=GetFIPAddr(iPumpID);
if (FIPAddr>0){
FIPAddr=FIPAddr-1;
iProdID=PNozzle[RecPumpData[FIPAddr].Grade];
if (iProdID>0) eeprom_read_block((void*) &ProductName, (const void*) &DefProductName[iProdID-1],sizeof(DefProductName[iProdID-1]));
else sprintf_P(ProductName,PSTR("N/A"));
TermID=eeprom_read_byte(&DefIFT_ID);
//Shift,TransNum,Date,Time
sprintf_P(strShift,PSTR("%d"),RecPumpData[FIPAddr].Shift);
sprintf_P(strTranNo,PSTR("%s"),RecPumpData[FIPAddr].strTransNum);
sprintf_P(strDate,PSTR("%s"),RecPumpData[FIPAddr].strTransDate);
sprintf_P(strTime,PSTR("%s"),RecPumpData[FIPAddr].strTransTime);
//TermID,FIP_ID,Product
sprintf_P(strIslandID,PSTR("%d"),TermID);
sprintf_P(strFIP_ID,PSTR("%.2d"),xPumpID);
sprintf_P(strDescription,PSTR("%s"),ProductName);
//Price Volume Money
sprintf_P(strPrice,PSTR("%s"),RecPumpData[FIPAddr].Price);
sprintf_P(strVolume,PSTR("%s"),RecPumpData[FIPAddr].Volume);
sprintf_P(strAmount,PSTR("%s"),RecPumpData[FIPAddr].Money);
MOPType=MOP_CASH;
IsPrinting=True;
Result=GS_GENERATED;
}
//ProductName
//iProdID=PNozzle[RecPumpData[iPumpID].Nozzle];
//BAsedOnGrade
return Result;
}
// Load the variable from EEPROM, if supported
//
bool AP_Param::load(void)
{
uint8_t group_element = 0;
const struct GroupInfo *ginfo;
uint8_t idx;
const struct AP_Param::Info *info = find_var_info(&group_element, &ginfo, &idx);
if (info == NULL) {
// we don't have any info on how to load it
return false;
}
struct Param_header phdr;
// create the header we will use to match the variable
if (ginfo != NULL) {
phdr.type = PGM_UINT8(&ginfo->type);
} else {
phdr.type = PGM_UINT8(&info->type);
}
phdr.key = PGM_UINT8(&info->key);
phdr.group_element = group_element;
// scan EEPROM to find the right location
uint16_t ofs;
if (!scan(&phdr, &ofs)) {
return false;
}
if (phdr.type != AP_PARAM_VECTOR3F && idx != 0) {
// only vector3f can have non-zero idx for now
return false;
}
AP_Param *ap;
ap = this;
if (idx != 0) {
ap = (AP_Param *)((uintptr_t)ap) - (idx*sizeof(float));
}
// found it
eeprom_read_block(ap, (void*)(ofs+sizeof(phdr)), type_size((enum ap_var_type)phdr.type));
return true;
}
bool lcd_material_verify_material_settings()
{
bool hasUPET = false;
uint8_t cnt = eeprom_read_byte(EEPROM_MATERIAL_COUNT_OFFSET());
if (cnt < 2 || cnt > EEPROM_MATERIAL_SETTINGS_MAX_COUNT)
return false;
while(cnt > 0)
{
cnt --;
if (eeprom_read_word(EEPROM_MATERIAL_TEMPERATURE_OFFSET(cnt)) > HEATER_0_MAXTEMP)
return false;
// if (eeprom_read_word(EEPROM_MATERIAL_BED_TEMPERATURE_OFFSET(cnt)) > BED_MAXTEMP)
// return false;
if (eeprom_read_byte(EEPROM_MATERIAL_FAN_SPEED_OFFSET(cnt)) > 100)
return false;
if (eeprom_read_word(EEPROM_MATERIAL_FLOW_OFFSET(cnt)) > 1000)
return false;
if (eeprom_read_float(EEPROM_MATERIAL_DIAMETER_OFFSET(cnt)) > 10.0)
return false;
if (eeprom_read_float(EEPROM_MATERIAL_DIAMETER_OFFSET(cnt)) < 0.1)
return false;
eeprom_read_block(card.longFilename, EEPROM_MATERIAL_NAME_OFFSET(cnt), 8);
if (strcmp_P(card.longFilename, PSTR("UPET")) == 0)
hasUPET = true;
}
cnt = eeprom_read_byte(EEPROM_MATERIAL_COUNT_OFFSET());
if (!hasUPET && cnt < EEPROM_MATERIAL_SETTINGS_MAX_COUNT)
{
strcpy_P(card.longFilename, PSTR("UPET"));
eeprom_write_block(card.longFilename, EEPROM_MATERIAL_NAME_OFFSET(cnt), 5);
eeprom_write_word(EEPROM_MATERIAL_TEMPERATURE_OFFSET(cnt), 250);
// eeprom_write_word(EEPROM_MATERIAL_BED_TEMPERATURE_OFFSET(cnt), 60);
eeprom_write_byte(EEPROM_MATERIAL_FAN_SPEED_OFFSET(cnt), 50);
eeprom_write_word(EEPROM_MATERIAL_FLOW_OFFSET(cnt), 100);
eeprom_write_float(EEPROM_MATERIAL_DIAMETER_OFFSET(cnt), 2.85);
eeprom_write_byte(EEPROM_MATERIAL_COUNT_OFFSET(), cnt + 1);
}
return true;
}
int main(void)
{
wdt_disable();
/* Clear WDRF in MCUSR */
MCUSR &= ~(1<<WDRF);
/* Write logical one to WDCE and WDE */
/* Keep old prescaler setting to prevent unintentional time-out */
WDTCSR |= (1<<WDCE) | (1<<WDE);
/* Turn off WDT */
WDTCSR = 0x00;
DDRC |= 0xC0;
eeprom_read_block(&state, &state_ee, sizeof(state));
leds_init();
buttons_init();
adc_init();
power_init();
door_init();
aes_handler_init();
bus_handler_init();
bus_init();
cmd_init();
timer0_init();
sei();
while( 1 ){
if( timer0_timebase ){
timer0_timebase--;
bus_tick();
door_tick();
power_tick();
cmd_tick();
buttons_tick();
leds_tick();
}
bus_process();
door_process();
power_process();
}
}
int restore_mbr(void )
{
mbr_t mbr;
eeprom_read_block(&mbr, EEPROM_MBR_OFFSET, sizeof(mbr));
memcpy(&mbr_config, &mbr.mbr_config, sizeof(mbr_config_t));
#ifdef MBR_DEBUG
debug_printf("mbr.identifier %c%c (0x%x 0x%x 0x%x)\n",
mbr.identifier[0],
mbr.identifier[1],
mbr.identifier[0],
mbr.identifier[1],
mbr.identifier[2]
);
#endif
#ifdef BOOTLOADER_SUPPORT
if (mbr.identifier[0] != 'e' || mbr.identifier[1] != '6' || mbr.identifier[2] != '\0')
return 1;
#endif
return 0;
}
void GenerateTransactionNum(char *sTransNumber){//Create and Save TransactionNumber to EEPROM
char i,PTransNum[7],cNum,xNum=0,xAdd=0,Length=0;
FillChar(PTransNum,sizeof(PTransNum),0);//"999999"->"000000"
eeprom_read_block((void*) &PTransNum, (const void*) &DefTransactionNumber,sizeof(DefTransactionNumber));
xAdd=1;
xNum=0;
Length=strlen(PTransNum);
for(i=0;i<Length;i++){//[000009] 999999 123456
xNum=PTransNum[Length-i-1]-'0';
cNum='0'+((xNum+xAdd)%10);
xAdd=((xNum+xAdd)/10);
PTransNum[Length-i-1]=cNum;
sTransNumber[Length-i-1]=cNum;
}
sTransNumber[Length]=0;
PTransNum[Length]=0;
eeprom_write_block((const void*)&PTransNum,(void*)&DefTransactionNumber,sizeof(DefTransactionNumber));
}
static char* lcd_menu_material_settings_store_callback(uint8_t nr)
{
char* c = lcd_cache_new.getData(LCD_CACHE::RAWSTRING).rawstring ;
uint8_t count = eeprom_read_byte(EEPROM_MATERIAL_COUNT_OFFSET());
if (nr == 0)
strcpy_P(c, PSTR("< RETURN"));
else
if (nr > count)
strcpy_P(c, PSTR("New preset"));
else
{
eeprom_read_block(material_name_buf, EEPROM_MATERIAL_NAME_OFFSET(nr - 1), MATERIAL_NAME_LENGTH);
material_name_buf[MATERIAL_NAME_LENGTH] = '\0';
strncpy (c,material_name_buf,MATERIAL_NAME_LENGTH+1);
return c;
}
return c;
}
bool readEEPROM() {
uint8_t i;
#ifdef MULTIPLE_CONFIGURATION_PROFILES
if(global_conf.currentSet>2) global_conf.currentSet=0;
#else
global_conf.currentSet=0;
#endif
eeprom_read_block((void*)&conf, (void*)(global_conf.currentSet * sizeof(conf) + sizeof(global_conf)), sizeof(conf));
if(calculate_sum((uint8_t*)&conf, sizeof(conf)) != conf.checksum) {
blinkLED(6,100,3);
#if defined(BUZZER)
alarmArray[7] = 3;
#endif
LoadDefaults(); // force load defaults
return false; // defaults loaded, don't reload constants (EEPROM life saving)
}
// 500/128 = 3.90625 3.9062 * 3.9062 = 15.259 1526*100/128 = 1192
for(i=0;i<5;i++) {
lookupPitchRollRC[i] = (1526+conf.rcExpo8*(i*i-15))*i*(int32_t)conf.rcRate8/1192;
}
for(i=0;i<11;i++) {
int16_t tmp = 10*i-conf.thrMid8;
uint8_t y = 1;
if (tmp>0) y = 100-conf.thrMid8;
if (tmp<0) y = conf.thrMid8;
lookupThrottleRC[i] = 10*conf.thrMid8 + tmp*( 100-conf.thrExpo8+(int32_t)conf.thrExpo8*(tmp*tmp)/(y*y) )/10; // [0;1000]
lookupThrottleRC[i] = conf.minthrottle + (int32_t)(MAXTHROTTLE-conf.minthrottle)* lookupThrottleRC[i]/1000; // [0;1000] -> [conf.minthrottle;MAXTHROTTLE]
}
#if defined(POWERMETER)
pAlarm = (uint32_t) conf.powerTrigger1 * (uint32_t) PLEVELSCALE * (uint32_t) PLEVELDIV; // need to cast before multiplying
#endif
#if GPS
GPS_set_pids(); // at this time we don't have info about GPS init done
recallGPSconf(); // Load gps parameters
#endif
#if defined(ARMEDTIMEWARNING)
ArmedTimeWarningMicroSeconds = (conf.armedtimewarning *1000000);
#endif
return true; // setting is OK
}
int8_t eeprom_save_config(void *mac, void *ip, void *netmask, void *gateway)
/* {{{ */ {
(void) ip;
(void) netmask;
(void) gateway;
/* save new ip addresses */
struct eeprom_config_base_t cfg_base;
/* the eeprom section must contain valid data, if any parameter is NULL */
eeprom_read_block(&cfg_base, EEPROM_CONFIG_BASE,
sizeof(struct eeprom_config_base_t));
if (mac != NULL)
memcpy(&cfg_base.mac, mac, 6);
#if (!UIP_CONF_IPV6 && (!defined(BOOTP_SUPPORT) \
|| defined(BOOTP_TO_EEPROM_SUPPORT))) \
|| defined(OPENVPN_SUPPORT) || defined(IPV6_STATIC_SUPPORT)
if (ip != NULL)
memcpy(&cfg_base.ip, ip, IPADDR_LEN);
#endif
#if !UIP_CONF_IPV6 && (!defined(BOOTP_SUPPORT) \
|| defined(BOOTP_TO_EEPROM_SUPPORT))
if (netmask != NULL)
memcpy(&cfg_base.netmask, netmask, 4);
if (gateway != NULL)
memcpy(&cfg_base.gateway, gateway, 4);
#endif /* not UIP_CONF_IPV6 and (not BOOTP or BOOTP_TO_EEPROM) */
/* calculate new checksum */
uint8_t checksum = crc_checksum(&cfg_base, sizeof(struct eeprom_config_base_t) - 1);
cfg_base.crc = checksum;
/* save config */
eeprom_write_block(EEPROM_CONFIG_BASE, &cfg_base,
sizeof(struct eeprom_config_base_t));
return 0;
} /* }}} */
int main() {
uchar buffer,i,lastkey = 0;
// Fetch password from EEPROM and send it
eeprom_read_block(messageBuffer, stored_password, sizeof(messageBuffer));
messagePtr = 0;
messageState = STATE_SEND;
for(i=0; i<sizeof(keyboard_report); i++) // clear report initially
((uchar *)&keyboard_report)[i] = 0;
wdt_enable(WDTO_1S); // enable 1s watchdog timer
init_uart0();
usbInit();
usbDeviceDisconnect(); // enforce re-enumeration
for(i = 0; i<250; i++) { // wait 500 ms
wdt_reset(); // keep the watchdog happy
_delay_ms(2);
}
usbDeviceConnect();
// TCCR0B |= (1 << CS01); // timer 0 at clk/8 will generate randomness
sei(); // Enable interrupts after re-enumeration
while(1) {
wdt_reset(); // keep the watchdog happy
usbPoll();
buffer = UDR0;
lastkey = buffer;
// characters are sent when messageState == STATE_SEND and after receiving
// the initial LED state from PC (good way to wait until device is recognized)
if(usbInterruptIsReady() && messageState == STATE_SEND) {
messageState = buildReport(lastkey);
usbSetInterrupt((void *)&keyboard_report, sizeof(keyboard_report));
}
}
return 0;
}
//----------------------------------------------------------------------------
//Auslesen der im eeprom gespeicherten Z�hlerst�nde
void read_eeprom (uint8_t addr)
{
uint32_t hilf;
uint16_t S0_address = 0;
if(addr == 0)S0_address = EEPROM_S0_0_STORE;
if(addr == 1)S0_address = EEPROM_S0_1_STORE;
if(S0_address == 0)return;
S0_DEBUG("EEPROM Read address:%i\r\n",S0_address);
// Counter aus Speicher auslesen
eeprom_busy_wait ();
eeprom_read_block(&hilf,(unsigned char *)S0_address,sizeof(uint32_t));
CountInt[addr]=hilf;
if(CountInt[addr]==0xFFFFFFFF)CountInt[addr]=0;
}
/**
* \brief This is the implementation of the 15.4 MAC Reset Request
* primitive.
* \param setDefaultPIB True if the default PIB values should be set.
* \return Integer denoting success or failure.
* \retval 0 Failure.
* \retval 1 Success.
*
* Sets all PIB values to default.
*/
void
sicslowmac_resetRequest (bool setDefaultPIB)
{
if(setDefaultPIB){
/* initialize all of the MAC PIB variables to their default values */
macCoordShortAddress = 0xffff;
macDSN = rand() % 256;
macSrcPANId = SOURCE_PAN_ID;
macDstPANId = DEST_PAN_ID;
macShortAddress = 0xffff;
/* Setup the address of this device by reading a stored address from eeprom. */
/** \todo This might be read from the serial eeprom onboard Raven. */
AVR_ENTER_CRITICAL_REGION();
eeprom_read_block ((void *)&macLongAddr, EEPROMMACADDRESS, 8);
byte_reverse((uint8_t *) &macLongAddr, 8);
AVR_LEAVE_CRITICAL_REGION();
}
}
static void monitor_insert_reedkontakt_state(uint8_t gruppe, uint8_t state)
{
eds_block_p it = eds_find_next_block((eds_block_p)0, EDS_userpanel_reedkontakte_BLOCK_ID);
if (!it)
{
load_error_page(ERROR_CONF_REEDKONTAKTE_MISSING);
return;
}
userpanel_reedkontakte_t c;
eeprom_read_block(&c, (it+2), sizeof(c)); // Ist ein EEPROM-Zugriff, daher langsamer!
uint8_t i;
for (i = 0; i < 24; i++)
{
if (gruppe == c.reed[i])
{
//canix_syslog_P(SYSLOG_PRIO_DEBUG, PSTR("g%d %d"), i, state);
monitor_reedkontakt_state[i] = state;
}
}
}
Cstorage::Cstorage(Cat45db041* flashdrv) {
u08 buf[pageSize];
this->flashdrv = flashdrv;
// Check if FLASH storage has been initialized
flashdrv->read(buf, configBasePage);
memcpy((u08*) &flash, buf, sizeof(flash));
if (flash.magic != FLASH_MAGIC_NUM_0) {
#ifndef LOADER
eraseFlash();
#endif
}
// Check if storage has been initilized.
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
eeprom_read_block(&eeprom, 0, sizeof(eeprom));
if (eeprom.magic != EEPROM_MAGIC_NUM_0) {
#ifndef LOADER
eraseEeprom();
#endif
}
}
}
void mem_init()
{
bool invalid = false;
ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
{
eeprom_read_block(&mem_config, &g_config_memory, sizeof(proto::Config));
// Validity check (empty EEPROM is 0xFFFF)
if(mem_config.active_axes > 100 || mem_config.num_keyframes >= proto::MAX_KEYFRAMES)
{
invalid = true;
mem_config.active_axes = 4;
mem_config.num_keyframes = 0;
}
}
if(invalid)
printf("No valid configuration found in EEPROM\n");
}
