int accelCalibrateOne(void) {
if (cntCalAcc++ == 3000)
{
int16_t accXOffset = accXsum/3000;
int16_t accYOffset = accYsum/3000;
int16_t accZOffset = 4096 + accZsum/3000;
cntCalAcc = 0;
gSensor.accXOffset = accXOffset;
gSensor.accYOffset = accYOffset;
gSensor.accZOffset = accZOffset;
EE_WriteVariable(VirtAddVarTab[PARAM_ACCX_OFFSET], gSensor.accXOffset);
EE_WriteVariable(VirtAddVarTab[PARAM_ACCY_OFFSET], gSensor.accYOffset);
EE_WriteVariable(VirtAddVarTab[PARAM_ACCZ_OFFSET], gSensor.accZOffset);
global_data.param[PARAM_ACCX_OFFSET] = gSensor.accXOffset;
global_data.param[PARAM_ACCY_OFFSET] = gSensor.accYOffset;
global_data.param[PARAM_ACCZ_OFFSET] = gSensor.accZOffset;
gState.numFaceAccCalib = 0;
gState.numFace = 0;
accXsum = 0;
accYsum = 0;
accZsum = 0;
}
else
{
accXsum += gSensor.accX;
accYsum += gSensor.accY;
accZsum += gSensor.accZ;
}
return 0;
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int mainOld(void)
{
/* Setup STM32 system (clock, PLL and Flash configuration) */
SystemInit();
/* Unlock the Flash Program Erase controller */
FLASH_Unlock();
/* EEPROM Init */
EE_Init();
/* --- Store successively many values of the three variables in the EEPROM ---*/
/* Store 1000 values of Variable1 in EEPROM */
for (VarValue = 0; VarValue < 1000; VarValue++)
{
EE_WriteVariable(VirtAddVarTab[0], VarValue);
}
/* Store 500 values of Variable2 in EEPROM */
for (VarValue = 0; VarValue < 500; VarValue++)
{
EE_WriteVariable(VirtAddVarTab[1], VarValue);
}
/* Store 800 values of Variable3 in EEPROM */
for (VarValue = 0; VarValue < 800; VarValue++)
{
EE_WriteVariable(VirtAddVarTab[2], VarValue);
}
while (1);
}
int gyroCalibrate(void)
{
if (j++==3000)
{
gSensor.gyroXOffset= (int16_t)(gyroXsum/3000);
gSensor.gyroYOffset= (int16_t)(gyroYsum/3000);
gSensor.gyroZOffset= (int16_t)(gyroZsum/3000);
j=0;
EE_WriteVariable(VirtAddVarTab[PARAM_GYROX_OFFSET], gSensor.gyroXOffset);
EE_WriteVariable(VirtAddVarTab[PARAM_GYROY_OFFSET], gSensor.gyroYOffset);
EE_WriteVariable(VirtAddVarTab[PARAM_GYROZ_OFFSET], gSensor.gyroZOffset);
global_data.param[PARAM_GYROX_OFFSET]=gSensor.gyroXOffset;
global_data.param[PARAM_GYROY_OFFSET]=gSensor.gyroYOffset;
global_data.param[PARAM_GYROZ_OFFSET]=gSensor.gyroZOffset;
gState.gyroCalibrated = 1;
gyroXsum = 0;
gyroYsum = 0;
gyroZsum = 0;
}
else if(j < 3000)
{
gyroXsum+=gSensor.gyroX;
gyroYsum+=gSensor.gyroY;
gyroZsum+=gSensor.gyroZ;
}
return 1;
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/* STM32F103xB HAL library initialization:
- Configure the Flash prefetch
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Set NVIC Group Priority to 4
- Low Level Initialization
*/
HAL_Init();
/* Configure the system clock to 64 MHz */
SystemClock_Config();
/* Unlock the Flash Program Erase controller */
HAL_FLASH_Unlock();
/* EEPROM Init */
EE_Init();
/* --- Store successively many values of the three variables in the EEPROM ---*/
/* Store 0x1000 values of Variable1 in EEPROM */
for (VarValue = 1; VarValue <= 0x1000; VarValue++)
{
EE_WriteVariable(VirtAddVarTab[0], VarValue);
}
/* read the last stored variables data*/
EE_ReadVariable(VirtAddVarTab[0], &VarDataTab[0]);
/* Store 0x2000 values of Variable2 in EEPROM */
for (VarValue = 1; VarValue <= 0x2000; VarValue++)
{
EE_WriteVariable(VirtAddVarTab[1], VarValue);
}
/* read the last stored variables data*/
EE_ReadVariable(VirtAddVarTab[0], &VarDataTab[0]);
EE_ReadVariable(VirtAddVarTab[1], &VarDataTab[1]);
/* Store 0x3000 values of Variable3 in EEPROM */
for (VarValue = 1; VarValue <= 0x3000; VarValue++)
{
EE_WriteVariable(VirtAddVarTab[2], VarValue);
}
/* read the last stored variables data*/
EE_ReadVariable(VirtAddVarTab[0], &VarDataTab[0]);
EE_ReadVariable(VirtAddVarTab[1], &VarDataTab[1]);
EE_ReadVariable(VirtAddVarTab[2], &VarDataTab[2]);
while (1)
{
};
}
/*====================================================================================================*/
void EE_SAVE_Attitude_PID(void)
{
u16 _temp;
if(flag.ParamSave){
flag.ParamSave=0;
_temp = ctrl.pitch.core.kp * 100;
EE_WriteVariable(VirtAddVarTab[EE_PID_CORE_PITCH_P],_temp);
_temp = ctrl.pitch.core.ki * 1000;
EE_WriteVariable(VirtAddVarTab[EE_PID_CORE_PITCH_I],_temp);
_temp = ctrl.pitch.core.kd * 100;
EE_WriteVariable(VirtAddVarTab[EE_PID_CORE_PITCH_D],_temp);
_temp = ctrl.roll.core.kp * 100;
EE_WriteVariable(VirtAddVarTab[EE_PID_CORE_ROLL_P],_temp);
_temp = ctrl.roll.core.ki * 1000;
EE_WriteVariable(VirtAddVarTab[EE_PID_CORE_ROLL_I],_temp);
_temp = ctrl.roll.core.kd * 100;
EE_WriteVariable(VirtAddVarTab[EE_PID_CORE_ROLL_D],_temp);
_temp = ctrl.yaw.core.kp * 100;
EE_WriteVariable(VirtAddVarTab[EE_PID_CORE_YAW_P],_temp);
_temp = ctrl.yaw.core.ki * 1000;
EE_WriteVariable(VirtAddVarTab[EE_PID_CORE_YAW_I],_temp);
_temp = ctrl.yaw.core.kd * 100;
EE_WriteVariable(VirtAddVarTab[EE_PID_CORE_YAW_D],_temp);
}
}
/* write parameter to flash -------------------------------------------------*/
void writeFlashParameter(u16 para, u16 value)
{
if (para == PARA_SET)
{
EE_WriteVariable(VirtAddVarTab[PARA_SET], value);
parameter[PARA_SET] = value;
}
else
{
EE_WriteVariable(VirtAddVarTab[para+parameter[PARA_SET]], value);
parameter[para+parameter[PARA_SET]] = value;
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/*!< At this stage the microcontroller clock setting is already configured,
this is done through SystemInit() function which is called from startup
file (startup_stm32f4xx.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f4xx.c file
*/
/* Unlock the Flash Program Erase controller */
FLASH_Unlock();
/* EEPROM Init */
EE_Init();
/* --- Store successively many values of the three variables in the EEPROM ---*/
/* Store 0x1000 values of Variable1 in EEPROM */
for (VarValue = 1; VarValue <= 0x1000; VarValue++)
{
EE_WriteVariable(VirtAddVarTab[0], VarValue);
}
/* read the last stored variables data*/
EE_ReadVariable(VirtAddVarTab[0], &VarDataTab[0]);
/* Store 0x2000 values of Variable2 in EEPROM */
for (VarValue = 1; VarValue <= 0x2000; VarValue++)
{
EE_WriteVariable(VirtAddVarTab[1], VarValue);
}
/* read the last stored variables data*/
EE_ReadVariable(VirtAddVarTab[0], &VarDataTab[0]);
EE_ReadVariable(VirtAddVarTab[1], &VarDataTab[1]);
/* Store 0x3000 values of Variable3 in EEPROM */
for (VarValue = 1; VarValue <= 0x3000; VarValue++)
{
EE_WriteVariable(VirtAddVarTab[2], VarValue);
}
/* read the last stored variables data*/
EE_ReadVariable(VirtAddVarTab[0], &VarDataTab[0]);
EE_ReadVariable(VirtAddVarTab[1], &VarDataTab[1]);
EE_ReadVariable(VirtAddVarTab[2], &VarDataTab[2]);
while (1);
}
void display_info_set(uint8_t distortion_type, uint8_t *buf)
{
FLASH_Unlock();
EE_WriteVariable(EE_DISPLAY_INFO_DISTORTION_TYPE, distortion_type);
uint16_t *writebuf = (uint16_t *)buf;
for (uint8_t i = 0; i < EE_DISPLAY_INFO_SIZE; i++) {
// Write in the parameters two bytes at a time
EE_WriteVariable(EE_DISPLAY_INFO_START+i, writebuf[i]);
}
FLASH_Lock();
}
/*
* Usuniecie danych o wcisnieciach klawiszy
*/
void resetEEPROM (void)
{
int i = 0;
for (i = 0; i < NB_OF_VAR; i++)
{
EE_WriteVariable(VirtAddVarTab[i], 0x00);
}
}
/* write parameter to flash -------------------------------------------------*/
void writeFlashParameter(u16 para, u16 value)
{
if (para == PARA_SET)
{
EE_WriteVariable(VirtAddVarTab[PARA_SET], value);
parameter[PARA_SET] = value;
}
else
{
EE_WriteVariable(VirtAddVarTab[para+parameter[PARA_SET]], value);
parameter[para+parameter[PARA_SET]] = value;
// if we change the SW Parameter we have to init the filter
if (para == PARA_SW) // = 4
{
initFilter(gyroAngle, copterAngle);
}
}
}
void setup_FLASH()
{
uint16_t tmp_eeprom_data_structure_version;
FLASH_Unlock();
EE_Init();
EE_ReadVariable(VirtAddVarTab[index_eeprom_data_structure_version],&tmp_eeprom_data_structure_version); //eeprom_data_structure_version lesen
if (tmp_eeprom_data_structure_version != eeprom_data_structure_version)
{
EE_Format();
EE_WriteVariable(VirtAddVarTab[index_eeprom_data_structure_version],eeprom_data_structure_version);
}
}
void eeprom_write_byte(uint8_t *pos, unsigned char value) {
uint16_t eeprom_address = (unsigned) pos;
eeprom_init();
HAL_FLASH_Unlock();
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
if (EE_WriteVariable(eeprom_address, (uint16_t) value) != EE_OK)
for (;;) HAL_Delay(1); // Spin forever until watchdog reset
HAL_FLASH_Lock();
}
void EE_Write_ACC_GYRO_Offset(void)
{
EE_WriteVariable(VirtAddVarTab[EE_ACC_X_OFFSET], mpu_info.offset_acc.x);
EE_WriteVariable(VirtAddVarTab[EE_ACC_Y_OFFSET], mpu_info.offset_acc.y);
EE_WriteVariable(VirtAddVarTab[EE_ACC_Z_OFFSET], mpu_info.offset_acc.z);
EE_WriteVariable(VirtAddVarTab[EE_GYRO_X_OFFSET], mpu_info.offset_gyro.x);
EE_WriteVariable(VirtAddVarTab[EE_GYRO_Y_OFFSET], mpu_info.offset_gyro.y);
EE_WriteVariable(VirtAddVarTab[EE_GYRO_Z_OFFSET], mpu_info.offset_gyro.z);
}
void EE_SAVE_PID(void) //保存PID参数
{
u16 _temp;
_temp = PID_ROL.P * 100;
EE_WriteVariable(VirtAddVarTab[EE_PID_ROL_P],_temp);
_temp = PID_ROL.I * 100;
EE_WriteVariable(VirtAddVarTab[EE_PID_ROL_I],_temp);
_temp = PID_ROL.D * 100;
EE_WriteVariable(VirtAddVarTab[EE_PID_ROL_D],_temp);
_temp = PID_PIT.P * 100;
EE_WriteVariable(VirtAddVarTab[EE_PID_PIT_P],_temp);
_temp = PID_PIT.I * 100;
EE_WriteVariable(VirtAddVarTab[EE_PID_PIT_I],_temp);
_temp = PID_PIT.D * 100;
EE_WriteVariable(VirtAddVarTab[EE_PID_PIT_D],_temp);
_temp = PID_YAW.P * 100;
EE_WriteVariable(VirtAddVarTab[EE_PID_YAW_P],_temp);
_temp = PID_YAW.I * 100;
EE_WriteVariable(VirtAddVarTab[EE_PID_YAW_I],_temp);
_temp = PID_YAW.D * 100;
EE_WriteVariable(VirtAddVarTab[EE_PID_YAW_D],_temp);
}
void EE_Write_PID(void) //
{
u16 _temp;
_temp = pidRoll.kp * 100;
EE_WriteVariable(VirtAddVarTab[EE_PID_ROL_P],_temp);
_temp = pidRoll.ki * 100;
EE_WriteVariable(VirtAddVarTab[EE_PID_ROL_I],_temp);
_temp = pidRoll.kd * 100;
EE_WriteVariable(VirtAddVarTab[EE_PID_ROL_D],_temp);
_temp = pidPitch.kp * 100;
EE_WriteVariable(VirtAddVarTab[EE_PID_PIT_P],_temp);
_temp = pidPitch.ki * 100;
EE_WriteVariable(VirtAddVarTab[EE_PID_PIT_I],_temp);
_temp = pidPitch.kd * 100;
EE_WriteVariable(VirtAddVarTab[EE_PID_PIT_D],_temp);
_temp = pidYaw.kp * 100;
EE_WriteVariable(VirtAddVarTab[EE_PID_YAW_P],_temp);
_temp = pidYaw.ki * 100;
EE_WriteVariable(VirtAddVarTab[EE_PID_YAW_I],_temp);
_temp = pidYaw.kd * 100;
EE_WriteVariable(VirtAddVarTab[EE_PID_YAW_D],_temp);
}
void writeConfig()
{
uint16_t i;
int16_t *ptr = (int16_t *)&s;
for(i=0; i<sizeof(servoConfig)/2;i++)
{
if(EE_WriteVariable(EADDR_CONFIG_START+i, *ptr)!=FLASH_COMPLETE)
{
usart_sendStr("Flash Error\n\r");
}
ptr++;
}
}
/* load Parameter from virtual EEPROM ---------------------------------------*/
void loadParameter()
{
u16 val;
u16 i;
// test if flash is clear
EE_ReadVariable(401, &val);
if (val != 99)
{
loadDefault();
}
EE_WriteVariable(401, 99);
for (i = 0;i <= USED_PARAMETER; i++)
{
EE_ReadVariable(VirtAddVarTab[i], &val);
parameter[i] = val;
// for test
print_para(i);
Delay(2); // prevent txbuffer overvlow
}
}
void getConfig()
{
FLASH_Unlock();
uint16_t i;
uint16_t *ptr;
EE_Init();
EE_ReadVariable(EADDR_IS_INITIALIZED,&i);
if(i != 0x5253)
{
//empty or corrupted EEPROM detected: write default config
//EE_Format();
EE_WriteVariable(EADDR_IS_INITIALIZED, 0x5253);
s.commutationMethod = commutationMethod_HALL;
s.inputMethod = inputMethod_stepDir;
s.encoder_PPR = 4000;
s.encoder_poles = 4;
s.encoder_counts_per_step = 10;
s.pid_Kp = 10;
s.pid_Ki = 0;
s.pid_Kd = 0;
s.usart_baud = 1152;
writeConfig(s);
return;
}
ptr = (uint16_t *)&s;
for(i=0; i<sizeof(servoConfig)/2;i++)
{
if(EE_ReadVariable(EADDR_CONFIG_START+i, ptr)!=0)
usart_sendStr("Flash Error\n\r");
ptr++;
}
return;
}
void EE_SAVE_GYRO_OFFSET(void)
{
EE_WriteVariable(VirtAddVarTab[EE_6050_GYRO_X_OFFSET_ADDR], GYRO_OFFSET.X);
EE_WriteVariable(VirtAddVarTab[EE_6050_GYRO_Y_OFFSET_ADDR], GYRO_OFFSET.Y);
EE_WriteVariable(VirtAddVarTab[EE_6050_GYRO_Z_OFFSET_ADDR], GYRO_OFFSET.Z);
}
void EE_SAVE_ACC_OFFSET(void)
{
EE_WriteVariable(VirtAddVarTab[EE_6050_ACC_X_OFFSET_ADDR], ACC_OFFSET.X);
EE_WriteVariable(VirtAddVarTab[EE_6050_ACC_Y_OFFSET_ADDR], ACC_OFFSET.Y);
EE_WriteVariable(VirtAddVarTab[EE_6050_ACC_Z_OFFSET_ADDR], ACC_OFFSET.Z);
}
int main(void)
{
SystemInit();
GPIOInit();
FLASH_Unlock();
EE_Init();
USBD_Init(&USB_OTG_dev,
#ifdef USE_USB_OTG_HS
USB_OTG_HS_CORE_ID,
#else
USB_OTG_FS_CORE_ID,
#endif
&USR_desc,
&USBD_HID_cb,
&USR_cb);
bitCount = 0;
currentValue = 0;
set = 0;
ignoreNext = 0;
uppercaseNext = 0;
shiftPressed = 0;
buttonPressed = 0;
getHowMany();
int i = 0;
resetBuffer();
for(;;)
{
/*
* Po wcisnieciu przycisku nastepuje wyslanie raportu USB
* zawierajacego rejestr przycisnietych klaiwszy
*/
if (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0))
{
if (!buttonPressed)
{
buttonPressed = 1;
for (i = 0; i < 64; i++)
{
EE_ReadVariable(VirtAddVarTab[i], &InBuffer[i]);
}
USBD_HID_SendReport (&USB_OTG_dev, InBuffer, 64);
}
} else if (buttonPressed)
{
buttonPressed = 0;
}
if (checkBufferReady())
{
/*
* Jezeli zapisano 64 wcisniecia klawiszy,
* nalezy oproznic EEPROM przed kontynuacja zapisu
*
*/
if(EEPROMFull())
{
GPIO_ToggleBits(GPIOD, GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15);
continue;
}
unsetBufferReady();
startTimer();
EE_WriteVariable(VirtAddVarTab[howMany=howMany+0x01], currentChar);
EE_WriteVariable(VirtAddVarTab[63], howMany);
}
}
}
/* load default parameter to flash ------------------------------------------*/
void loadDefault()
{
//#########################################################################
// store default set if flash - only set 1
//#########################################################################
EE_WriteVariable(VirtAddVarTab[PARA_SET], 0x00);
EE_WriteVariable(VirtAddVarTab[PARA_DEBUG], 0x00);
EE_WriteVariable(VirtAddVarTab[PARA_HW], 0x01);
EE_WriteVariable(VirtAddVarTab[PARA_VOLT], 0x8BC); //2236 = 10 Volt
EE_WriteVariable(VirtAddVarTab[PARA_SW], 0x01);
EE_WriteVariable(VirtAddVarTab[PARA_ACC_X_ZERO], 0x7FF);
EE_WriteVariable(VirtAddVarTab[PARA_ACC_Y_ZERO], 0x7F1);
EE_WriteVariable(VirtAddVarTab[PARA_ACC_Z_ZERO], 0x7F8);
EE_WriteVariable(VirtAddVarTab[PARA_SMOOTH_ACC], 0x00);
EE_WriteVariable(VirtAddVarTab[PARA_SMOOTH_GYRO], 0x00);
EE_WriteVariable(VirtAddVarTab[PARA_SMOOTH_RC], 0x00);
EE_WriteVariable(VirtAddVarTab[PARA_GYRO_X_90], 0x898);
EE_WriteVariable(VirtAddVarTab[PARA_GYRO_Y_90], 0x898);
EE_WriteVariable(VirtAddVarTab[PARA_GYRO_Z_90], 0x898);
EE_WriteVariable(VirtAddVarTab[PARA_ACC_FORCE], 0x1F4);
EE_WriteVariable(VirtAddVarTab[PARA_GYRO_CORR], 0x1F4);
EE_WriteVariable(VirtAddVarTab[PARA_SERVO0_CH], 0x5);
EE_WriteVariable(VirtAddVarTab[PARA_SERVO1_CH], 0x6);
EE_WriteVariable(VirtAddVarTab[PARA_SERVO2_CH], 0x7);
EE_WriteVariable(VirtAddVarTab[PARA_SERVO3_CH], 0x8);
EE_WriteVariable(VirtAddVarTab[PARA_CAM_X], 0x5014); //servo 2 , 0, wert 500
EE_WriteVariable(VirtAddVarTab[PARA_CAM_Y], 0x7724); //servo 3 , 0, wert 500
EE_WriteVariable(VirtAddVarTab[PARA_MIN_GAS], 0x20);
//#########################################################################
u16 val;
u16 i;
for (i = 0;i <= USED_PARAMETER; i++)
{
EE_ReadVariable(VirtAddVarTab[i], &val);
parameter[i] = val;
// for test
print_para(i);
Delay(2); // prevent txbuffer overvlow
}
// info user over uart1
send(DEFAULT);
}
/* buffer: 012345 -> arguments for Write: (10)(32)(54) -> eeprom: 01,23,45 */
void eeprom_store(uint8_t virt_addr, uint8_t *buf)
{
EE_WriteVariable(virt_addr, (buf[1] << 8) | buf[0]);
EE_WriteVariable(virt_addr + 1, (buf[3] << 8) | buf[2]);
EE_WriteVariable(virt_addr + 2, (buf[5] << 8) | buf[4]);
}
/**
* @brief RTC Application runs in while loop
* @param None
* @retval : None
*/
void RTC_Application(void)
{
uint8_t ReturnValue;
CalculateTime();
if(TimeDateDisplay==0)
{
DisplayTime();
}
if(DisplayDateFlag==1 && TimeDateDisplay==0)
{
DisplayDate();
DisplayDateFlag=0;
}
if(AlarmStatus==1)
{
DisplayAlarm();
GPIO_SetBits(GPIOC, GPIO_Pin_6);
Dummy=RTC_GetCounter();
AlarmStatus=2;
}
if(((RTC_GetCounter()-Dummy) == 4) && (AlarmStatus==2))
{
GPIO_ResetBits(GPIOC, GPIO_Pin_6);
SelIntExtOnOffConfig(ENABLE);
RightLeftIntExtOnOffConfig(ENABLE);
UpDownIntOnOffConfig(ENABLE);
MenuInit();
Dummy=0;
AlarmStatus = 0;
}
if(TamperEvent == 1) /* Tamper event is detected */
{
TamperNumber = TamperNumber + 1;
BKP_WriteBackupRegister(BKP_DR5,TamperNumber);
BKP_WriteBackupRegister(BKP_DR1, CONFIGURATION_DONE);
BKP_WriteBackupRegister(BKP_DR2,s_DateStructVar.Month);
BKP_WriteBackupRegister(BKP_DR3,s_DateStructVar.Day);
BKP_WriteBackupRegister(BKP_DR4,s_DateStructVar.Year);
BKP_WriteBackupRegister(BKP_DR9,s_AlarmDateStructVar.Day);
BKP_WriteBackupRegister(BKP_DR8,s_AlarmDateStructVar.Month);
BKP_WriteBackupRegister(BKP_DR10,s_AlarmDateStructVar.Year);
BKP_WriteBackupRegister(BKP_DR6,ClockSource);
BKP_WriteBackupRegister(BKP_DR7,SummerTimeCorrect);
ReturnValue=EE_WriteVariable(TamperNumber);
if(ReturnValue==PAGE_FULL)
{
ReturnValue=EE_WriteVariable(TamperNumber);
}
ReturnValue=EE_WriteVariable(s_DateStructVar.Day);
ReturnValue=EE_WriteVariable(s_DateStructVar.Month);
ReturnValue=EE_WriteVariable((s_DateStructVar.Year)/100);
ReturnValue=EE_WriteVariable((s_DateStructVar.Year)%100);
ReturnValue=EE_WriteVariable((s_TimeStructVar.HourHigh*10)+\
s_TimeStructVar.HourLow);
ReturnValue=EE_WriteVariable((s_TimeStructVar.MinHigh*10)+\
s_TimeStructVar.MinLow);
ReturnValue=EE_WriteVariable((s_TimeStructVar.SecHigh*10)+\
s_TimeStructVar.SecLow);
while(!(GPIO_ReadInputDataBit(GPIOC, GPIO_Pin_13)))
{
}
TamperEvent=0;
BKP_TamperPinCmd(ENABLE);
}
if(BatteryRemoved != 0) /* Battery tamper is detected */
{
TamperNumber = TamperNumber + 1;
BKP_WriteBackupRegister(BKP_DR5,TamperNumber);
ReturnValue=EE_WriteVariable(TamperNumber);
if(ReturnValue==PAGE_FULL)
{
ReturnValue=EE_WriteVariable(TamperNumber);
}
ReturnValue=EE_WriteVariable(s_DateStructVar.Day);
ReturnValue=EE_WriteVariable(s_DateStructVar.Month);
ReturnValue=EE_WriteVariable((s_DateStructVar.Year)/100);
ReturnValue=EE_WriteVariable((s_DateStructVar.Year)%100);
ReturnValue=EE_WriteVariable((s_TimeStructVar.HourHigh*10)\
+s_TimeStructVar.HourLow);
ReturnValue=EE_WriteVariable((s_TimeStructVar.MinHigh*10)\
+s_TimeStructVar.MinLow);
if(BatteryRemoved==1)
{
ReturnValue=EE_WriteVariable(BATTERY_REMOVED);
BatteryRemoved=0;
}
else if(BatteryRemoved==2)
{
ReturnValue=EE_WriteVariable(BATTERY_RESTORED);
BatteryRemoved=0;
}
BKP_TamperPinCmd(ENABLE);
}
}
int main(void)
{
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* Configure the system clock */
SystemClock_Config();
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_DMA_Init();
MX_ADC_Init();
MX_SPI1_Init();
MX_USB_DEVICE_Init();
MX_TIM14_Init();
HAL_FLASH_Unlock();
EE_Init();
EE_ReadVariable(VirtAddVarTab[0], &x_low_th);
EE_ReadVariable(VirtAddVarTab[1], &x_high_th);
EE_ReadVariable(VirtAddVarTab[2], &y_low_th);
EE_ReadVariable(VirtAddVarTab[3], &y_high_th);
HAL_FLASH_Lock();
HAL_ADC_Start_DMA(&hadc, (uint32_t*)axis, 5);
while (1)
{
HAL_GPIO_WritePin(SPI1_nCS_GPIO_Port, SPI1_nCS_Pin, GPIO_PIN_SET);
HAL_TIM_Base_Start_IT(&htim14);
while (!u100ticks) /* do nothing for 100 us */;
HAL_TIM_Base_Stop_IT(&htim14);
u100ticks = 0;
HAL_StatusTypeDef status =
HAL_SPI_Receive(&hspi1, rx_buffer, sizeof(rx_buffer), 3000);
switch(status)
{
case HAL_OK:
report.buttons[0] = 0x00;
// report.buttons[1] = 0x00;
report.buttons[2] = 0x00;
if ((rx_buffer[0] & 0xff) != 0xff) // if all bits of rx_buffer[0] is 1 assume shifter is disconnected
{
if (rx_buffer[0] & 4) report.buttons[0] |= 1; else report.buttons[0] &= ~1;
if (rx_buffer[0] & 1) report.buttons[0] |= (1 << 1); else report.buttons[0] &= ~(1 << 1);
if (rx_buffer[0] & 2) report.buttons[0] |= (1 << 2); else report.buttons[0] &= ~(1 << 2);
if (rx_buffer[0] & 8) report.buttons[0] |= (1 << 3); else report.buttons[0] &= ~(1 << 3);
if (rx_buffer[1] & 1) report.buttons[2] |= 1; else report.buttons[2] &= ~1;
if (rx_buffer[1] & 2) report.buttons[2] |= (1 << 1); else report.buttons[2] &= ~(1 << 1);
if (rx_buffer[1] & 4) report.buttons[2] |= (1 << 2); else report.buttons[2] &= ~(1 << 2);
if (rx_buffer[1] & 8) report.buttons[2] |= (1 << 3); else report.buttons[2] &= ~(1 << 3);
if (rx_buffer[1] & 32) report.buttons[0] |= (1 << 4); else report.buttons[0] &= ~(1 << 4);
if (rx_buffer[1] & 128) report.buttons[0] |= (1 << 5); else report.buttons[0] &= ~(1 << 5);
if (rx_buffer[1] & 64) report.buttons[0] |= (1 << 6); else report.buttons[0] &= ~(1 << 6);
if (rx_buffer[1] & 16) report.buttons[0] |= (1 << 7); else report.buttons[0] &= ~(1 << 7);
}
break;
case HAL_TIMEOUT:
case HAL_BUSY:
case HAL_ERROR:
Error_Handler();
default:
report.buttons[0] = 0xff;
break;
}
HAL_GPIO_WritePin(SPI1_nCS_GPIO_Port, SPI1_nCS_Pin, GPIO_PIN_RESET);
report.id = 0x01;
x_axis = ((X_AXIS << 2) + x_axis * 96) / 100;
y_axis = ((Y_AXIS << 2) + y_axis * 96) / 100;
if (rx_buffer[0] & 16)
{
if (y_axis < y_low_th) // stick towards player
{
report.buttons[1] = 128;
report.buttons[2] &= ~(1 << 4);
}
else if (y_axis > y_high_th) // stick opposite to player
{
report.buttons[1] = 0; // neutral
report.buttons[2] |= (1 << 4);
}
else
{
report.buttons[1] = 0; // neutral
report.buttons[2] &= ~(1 << 4);
}
}
else
{
report.buttons[1] &= ~(1 << 7);
report.buttons[2] &= ~(1 << 4);
if (y_axis < y_low_th) // stick towards player
{
if (x_axis < x_low_th)
{
if (!report.buttons[1]) report.buttons[1] = 2; // 2nd gear
}
else if (!report.buttons[1])
{
report.buttons[1] = (x_axis > x_high_th) ? ((rx_buffer[0] & 64) ? 64 : 32) : 8;
}
}
else
{
if (y_axis > y_high_th) // stick opposite to player
{
if (x_axis < x_low_th)
{
if (!report.buttons[1]) report.buttons[1] = 1; // 1st gear
}
else if (!report.buttons[1])
{
report.buttons[1] = (x_axis > x_high_th) ? 16 : 4;
}
}
else
{
report.buttons[1] = 0; // neutral
}
}
}
report.axis[0] = x_axis;
report.axis[1] = y_axis;
if (report2send == 2)
{
HAL_FLASH_Unlock();
EE_WriteVariable(VirtAddVarTab[0], x_low_th);
EE_WriteVariable(VirtAddVarTab[1], x_high_th);
EE_WriteVariable(VirtAddVarTab[2], y_low_th);
EE_WriteVariable(VirtAddVarTab[3], y_high_th);
HAL_FLASH_Lock();
report2send = 0;
}
if (hUsbDeviceFS.pClassData
&& ((USBD_HID_HandleTypeDef *)hUsbDeviceFS.pClassData)->state == HID_IDLE)
{
USBD_HID_SendReport(&hUsbDeviceFS, (uint8_t *)&report, sizeof(report));
}
}
}
/*====================================================================================================*/
void EE_SAVE_MAG_OFFSET(void)
{
u8 cy;
for(cy=0;cy<6;cy++)
EE_WriteVariable(VirtAddVarTab[3+cy],*(mag_limt+cy));
}
/*====================================================================================================*/
void EE_SAVE_ACC_OFFSET(void)
{
EE_WriteVariable(VirtAddVarTab[0],sensor.acc.quiet.x);
EE_WriteVariable(VirtAddVarTab[1],sensor.acc.quiet.y);
EE_WriteVariable(VirtAddVarTab[2],sensor.acc.quiet.z);
}
int main(void)
{
/*!< At this stage the microcontroller clock setting is already configured,
this is done through SystemInit() function which is called from startup
file (startup_stm32f4xx.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f4xx.c file
*/
//initiate user button
PB_Config();
//initiate LEDs and turn them on
LED_Config();
/* -----------------------------------------------------------------------
TIM3 Configuration: Output Compare Timing Mode:
In this example TIM3 input clock (TIM3CLK) is set to 2 * APB1 clock (PCLK1),
since APB1 prescaler is different from 1.
TIM3CLK = 2 * PCLK1
PCLK1 = HCLK / 4
=> TIM3CLK = HCLK / 2 = SystemCoreClock /2
To get TIM3 counter clock at 50 MHz, the prescaler is computed as follows:
Prescaler = (TIM3CLK / TIM3 counter clock) - 1
Prescaler = ((SystemCoreClock /2) /0.5 MHz) - 1
CC1 update rate = TIM3 counter clock / CCR1_Val = 10.0 Hz
==> Toggling frequency = 5 Hz
Note:
SystemCoreClock variable holds HCLK frequency and is defined in system_stm32f4xx.c file.
Each time the core clock (HCLK) changes, user had to call SystemCoreClockUpdate()
function to update SystemCoreClock variable value. Otherwise, any configuration
based on this variable will be incorrect.
----------------------------------------------------------------------- */
//=======================Configure and init Timer======================
/* Compute the prescaler value */
PrescalerValue = (uint16_t) ((SystemCoreClock / 2) / 500000) - 1;
/* TIM Configuration */
TIM3_Config();
// configure the output compare
TIM3_OCConfig();
/* TIM Interrupts enable */
TIM_ITConfig(TIM3, TIM_IT_CC1, ENABLE);
/* TIM3 enable counter */
TIM_Cmd(TIM3, ENABLE);
//======================================configure and init LCD ======================
/* LCD initiatization */
LCD_Init();
/* LCD Layer initiatization */
LCD_LayerInit();
/* Enable the LTDC */
LTDC_Cmd(ENABLE);
/* Set LCD foreground layer */
LCD_SetLayer(LCD_FOREGROUND_LAYER);
//================EEPROM init====================================
/* Unlock the Flash Program Erase controller */
FLASH_Unlock();
/* EEPROM Init */
EE_Init();
//============ Set up for random number generation==============
RNG_Config();
//with the default font, LCD can display 12 lines of chars, they are LINE(0), LINE(1)...LINE(11)
//with the default font, LCD can display 15 columns, they are COLUMN(0)....COLUMN(14)
LCD_Clear(LCD_COLOR_WHITE);
LCD_DisplayStringLine(LINE(0), (uint8_t *) "Attempt");
LCD_DisplayStringLine(LINE(2), (uint8_t *) "Record");
EE_WriteVariable(VirtAddVarTab[0],VarValue);
EE_ReadVariable(VirtAddVarTab[0], &VarDataTab[0]);
sprintf(str, "%d", VarDataTab[0]);
//LCD_DisplayStringLine(LINE(3), (uint8_t *) str);
//randomNumber = RNG_GetRandomNumber()/100000;
//sprintf(str, "%d", randomNumber());
//LCD_DisplayStringLine(LINE(5), (uint8_t *) str);
resetTimer();
/*the following while loop is where the main part of the code is
* it currently uses the userbutton on board since Mario forgot to bring along his
* jumper cables to test out the push button part
*/
//if toggle = 0 lights are blinking
//if toggle = 1 2 second wait
//if toggle = 2 LED toggle off, the lights stay on
//@TODO add external push button to code
externalButton();
while (1){
int num = TIM_GetCounter(TIM3);
//This is for the start of the procedure
if(toggle==0){
if(num == 3000){
STM_EVAL_LEDOn(LED3);
STM_EVAL_LEDOn(LED4);
}
else if(num == 6000){
STM_EVAL_LEDOff(LED3);
STM_EVAL_LEDOff(LED4);
resetTimer();
}
}
//if the user button has been pressed and the lights are blinking
if (UBPressed==1 && toggle==0) {
STM_EVAL_LEDOff(LED3);
STM_EVAL_LEDOff(LED4);
UBPressed=0;
PB_Config();
resetTimerLong();
toggle = 1;
rand = randomNumber();//generate a random number
}
//this is the to get the wait time for the reaction test.
if(toggle==1){
if(num == rand){ //if num is equal to the ramdom gened number turn on the LEDs and reset the timer
STM_EVAL_LEDOn(LED3);
STM_EVAL_LEDOn(LED4);
resetTimerLong();
}
}
//this is the code for when the reaction timer has gone off
if (UBPressed==1 && toggle==1) {
//this if statement is to prevent cheating
//if the number = 0 it means that the user cheated as someone should not be able to get 0
if(num == 0){
ExtButtonPressed=0;
PB_Config();
externalButton();
resetTimer();
toggle = 0;
}else{
sprintf(str, "%d", num);
//this block of code writes to the LCD the lastest user reaction time.
LCD_DisplayStringLine(LINE(1), (uint8_t *) " ");
LCD_DisplayStringLine(LINE(1), (uint8_t *) str);
EE_ReadVariable(VirtAddVarTab[0], &VarDataTab[0]);
//this if statement determines wheter the user has beat their best reaction time
if(num < VarDataTab[0]){
VarValue = num;
EE_WriteVariable(VirtAddVarTab[0],VarValue);
}
/*the following block of code writes to the LCD the record reaction time*/
EE_ReadVariable(VirtAddVarTab[0], &VarDataTab[0]);
sprintf(str, "%d", VarDataTab[0]);
LCD_DisplayStringLine(LINE(3), (uint8_t *) " ");
LCD_DisplayStringLine(LINE(3), (uint8_t *) str);
UBPressed=0;
PB_Config();
resetTimerLong();
toggle = 2;
}
}
//the user needs to press the button to get the reaction time game going again.
//to reset the reaction timer
if (ExtButtonPressed==1) {
ExtButtonPressed=0;
PB_Config();
externalButton();
resetTimer();
toggle = 0;
}
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/* Enable the CPU Cache */
CPU_CACHE_Enable();
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* Configure the system clock to have a system clock = 180 Mhz */
SystemClock_Config();
/* Unlock the Flash Program Erase controller */
HAL_FLASH_Unlock();
/* Configure LED1 */
BSP_LED_Init(LED1);
/* EEPROM Init */
if( EE_Init() != EE_OK)
{
Error_Handler();
}
/* --- Store successively many values of the three variables in the EEPROM ---*/
/* Store 0x1000 values of Variable1 in EEPROM */
for (VarValue = 1; VarValue <= 0x1000; VarValue++)
{
/* Sequence 1 */
if((EE_WriteVariable(VirtAddVarTab[0], VarValue)) != HAL_OK)
{
Error_Handler();
}
if((EE_ReadVariable(VirtAddVarTab[0], &VarDataTab[0])) != HAL_OK)
{
Error_Handler();
}
if (VarValue != VarDataTab[0])
{
Error_Handler();
}
/* Sequence 2 */
if(EE_WriteVariable(VirtAddVarTab[1], ~VarValue) != HAL_OK)
{
Error_Handler();
}
if(EE_ReadVariable(VirtAddVarTab[1], &VarDataTab[1]) != HAL_OK)
{
Error_Handler();
}
if(((uint16_t)~VarValue) != VarDataTab[1])
{
Error_Handler();
}
/* Sequence 3 */
if(EE_WriteVariable(VirtAddVarTab[2], VarValue << 1) != HAL_OK)
{
Error_Handler();
}
if(EE_ReadVariable(VirtAddVarTab[2], &VarDataTab[2]) != HAL_OK)
{
Error_Handler();
}
if ((VarValue << 1) != VarDataTab[2])
{
Error_Handler();
}
}
/* Store 0x2000 values of Variable2 in EEPROM */
for (VarValue = 1; VarValue <= 0x2000; VarValue++)
{
if(EE_WriteVariable(VirtAddVarTab[1], VarValue) != HAL_OK)
{
Error_Handler();
}
if(EE_ReadVariable(VirtAddVarTab[1], &VarDataTab[1]) != HAL_OK)
{
Error_Handler();
}
if(VarValue != VarDataTab[1])
{
Error_Handler();
}
}
/* read the last stored variables data*/
if(EE_ReadVariable(VirtAddVarTab[0], &VarDataTmp) != HAL_OK)
{
Error_Handler();
}
if (VarDataTmp != VarDataTab[0])
{
Error_Handler();
}
if(EE_ReadVariable(VirtAddVarTab[1], &VarDataTmp) != HAL_OK)
{
Error_Handler();
}
if (VarDataTmp != VarDataTab[1])
{
Error_Handler();
}
if(EE_ReadVariable(VirtAddVarTab[2], &VarDataTmp) != HAL_OK)
{
Error_Handler();
}
if (VarDataTmp != VarDataTab[2])
{
Error_Handler();
}
/* Store 0x3000 values of Variable3 in EEPROM */
for (VarValue = 1; VarValue <= 0x3000; VarValue++)
{
if(EE_WriteVariable(VirtAddVarTab[2], VarValue) != HAL_OK)
{
Error_Handler();
}
if(EE_ReadVariable(VirtAddVarTab[2], &VarDataTab[2]) != HAL_OK)
{
Error_Handler();
}
if(VarValue != VarDataTab[2])
{
Error_Handler();
}
}
/* read the last stored variables data*/
if(EE_ReadVariable(VirtAddVarTab[0], &VarDataTmp) != HAL_OK)
{
Error_Handler();
}
if (VarDataTmp != VarDataTab[0])
{
Error_Handler();
}
if(EE_ReadVariable(VirtAddVarTab[1], &VarDataTmp) != HAL_OK)
{
Error_Handler();
}
if (VarDataTmp != VarDataTab[1])
{
Error_Handler();
}
if(EE_ReadVariable(VirtAddVarTab[2], &VarDataTmp) != HAL_OK)
{
Error_Handler();
}
if (VarDataTmp != VarDataTab[2])
{
Error_Handler();
}
while (1)
{
/* Turn LED1 On */
BSP_LED_On(LED1);
}
}
/* load default parameter to flash ------------------------------------------*/
void loadDefault()
{
//#########################################################################
// store default set if flash - only set 1
//#########################################################################
EE_WriteVariable(VirtAddVarTab[PARA_SET], 0);
EE_WriteVariable(VirtAddVarTab[PARA_DEBUG], 0);
EE_WriteVariable(VirtAddVarTab[PARA_HW], 3); //0=RC,1=PC,2=MotMix,4=Compass
EE_WriteVariable(VirtAddVarTab[PARA_VOLT], 2236); //2236 = 10 Volt
EE_WriteVariable(VirtAddVarTab[PARA_SW], 1); //0=HH,1=acc,2=comp2, 3=DCM
EE_WriteVariable(VirtAddVarTab[PARA_ACC_X_ZERO], 20536); //20470
EE_WriteVariable(VirtAddVarTab[PARA_ACC_Y_ZERO], 20369); //20330
EE_WriteVariable(VirtAddVarTab[PARA_ACC_Z_ZERO], 20452); //24450
EE_WriteVariable(VirtAddVarTab[PARA_SMOOTH_ACC], 200);
EE_WriteVariable(VirtAddVarTab[PARA_STICK_FACTOR], 20);
EE_WriteVariable(VirtAddVarTab[PARA_SMOOTH_RC], 00);
EE_WriteVariable(VirtAddVarTab[PARA_GYRO_X_90], 2200);
EE_WriteVariable(VirtAddVarTab[PARA_GYRO_Y_90], 2200);
EE_WriteVariable(VirtAddVarTab[PARA_GYRO_Z_90], 2200);
EE_WriteVariable(VirtAddVarTab[PARA_ACC_FORCE], 300); //50
EE_WriteVariable(VirtAddVarTab[PARA_GYRO_CORR], 50); //25
EE_WriteVariable(VirtAddVarTab[PARA_SERVO0_CH], 5); //Kanal 5
EE_WriteVariable(VirtAddVarTab[PARA_SERVO1_CH], 6); //Kanal 6
EE_WriteVariable(VirtAddVarTab[PARA_SERVO2_CH], 7); //Kanal 7
EE_WriteVariable(VirtAddVarTab[PARA_SERVO3_CH], 8); //Kanal 8
EE_WriteVariable(VirtAddVarTab[PARA_CAM_X], 20500); //servo 2 , 0, wert 500
EE_WriteVariable(VirtAddVarTab[PARA_CAM_Y], 30500); //servo 3 , 0, wert 500
EE_WriteVariable(VirtAddVarTab[PARA_MIN_GAS], 10); // min gas 24
EE_WriteVariable(VirtAddVarTab[PARA_P_X], 1000); //23:1000
EE_WriteVariable(VirtAddVarTab[PARA_I_X], 0); //24:
EE_WriteVariable(VirtAddVarTab[PARA_D_X], 3000); //25:3000
EE_WriteVariable(VirtAddVarTab[PARA_P_Y], 1000); //26:
EE_WriteVariable(VirtAddVarTab[PARA_I_Y], 0); //27:
EE_WriteVariable(VirtAddVarTab[PARA_D_Y], 3000); //28:
EE_WriteVariable(VirtAddVarTab[PARA_P_Z], 0); //29:
EE_WriteVariable(VirtAddVarTab[PARA_I_Z], 0); //30:
EE_WriteVariable(VirtAddVarTab[PARA_D_Z], 0); //31:
EE_WriteVariable(VirtAddVarTab[PARA_COMP_CORR_X], 0);
EE_WriteVariable(VirtAddVarTab[PARA_COMP_CORR_Y], 0);
EE_WriteVariable(VirtAddVarTab[PARA_COMP_CORR_Z], 0);
EE_WriteVariable(VirtAddVarTab[PARA_COMP_DECL], 0);
EE_WriteVariable(VirtAddVarTab[PARA_COMP_FORCE], 0);
EE_WriteVariable(VirtAddVarTab[PARA_MIXER_MOT1A], 25600); //100, 0
EE_WriteVariable(VirtAddVarTab[PARA_MIXER_MOT1B], 40092); //-100, -100
EE_WriteVariable(VirtAddVarTab[PARA_MIXER_MOT2A], 25600); //100, 0
EE_WriteVariable(VirtAddVarTab[PARA_MIXER_MOT2B], 25756); //100, -100
EE_WriteVariable(VirtAddVarTab[PARA_MIXER_MOT3A], 25700); //100, 100
EE_WriteVariable(VirtAddVarTab[PARA_MIXER_MOT3B], 100); //0, 100
EE_WriteVariable(VirtAddVarTab[PARA_MIXER_MOT4A], 25828); //100, -100
EE_WriteVariable(VirtAddVarTab[PARA_MIXER_MOT4B], 100); //0, 100
EE_WriteVariable(VirtAddVarTab[PARA_MIXER_MOT5A], 25600); //100, 0 - Motor not used
EE_WriteVariable(VirtAddVarTab[PARA_MIXER_MOT5B], 25600);
EE_WriteVariable(VirtAddVarTab[PARA_MIXER_MOT6A], 25600);
EE_WriteVariable(VirtAddVarTab[PARA_MIXER_MOT6B], 25600);
EE_WriteVariable(VirtAddVarTab[PARA_MIXER_MOT7A], 25600);
EE_WriteVariable(VirtAddVarTab[PARA_MIXER_MOT7B], 25600);
EE_WriteVariable(VirtAddVarTab[PARA_MIXER_MOT8A], 25600);
EE_WriteVariable(VirtAddVarTab[PARA_MIXER_MOT8B], 25600);
EE_WriteVariable(VirtAddVarTab[PARA_MIXER_MOT9A], 25600);
EE_WriteVariable(VirtAddVarTab[PARA_MIXER_MOT9B], 25600);
EE_WriteVariable(VirtAddVarTab[PARA_MIXER_MOT10A], 25600);
EE_WriteVariable(VirtAddVarTab[PARA_MIXER_MOT10B], 25600);
EE_WriteVariable(VirtAddVarTab[PARA_MIXER_MOT11A], 25600);
EE_WriteVariable(VirtAddVarTab[PARA_MIXER_MOT11B], 25600);
EE_WriteVariable(VirtAddVarTab[PARA_MIXER_MOT12A], 25600);
EE_WriteVariable(VirtAddVarTab[PARA_MIXER_MOT12B], 25600);
//#########################################################################
u16 val;
u16 i;
for (i = 0;i <= USED_PARAMETER; i++)
{
EE_ReadVariable(VirtAddVarTab[i], &val);
parameter[i] = val;
// for test
print_para(i);
Delay(2); // prevent txbuffer overvlow
}
// info user over uart1
send(DEFAULT);
}
