bool readEEPROM() {
uint8_t i;
global_conf.currentSet=0;
eeprom_read_block((void*)&conf, (void*)(global_conf.currentSet * sizeof(conf) + sizeof(global_conf)), sizeof(conf));
print("Calcul Eprom = %d, Read conf = %d \n\r", calculate_sum((uint8_t*)&conf, sizeof(conf)), conf.checksum);
if(calculate_sum((uint8_t*)&conf, sizeof(conf)) != conf.checksum) {
print("Loading Defaults\n\r");
blinkLED(6,100,3);
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]
}
return true; // setting is OK
}
void writeParams(uint8_t b) {
global_conf.currentSet=0;
conf.checksum = calculate_sum((uint8_t*)&conf, sizeof(conf));
eeprom_write_block((const void*)&conf, (void*)(global_conf.currentSet * sizeof(conf) + sizeof(global_conf)), sizeof(conf));
readEEPROM();
if (b == 1) blinkLED(15,20,1);
}
void readGlobalSet() {
eeprom_read_block((void*)&global_conf, (void*)0, sizeof(global_conf));
if(calculate_sum((uint8_t*)&global_conf, sizeof(global_conf)) != global_conf.checksum) {
global_conf.currentSet = 0;
global_conf.accZero[ROLL] = 5000; // for config error signalization
}
}
void writeGlobalSet(uint8_t b) {
global_conf.checksum = calculate_sum((uint8_t*)&global_conf, sizeof(global_conf));
eeprom_write_block((const void*)&global_conf, (void*)0, sizeof(global_conf));
if (b == 1) blinkLED(15,20,1);
SET_ALARM_BUZZER(ALRM_FAC_CONFIRM, ALRM_LVL_CONFIRM_1);
}
main(){
make_linked_list();
get_numbers();
get_scale();
calculate_sum();
print_result();
getch();
}
// Read the given number of WP from the eeprom, supposedly we can use this during flight.
// Returns true when reading is successfull and returns false if there were some error (for example checksum)
bool recallWP(uint8_t wp_number) {
if (wp_number > 254) return false;
eeprom_read_block((void*)&mission_step, (void*)(PROFILES * sizeof(conf) + sizeof(global_conf)+sizeof(GPS_conf)+(sizeof(mission_step)*wp_number)), sizeof(mission_step));
if(calculate_sum((uint8_t*)&mission_step, sizeof(mission_step)) != mission_step.checksum) return false;
return true;
}
//Recall gps_configuration
bool recallGPSconf(void) {
eeprom_read_block((void*)&GPS_conf, (void*)(PROFILES * sizeof(conf) + sizeof(global_conf)), sizeof(GPS_conf));
if(calculate_sum((uint8_t*)&GPS_conf, sizeof(GPS_conf)) != GPS_conf.checksum) {
loadGPSdefaults();
return false;
}
return true;
}
void writeGlobalSet(uint8_t b) {
global_conf.checksum = calculate_sum((uint8_t*)&global_conf, sizeof(global_conf));
eeprom_write_block((const void*)&global_conf, (void*)0, sizeof(global_conf));
if (b == 1) blinkLED(15,20,1);
#if defined(BUZZER)
alarmArray[7] = 1;
#endif
}
typename std::iterator_traits<iterator>::value_type calculate_mean( iterator begin, iterator end )
{
typedef typename std::iterator_traits<iterator>::value_type value_t;
typedef typename std::iterator_traits<iterator>::difference_type diff_t;
diff_t length = end - begin;
value_t tmp = calculate_sum( begin, end );
if ( length > 1 )
tmp /= length;
return tmp;
}
//Stores the WP data in the wp struct in the EEPROM
void storeWP() {
#ifdef MULTIPLE_CONFIGURATION_PROFILES
#define PROFILES 3
#else
#define PROFILES 1
#endif
if (mission_step.number >254) return;
mission_step.checksum = calculate_sum((uint8_t*)&mission_step, sizeof(mission_step));
eeprom_write_block((void*)&mission_step, (void*)(PROFILES * sizeof(conf) + sizeof(global_conf)+(sizeof(mission_step)*mission_step.number)),sizeof(mission_step));
}
void readPLog(void) {
eeprom_read_block((void*)&plog, (void*)(E2END - 4 - sizeof(plog)), sizeof(plog));
if(calculate_sum((uint8_t*)&plog, sizeof(plog)) != plog.checksum) {
blinkLED(9,100,3);
SET_ALARM_BUZZER(ALRM_FAC_CONFIRM, ALRM_LVL_CONFIRM_ELSE);
// force load defaults
plog.arm = plog.disarm = plog.start = plog.failsafe = plog.i2c = 0;
plog.running = 1;
plog.lifetime = plog.armed_time = 0;
writePLog();
}
}
// Read the given number of WP from the eeprom, supposedly we can use this during flight.
// Returns true when reading is successfull and returns false if there were some error (for example checksum)
bool recallWP(uint8_t wp_number) {
#ifdef MULTIPLE_CONFIGURATION_PROFILES
#define PROFILES 3
#else
#define PROFILES 1
#endif
if (wp_number > 254) return false;
eeprom_read_block((void*)&mission_step, (void*)(PROFILES * sizeof(conf) + sizeof(global_conf)+(sizeof(mission_step)*wp_number)), sizeof(mission_step));
if(calculate_sum((uint8_t*)&mission_step, sizeof(mission_step)) != mission_step.checksum) return false;
return true;
}
void readPLog(void) {
eeprom_read_block((void*)&plog, (void*)(E2END - 4 - sizeof(plog)), sizeof(plog));
if(calculate_sum((uint8_t*)&plog, sizeof(plog)) != plog.checksum) {
blinkLED(9,100,3);
#if defined(BUZZER)
alarmArray[7] = 3;
#endif
// force load defaults
plog.arm = plog.disarm = plog.start = plog.failsafe = plog.i2c = 0;
plog.running = 1;
plog.lifetime = plog.armed_time = 0;
writePLog();
}
}
void writeParams(uint8_t b) {
#ifdef MULTIPLE_CONFIGURATION_PROFILES
if(global_conf.currentSet>2) global_conf.currentSet=0;
#else
global_conf.currentSet=0;
#endif
conf.checksum = calculate_sum((uint8_t*)&conf, sizeof(conf));
eeprom_write_block((const void*)&conf, (void*)(global_conf.currentSet * sizeof(conf) + sizeof(global_conf)), sizeof(conf));
readEEPROM();
if (b == 1) blinkLED(15,20,1);
#if defined(BUZZER)
alarmArray[7] = 1; //beep if loaded from gui or android
#endif
}
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
conf.rcExpo8 = 0;
conf.rcRate8 = PITCH_ROLL_RC_RATE_AIR;
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++) {
//conf.thrExpo8 = 0;
//conf.thrMid8 = 0;
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]
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
#endif
#if defined(ARMEDTIMEWARNING)
ArmedTimeWarningMicroSeconds = (conf.armedtimewarning *1000000);
#endif
return true; // setting is OK
}
/* average and standard deviation of a vector */
size_t average (size_t N, double *data, double *av) {
double sum;
double n = (double) N; /* cast to double */
/* check that we have at least two values for the determination of standard deviation */
if (N==0) {
err_message ("Insufficient data to perform average\n");
return MYLIB_FAIL;
}
/* sum */
calculate_sum (N, data, &sum);
/* calculate average and standard deviation */
*av = _AVERAGE (n,sum);
return MYLIB_SUCCESS;
}
void writeParams(uint8_t b) {
#ifdef MULTIPLE_CONFIGURATION_PROFILES
if(global_conf.currentSet>2) global_conf.currentSet=0;
#else
global_conf.currentSet=0;
#endif
conf.checksum = calculate_sum((uint8_t*)&conf, sizeof(conf));
eeprom_write_block((const void*)&conf, (void*)(global_conf.currentSet * sizeof(conf) + sizeof(global_conf)), sizeof(conf));
#if GPS
writeGPSconf(); //Write GPS parameters
recallGPSconf(); //Read it to ensure correct eeprom content
#endif
readEEPROM();
if (b == 1) blinkLED(15,20,1);
SET_ALARM_BUZZER(ALRM_FAC_CONFIRM, ALRM_LVL_CONFIRM_1);
}
void do_sleep(int proc, size_t numDoubles)
{
stk::CommSparse comm(MPI_COMM_WORLD);
if(proc==0)
::usleep(workTimeProc0*1e6);
else
calculate_sum(workTimeProcOthers*1e6);
std::vector<double> dataSent(numDoubles,1);
std::vector<std::vector<double> > dataRecvd(comm.parallel_size());
stk::pack_and_communicate(comm, [&comm, &dataSent]() { send_data_to_other_procs(dataSent, comm); });
stk::unpack_communications(comm,
[&comm, &dataRecvd](int procId)
{
stk::unpack_vector_from_proc(comm, dataRecvd[procId], procId);
});
}
bool readEEPROM() {
uint8_t i;
int8_t tmp;
uint8_t y;
#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);
SET_ALARM_BUZZER(ALRM_FAC_CONFIRM, ALRM_LVL_CONFIRM_ELSE);
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++) {
tmp = 10*i-conf.thrMid8;
y = conf.thrMid8;
if (tmp>0) y = 100-y;
lookupThrottleRC[i] = 100*conf.thrMid8 + tmp*( (int32_t)conf.thrExpo8*(tmp*tmp)/((uint16_t)y*y)+100-conf.thrExpo8 ); // [0;10000]
lookupThrottleRC[i] = conf.minthrottle + (uint32_t)((uint16_t)(MAXTHROTTLE-conf.minthrottle))* lookupThrottleRC[i]/10000; // [0;10000] -> [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
}
static image_reconstruct_ERROR_CODE
do_reconstruction(const image_filter_IMG* original,
const image_reconstruct_PARAMETERS* params,
image_filter_IMG* result)
{
image_reconstruct_ERROR_CODE ret = IMAGE_RECONSTRUCT_OK;
image_filter_FILTER row_filter = {0};
image_filter_FILTER col_filter = {0};
image_filter_IMG approx_row = {0};
image_filter_IMG approx_col = {0};
image_filter_IMG approx_diag = {0};
image_filter_IMG tmp = {0};
double row_mask[] = PREWITT_ROW_MASK;
double col_mask[] = PREWITT_COL_MASK;
image_filter_create_filter_by_mask(3,
row_mask,
&row_filter);
image_filter_create_filter_by_mask(3,
col_mask,
&col_filter);
image_filter_create_image(original->width,
original->height,
&approx_row);
image_filter_create_image(original->width,
original->height,
&tmp);
image_filter_create_image(original->width,
original->height,
&approx_col);
image_filter_create_image(original->width,
original->height,
&approx_diag);
if ((ret = prepare_image(original, params, &tmp))
!= IMAGE_AMPLIFIER_OK)
{}
else if ((ret = apply_filter(&tmp,
&row_filter,
&approx_row)) != IMAGE_RECONSTRUCT_OK)
{}
else if ((ret = apply_filter(&tmp,
&col_filter,
&approx_col)) != IMAGE_RECONSTRUCT_OK)
{}
if (ret == IMAGE_RECONSTRUCT_OK)
{
haar_transformation_DATA_SOURCE data;
calculate_sum(&approx_col,
&approx_row,
NULL,
&approx_diag);
data.width = original->width;
data.height = original->height;
data.original_image = result->content;
data.avg_image = tmp.content;
data.vertical_edges = approx_col.content;
data.horizontal_edges = approx_row.content;
data.diagonal_edges = approx_diag.content;
/* DUMPER_TRACE_IMAGE(data.avg_image, data.width, data.height);
DUMPER_TRACE_IMAGE(data.vertical_edges, data.width, data.height);
DUMPER_TRACE_IMAGE(data.horizontal_edges, data.width, data.height);
DUMPER_TRACE_IMAGE(data.diagonal_edges, data.width, data.height);
DUMPER_TRACE_IMAGE(tmp.content, data.width, data.height); */
data.width *= 2;
data.height *= 2;
haar_transformation_inverse_transformation(data);
/* DUMPER_TRACE_IMAGE(data.original_image, data.width, data.height); */
}
image_filter_destroy_image(&approx_diag);
image_filter_destroy_image(&tmp);
image_filter_destroy_image(&approx_col);
image_filter_destroy_image(&approx_row);
image_filter_destroy_filter(&row_filter);
image_filter_destroy_filter(&col_filter);
return ret;
}
//Stores the WP data in the wp struct in the EEPROM
void storeWP() {
if (mission_step.number >254) return;
mission_step.checksum = calculate_sum((uint8_t*)&mission_step, sizeof(mission_step));
eeprom_write_block((void*)&mission_step, (void*)(PROFILES * sizeof(conf) + sizeof(global_conf) + sizeof(GPS_conf) +(sizeof(mission_step)*mission_step.number)),sizeof(mission_step));
}
void writeGPSLog(uint32_t gpstime, int32_t latitude, int32_t longitude, int32_t altitude) {
#else
void writeGPSLog(int32_t latitude, int32_t longitude, int32_t altitude) {
#endif
if (f.SDCARD == 0) return;
if (gps_data.open(GPS_LOG_FILENAME, O_WRITE | O_CREAT | O_APPEND)) {
#ifdef UBLOX
gps_data.print(gpstime); gps_data.write(',');
#endif
gps_data.print(latitude); gps_data.write(',');
gps_data.print(longitude); gps_data.write(',');
gps_data.print(altitude); gps_data.println();
gps_data.close();
} else {
return;
}
}
void writePLogToSD() {
if (f.SDCARD == 0) return;
plog.checksum = calculate_sum((uint8_t*)&plog, sizeof(plog));
if (permanent.open(PERMANENT_LOG_FILENAME, O_WRITE | O_CREAT | O_TRUNC)) {
permanent.print(F("arm=")); permanent.println(plog.arm);
permanent.print(F("disarm=")); permanent.println(plog.disarm);
permanent.print(F("start=")); permanent.println(plog.start);
permanent.print(F("armed_time=")); permanent.println(plog.armed_time);
permanent.print(F("lifetime=")); permanent.println(plog.lifetime, DEC);
permanent.print(F("failsafe=")); permanent.println(plog.failsafe);
permanent.print(F("i2c=")); permanent.println(plog.i2c);
permanent.print(F("running=")); permanent.println(plog.running, DEC);
permanent.print(F("checksum=")); permanent.println(plog.checksum, DEC);
permanent.print(F("debug=")); permanent.print(debug[0]);
permanent.print(F(",")); permanent.print(debug[1]);
permanent.print(F(",")); permanent.print(debug[2]);
permanent.print(F(",")); permanent.println(debug[3]);
permanent.println();
permanent.close();
} else {
return;
}
}
void fillPlogStruct(char* key, char* value) {
if (strcmp(key, "arm") == 0) sscanf(value, "%u", &plog.arm);
if (strcmp(key, "disarm") == 0) sscanf(value, "%u", &plog.disarm);
if (strcmp(key, "start") == 0) sscanf(value, "%u", &plog.start);
if (strcmp(key, "armed_time") == 0) sscanf(value, "%lu", &plog.armed_time);
if (strcmp(key, "lifetime") == 0) sscanf(value, "%lu", &plog.lifetime);
if (strcmp(key, "failsafe") == 0) sscanf(value, "%u", &plog.failsafe);
if (strcmp(key, "i2c") == 0) sscanf(value, "%u", &plog.i2c);
if (strcmp(key, "running") == 0) sscanf(value, "%hhu", &plog.running);
if (strcmp(key, "checksum") == 0) sscanf(value, "%hhu", &plog.checksum);
}
void readPLogFromSD() {
if (f.SDCARD == 0) return;
SdFile myfile;
char key[12];
char value[32];
char* tabPtr = key;
int c;
uint8_t i = 0;
if (myfile.open(PERMANENT_LOG_FILENAME, O_READ)) {
while (myfile.available()) {
c = myfile.read();
switch ((char)c) {
case ' ':
break;
case '=':
*tabPtr = '\0';
tabPtr = value;
break;
case '\n':
*tabPtr = '\0';
tabPtr = key;
i = 0;
fillPlogStruct(key, value);
memset(key, '\0', sizeof(key));
memset(value, '\0', sizeof(value));
break;
default:
i++;
if (i <= 12) {
*tabPtr = (char)c;
tabPtr++;
}
break;
}
}
} else return;
if (calculate_sum((uint8_t*)&plog, sizeof(plog)) != plog.checksum) {
#if defined(BUZZER)
alarmArray[7] = 3;
blinkLED(9, 100, 3);
#endif
// force load defaults
plog.arm = plog.disarm = plog.start = plog.failsafe = plog.i2c = 11;
plog.running = 1;
plog.lifetime = plog.armed_time = 3;
writePLogToSD();
}
}
void writeGPSconf(void) {
GPS_conf.checksum = calculate_sum((uint8_t*)&GPS_conf, sizeof(GPS_conf));
eeprom_write_block( (void*)&GPS_conf, (void*) (PROFILES * sizeof(conf) + sizeof(global_conf)), sizeof(GPS_conf) );
}
void writePLog(void) {
plog.checksum = calculate_sum((uint8_t*)&plog, sizeof(plog));
eeprom_write_block((const void*)&plog, (void*)(E2END - 4 - sizeof(plog)), sizeof(plog));
}
int main (void)
{
FILE *infile = NULL, *outfile = NULL;
double gpa1 = 0.0, gpa2 = 0.0, gpa3 = 0.0, gpa4 = 0.0, gpa5 = 0.0,
age1 = 0.0, age2 = 0.0, age3 = 0.0, age4 = 0.0, age5 = 0.0,
sum_gpa = 0.0, sum_class_standing = 0.0, sum_age = 0.0,
mean_gpa = 0.0, mean_class_standing = 0.0, mean_age = 0.0,
gpa1_dev = 0.0, gpa2_dev = 0.0, gpa3_dev = 0.0, gpa4_dev = 0.0, gpa5_dev = 0.0,
gpa_variance = 0.0, gpa_std_dev = 0.0, min_gpa = 0.0, max_gpa = 0.0;
int id1 = 0, id2 = 0, id3 = 0, id4 = 0, id5 =0,
class_standing1 = 0, class_standing2 = 0, class_standing3 = 0, class_standing4 = 0, class_standing5 = 0;
//Opens an input file "input.dat" for reading;
infile = fopen ("input.dat", "r");
//Opens an output file "output.dat" for writing;
outfile = fopen ("output.dat", "w");
//Reads five records from the input file (input.dat); You will need to use a combination of read_double ( ) and read_integer ( ) function calls here!
id1 = read_integer (infile);
gpa1 = read_double (infile);
class_standing1 = read_integer (infile);
age1 = read_double (infile);
id2 = read_integer (infile);
gpa2 = read_double (infile);
class_standing2 = read_integer (infile);
age2 = read_double (infile);
id3 = read_integer (infile);
gpa3 = read_double (infile);
class_standing3 = read_integer (infile);
age3 = read_double (infile);
id4 = read_integer (infile);
gpa4 = read_double (infile);
class_standing4 = read_integer (infile);
age4 = read_double (infile);
id5 = read_integer (infile);
gpa5 = read_double (infile);
class_standing5 = read_integer (infile);
age5 = read_double (infile);
//Calculates the sum of the GPAs;
sum_gpa = calculate_sum (gpa1, gpa2, gpa3, gpa4, gpa5);
//Calculates the sum of the class standings;
sum_class_standing = calculate_sum (class_standing1, class_standing2, class_standing3, class_standing4, class_standing5);
//Calculates the sum of the ages;
sum_age = calculate_sum (age1, age2, age3, age4, age5);
//Calculates the mean of the GPAs, writing the result to the output file (output.dat);
mean_gpa = calculate_mean (sum_gpa, 5);
fprintf (outfile, "The mean GPA is %lf\n", mean_gpa);
//Calculates the mean of the class standings, writing the result to the output file (output.dat);
mean_class_standing = calculate_mean (sum_class_standing, 5);
fprintf (outfile, "The mean class standing is %lf\n", mean_class_standing);
//Calculates the mean of the ages, writing the result to the output file (output.dat);
mean_age = calculate_mean (sum_age, 5);
fprintf (outfile, "The mean age is %lf\n", mean_age);
//Calculates the deviation of each GPA from the mean (Hint: need to call calculate_deviation ( ) 5 times)
//Calculates the variance of the GPAs
//Calculates the standard deviation of the GPAs, writing the result to the output file (output.dat);
//Determines the min of the GPAs, writing the result to the output file (output.dat);
//Determines the max of the GPAs, writing the result to the output file (output.dat);
//Closes the input and output files (i.e. input.dat and output.dat)
fclose (infile);
fclose (outfile);
return 0;
}
void writeGlobalSet(uint8_t b) {
global_conf.checksum = calculate_sum((uint8_t*)&global_conf, sizeof(global_conf));
eeprom_write_block((const void*)&global_conf, (void*)0, sizeof(global_conf));
if (b == 1) blinkLED(15,20,1);
}