/**
* @brief Main program.
* @param None
* @retval None
*/
void main(void)
{
u8 l_cnt;
disableInterrupts();
Config();
Errors_Init();
enableInterrupts();
Goto_HALT();
while (1)
{
if((btn_pressed != BUTTON1) && (btn_pressed != BUTTON2))
{
DELAY_STOP;
goto sleep;
}
while(!DELAY_EXPIRED); // wait for power-up delay to expire (~20ms)
DELAY_STOP;
disableInterrupts();
if(btn_pressed == BUTTON1)
{
RF_Send(RFCMD_HEATING_ON);
}
else if(btn_pressed = BUTTON2)
{
RF_Send(RFCMD_HEATING_OFF);
}
enableInterrupts();
sleep:
Goto_HALT();
}
}
/*
Function: Measures actual radiation value during specified time. Maximum time is 60 seconds
Returns:
RadiationValueCPM: radiation value in CPM
Parameters:
time: time while radiation is measured. Time must be in milliseconds
Values:
*/
float WaspRadiationBoard::getCPM(long time)
{
float k=0;
float minute = 60000;
unsigned long previous=millis();
enableInterrupts(RAD_INT);
while( (millis()-previous<time) )
{
if( intFlag & RAD_INT)
{
disableInterrupts(RAD_INT);
intFlag &= ~(RAD_INT);
countPulse();
while(!digitalRead(RAD_INT_PIN_MON));
enableInterrupts(RAD_INT);
}
// Condition to avoid an overflow (DO NOT REMOVE)
if( millis() < previous ) previous=millis();
}
k = (minute/time);
radiationValueCPM = k*count ;
timePreviousMeassure = millis();
ledBar(k*count);
count = 0;
return radiationValueCPM;
}
/*
Function: Measures actual radiation value during 10 seconds.
Returns:
radiationValue: Returns value of radiation in uSv/H
Parameters:
Values:
*/
float WaspRadiationBoard::getRadiationInt()
{
unsigned long timeRepeat= 10000;
unsigned long previous=millis();
enableInterrupts(RAD_INT);
while( (millis()-previous<timeRepeat) )
{
if( intFlag & RAD_INT){
disableInterrupts(RAD_INT);
intFlag &= ~(RAD_INT);
countPulse();
while(!digitalRead(RAD_INT_PIN_MON));
enableInterrupts(RAD_INT);
}
// Condition to avoid an overflow (DO NOT REMOVE)
if( millis() < previous ) previous = millis();
}
radiationValue = 6.0 *count * CONV_FACTOR;
timePreviousMeassure = millis();
ledBar(6*count);
count = 0;
return radiationValue;
}
/**
* @brief Main program.
* @param None
* @retval None
*/
void main(void)
{
/* CLK configuration -------------------------------------------*/
CLK_Config();
/* Init TIM2 to generate 1 ms time base update interrupt */
TimingDelay_Init();
/* Enable Interrupts */
enableInterrupts();
/* Initialize LEDs mounted on STM8L152X-EVAL board */
STM_EVAL_LEDInit(LED1);
STM_EVAL_LEDInit(LED2);
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED4);
/* Turn on LED1 and LED3 */
STM_EVAL_LEDOn(LED1);
STM_EVAL_LEDOn(LED3);
/* Initialize push-buttons mounted on STM8L152X-EVAL board */
STM_EVAL_PBInit(BUTTON_RIGHT, BUTTON_MODE_EXTI);
STM_EVAL_PBInit(BUTTON_LEFT, BUTTON_MODE_EXTI);
STM_EVAL_PBInit(BUTTON_UP, BUTTON_MODE_EXTI);
STM_EVAL_PBInit(BUTTON_DOWN, BUTTON_MODE_EXTI);
/* Init the Eval board LCD */
STM8_EVAL_LCD_Init();
/* Clear LCD */
LCD_Clear();
/* Enable general interrupts */
enableInterrupts();
LCD_SetCursorPos(LCD_LINE1, 0);
LCD_Print(" System Clock ");
LCD_SetCursorPos(LCD_LINE2, 0);
LCD_Print(" Source: HSE ");
while (1)
{
/* Toggle LED2 and LED4 */
STM_EVAL_LEDToggle(LED2);
STM_EVAL_LEDToggle(LED4);
/* Insert a delay */
Delay(10);
/* Toggle LED1 and LED3 */
STM_EVAL_LEDToggle(LED1);
STM_EVAL_LEDToggle(LED3);
/* Insert a delay */
Delay(10);
}
}
void timer4_init ()
{
timer4.setPsc (Btimer::div128);
timer4.setArr (125);
enableInterrupts();
timer4.interrupt (true);
enableInterrupts();
timer4.start ();
}
int main()
{
// Chip errata
CHIP_Init();
// ensure core frequency has been updated
SystemCoreClockUpdate();
// start clocks
initClocks();
// init LEDs
LED_Init();
// init scheduler
SCHEDULER_Init();
// enable timers
enableTimers();
// enable interrupts
enableInterrupts();
// init tasks
SCHEDULER_TaskInit(&radio_task, radio_task_entrypoint);
// run
SCHEDULER_Run();
}
/**
* @brief Configure UART1 for the communication with HyperTerminal
* @param None
* @retval None
*/
static void UART1_Config(void)
{
/* EVAL COM (UART) configuration -----------------------------------------*/
/* USART configured as follow:
- BaudRate = 115200 baud
- Word Length = 8 Bits
- One Stop Bit
- Odd parity
- Receive and transmit enabled
- UART Clock disabled
*/
UART1_Init((uint32_t)115200, UART1_WORDLENGTH_8D,UART1_STOPBITS_1, UART1_PARITY_ODD,
UART1_SYNCMODE_CLOCK_DISABLE, UART1_MODE_TXRX_ENABLE);
/* Enable the UART Receive interrupt: this interrupt is generated when the UART
receive data register is not empty */
UART1_ITConfig(UART1_IT_RXNE_OR, ENABLE);
/* Enable the UART Transmit complete interrupt: this interrupt is generated
when the UART transmit Shift Register is empty */
UART1_ITConfig(UART1_IT_TXE, ENABLE);
/* Enable UART */
UART1_Cmd(ENABLE);
/* Enable general interrupts */
enableInterrupts();
}
/**
******************************************************************************
* @brief Modify the tick values for specific cases when the H/W timer doesn't
* work (halt, ...).
* @param [in] Delay Time to add to the ticks (unit is 500 us). Range is [1..65535].
* @retval void None
* @par Required preconditions:
* None
******************************************************************************
*/
void TSL_Timer_Adjust(u16 Delay)
{
disableInterrupts();
do
{
if (Delay > TICK_FACTOR_10MS) /* delay > 10ms */
{
TSL_Tick_Base += TICK_FACTOR_10MS;
Delay -= TICK_FACTOR_10MS;
TSL_Timer_Check_10ms_Tick();
}
else
{
TSL_Tick_Base++;
Delay--;
TSL_Timer_Check_10ms_Tick();
}
}
while ( Delay );
enableInterrupts();
}
/*
Function: Measures actual radiation value during specified time. Maximum measure time is 60 seconds
Returns:
radiationValue: Returns value of radiation in uSv/H
Parameters:
time: time while radiation is measured. Time units must be milliseconds
Values:
*/
float WaspSensorRadiation::getRadiation(long time){
float k=0; //used to obtain CPM
float minute = 60000;
long previous=millis();
while( (millis()-previous<time) )
{
if( intFlag & RAD_INT){
disableInterrupts(RAD_INT);
intFlag &= ~(RAD_INT);
countPulse();
while(!digitalRead(RAD_INT_PIN_MON));
enableInterrupts(RAD_INT);
}
// Condition to avoid an overflow (DO NOT REMOVE)
if( millis()-previous < 0 ) previous=millis();
}
k = (minute/time);
radiationValueCPM = k*count;
radiationValue = k*count * CONV_FACTOR;
timePreviousMeassure = millis();
ledBar(k*count);
count = 0;
return radiationValue;
}
int main() {
SYSTEMConfigPerformance(10000000); //Configures low-level system parameters for 10 MHz clock
enableInterrupts(); //This function is necessary to use interrupts.
//TODO: Write each initialization function
initLEDs();
initTimer1();
while(1) {
switch(state) {
case led1:
LATDbits.LATD0 = ON;
LATDbits.LATD1 = OFF;
LATDbits.LATD2 = OFF;
break;
case led2:
LATDbits.LATD0 = OFF;
LATDbits.LATD1 = ON;
LATDbits.LATD2 = OFF;
break;
case led3:
LATDbits.LATD0 = OFF;
LATDbits.LATD1 = OFF;
LATDbits.LATD2 = ON;
break;
}
}
return 0;
}
/**
******************************************************************************
* @brief Initialize memory API and structures.
* @par Parameters:
* None
* @retval void None
* @par Required preconditions:
* Must be run once in the main function during initialization phase.
******************************************************************************
*/
void TSL_Init(void)
{
disableInterrupts();
DetectionIntegrator = DETECTION_INTEGRATOR_DEFAULT;
EndDetectionIntegrator = END_DETECTION_INTEGRATOR_DEFAULT;
ECSTimeStep = ECS_TIME_STEP_DEFAULT;
ECSTemporization = ECS_TEMPO_DEFAULT;
RecalibrationIntegrator = RECALIBRATION_INTEGRATOR_DEFAULT;
DetectionTimeout = DTO_DEFAULT;
ECS_K_Fast = ECS_IIR_KFAST_DEFAULT;
ECS_K_Slow = ECS_IIR_KSLOW_DEFAULT;
ECSTimeStepCounter = ECSTimeStep;
ECSTempoCounter = 0;
ECSTempoPrescaler = 0;
TSL_IO_Init();
TSL_Timer_Init();
TSL_SCKey_Init();
#if NUMBER_OF_MULTI_CHANNEL_KEYS > 0
TSL_MCKey_Init();
#endif
enableInterrupts();
TSLState = TSL_IDLE_STATE;
}
int main() {
bool newreadings;
bool buttonschanged;
load_init();
initsystem();
watchdog_init();
initserial();
timer_init();
display_init();
initfan();
adc_init();
buttons_init();
enableInterrupts();
protocol_onbooted();
while (1) {
watchdog_kick();
newreadings = adc_updatereadings();
if (newreadings) {
checkstate();
}
buttonschanged = buttons_check();
if (newreadings || buttonschanged) {
protocol_sendstate();
display_update();
}
protocol_checkcommand();
}
}
void mcs_turn(int32_t a)
{
/* a the angle in degrees */
/* degrees to ticks */
uint32_t enc = (abs(a) * 10) / 37 - 3;
disableInterrupts();
/* turn left or right */
if (a < 0)
{
ldir = 0;
rdir = 1;
}
else
{
ldir = 1;
rdir = 0;
}
do_encoder(enc);
enableInterrupts();
}
void mcs_move(int32_t d)
{
/* d the distance in cms */
/* convert distance to tick */
uint32_t enc = abs(d) * CONFIG_TICK_PER_CM;
disableInterrupts();
/* forward or backward direction */
if (d < 0)
{
ldir = 0;
rdir = 0;
}
else
{
ldir = 1;
rdir = 1;
}
do_encoder();
enableInterrupts();
}
int main()
{
enableInterrupts();
initTMR2();
char key = 'x';
while(1);
{
clearLCD();
InitKeyPad();
switch(state)
{
case findKey:
ScanKeys(); //should i update the key value here?
break;
case debouncePress:
delayUs(5000); //Proper Delay?
break;
case debounceRelease:
delayUs(5000);
break;
case display:
printCharLCD(key);
break;
}
}
}
void TIM2_IRQHandler(void)
{
/* 10hz frequency */
/* todo: reduce the scope by capturing variables */
disableInterrupts();
/* forward */
if ((dir != 1) || (speed <= 0)) goto on_done;
if (lenc < speed) lpwm += 2; /* I_up */
else if (lenc > speed) lpwm -= 2;
if (renc < speed) rpwm += 2;
else if (renc > speed) rpwm -= 2;
err = clamp(err + lenc - renc, -128, 128);
/* reset encoder counters */
lenc = 0;
renc = 0;
lpwm = clamp(CONFIG_START_POWER_FWD + lpwm - err, 0, 255);
rpwm = clamp(CONFIG_START_POWER_FWD + rpwm - err, 0, 255);
set_lpwm(lpwm);
set_rpwm(rpwm);
on_done:
TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
enableInterrupts();
}
/**
* Enable interrupts to occur on this input.
* Interrupts are disabled when the RequestInterrupt call is made. This gives
* time to do the
* setup of the other options before starting to field interrupts.
*/
void InterruptableSensorBase::EnableInterrupts() {
if (StatusIsFatal()) return;
wpi_assert(m_interrupt != nullptr);
int32_t status = 0;
enableInterrupts(m_interrupt, &status);
wpi_setErrorWithContext(status, getHALErrorMessage(status));
}
/*主程序*/
void main()
{
CLK_Config();
CLK_PeripheralClockConfig(CLK_PERIPHERAL_TIMER2, ENABLE);
CLK_PeripheralClockConfig(CLK_PERIPHERAL_TIMER3, ENABLE);
/* Check if the system has resumed from IWDG reset */
if (RST_GetFlagStatus(RST_FLAG_IWDGF) != RESET)
{
/* Clear IWDGF Flag */
RST_ClearFlag(RST_FLAG_IWDGF);
}
/*通信串口初始化*/
DBG_Config();
IR_Init();
printf("starting...\n");
/*打开全局中断*/
enableInterrupts();
while (1)
{
IR_Process();
}
}
int main(void)
{
SYSTEMConfigPerformance(10000000);
initTimer1();
initSW2();
initLEDs();
enableInterrupts();
state = led1;
while(1)
{
//TODO: Using a finite-state machine, define the behavior of the LEDs
//Debounce the switch
switch(state) {
case led1:
turnOnLED(1);
stateNext = led2;
break;
case led2:
turnOnLED(2);
stateNext = led1;
break;
case deBounce1:
delayUs(10000);
break;
case deBounce2:
delayUs(10000);
break;
}
}
return 0;
}
/**
* @brief Configure ADC and Analog watchdog
* @param None
* @retval None
*/
static void ADC_Config(void)
{
/* Enable ADC1 clock */
CLK_PeripheralClockConfig(CLK_Peripheral_ADC1, ENABLE);
/* Initialise and configure ADC1 */
ADC_Init(ADC1, ADC_ConversionMode_Continuous, ADC_Resolution_12Bit, ADC_Prescaler_2);
ADC_SamplingTimeConfig(ADC1, ADC_Group_SlowChannels, ADC_SamplingTime_384Cycles);
/* Enable ADC1 */
ADC_Cmd(ADC1, ENABLE);
/* Enable ADC1 Channel 3 */
ADC_ChannelCmd(ADC1, ADC_Channel_3, ENABLE);
/* Calculate Threshold data value*/
HighThresholdData = (uint16_t)(((uint32_t)HIGH_THRESHOLD_VOLTAGE * 1000) / (uint32_t)ADC_RATIO) ;
LowThresholdData = (uint16_t)(((uint32_t)LOW_THRESHOLD_VOLTAGE * 1000) / (uint32_t)ADC_RATIO) ;
/* Configure Analog Watchdog selected channel and Thresholds */
ADC_AnalogWatchdogConfig(ADC1, ADC_AnalogWatchdogSelection_Channel3,
HighThresholdData,
LowThresholdData);
/* Enable Analog watchdog ADC1 Interrupt */
ADC_ITConfig(ADC1, ADC_IT_AWD, ENABLE);
/* Enable Interrupts */
enableInterrupts();
/* Start ADC1 Conversion using Software trigger*/
ADC_SoftwareStartConv(ADC1);
}
int kickoff() {
initVideo();
putStr("Hello World! - Team Virtua!!!\n");
installDescriptorTables();
installTimer();
installKeyboard();
initializePaging();
putStr("Hello, paging world! - Team Virtua !!!\n");
enableInterrupts();
// u32 end_addr = (u32)&end;
// u32 *ptr = (u32 *)end_addr;
// while(1) {
// putStr("End Address : ");
// putHex(end_addr);
// putStr(" ");
// putHex((u32)ptr);
// putStr(" : ");
// putNum(*ptr);
// putStr("\n");
// ptr++;
// }
putStr("Gotcha!!!\n");
for (;;);
return 0;
}
/**
******************************************************************************
* @brief Initialize all the TS keys
* @par Parameters:
* None
* @retval void None
* @par Required preconditions:
* None
******************************************************************************
*/
void ExtraCode_Init(void)
{
u8 i;
/* All keys are implemented and enabled */
for (i = 0; i < NUMBER_OF_SINGLE_CHANNEL_KEYS; i++)
{
sSCKeyInfo[i].Setting.b.IMPLEMENTED = 1;
sSCKeyInfo[i].Setting.b.ENABLED = 1;
sSCKeyInfo[i].DESGroup = 0x01; /* Put 0x00 to disable the DES on these pins */
}
#if NUMBER_OF_MULTI_CHANNEL_KEYS > 0
for (i = 0; i < NUMBER_OF_MULTI_CHANNEL_KEYS; i++)
{
sMCKeyInfo[i].Setting.b.IMPLEMENTED = 1;
sMCKeyInfo[i].Setting.b.ENABLED = 1;
sMCKeyInfo[i].DESGroup = 0x01; /* Put 0x00 to disable the DES on these pins */
}
#endif
enableInterrupts();
}
/**
******************************************************************************
* @brief Modify the tick values for specific cases when the H/W timer doesn't
* work (halt, ...).
* @param[in] adjust_delay Time to add to the ticks (unit is 500µs).
* @retval None
******************************************************************************
*/
void TSL_Timer_Adjust(uint32_t adjust_delay)
{
disableInterrupts();
do
{
if (adjust_delay > TICK_FACTOR_10MS)
{
TSL_Tick_Base += TICK_FACTOR_10MS;
adjust_delay -= TICK_FACTOR_10MS;
TSL_Timer_Check_10ms_Tick();
}
else
{
TSL_Tick_Base++;
adjust_delay--;
TSL_Timer_Check_10ms_Tick();
}
}
while (adjust_delay);
enableInterrupts();
}
void main(void)
{
char x=10;
char y=10;
CLK->CKDIVR = 0;
disableInterrupts();
Init_GPIO();
Init_TIM1();
Init_Clock();
usb_init();
enableInterrupts();
while(usb_ready == 0)
{
usb_process();
}
while(1)
{
delay(100);
if(get_random_byte()>127)
{
x=-x;
y=-y;
}
data_buffer[0] = 0x00;
data_buffer[1] = x;
data_buffer[2] = y;
data_buffer[3] = 0x00;
usb_send_data(&data_buffer[0], 4, 0);
}
}
int main() {
//SYSTEMConfigPerformance(10000000); //Configures low-level system parameters for 10 MHz clock
enableInterrupts(); //This function is necessary to use interrupts.
//TODO: Write each initialization function
initLEDs();
initTimer1();
while(1){
//TODO: Implement a state machine to create the desired functionality
switch(state){
case led1: //LED1 is on
LATDbits.LATD0 = ON;
LATDbits.LATD1 = OFF;
LATDbits.LATD2 = OFF;
break;
case led2: //LED2 is on
LATDbits.LATD0 = OFF;
LATDbits.LATD1 = ON;
LATDbits.LATD2 = OFF;
break;
case led3: //LED3 is on
LATDbits.LATD0 = OFF;
LATDbits.LATD1 = OFF;
LATDbits.LATD2 = ON;
break;
}
}
return 0;
}
int main() {
//This function is necessary to use interrupts.
enableInterrupts();
initSwitch1();
initLEDs();
while(1){
switch (state){
case led1:
if(PORTDbits.RD7 == 0){
delayMs();
i=2;
wait2();
state = debounceRelease;
}
break;
case led2:
if(PORTDbits.RD7 == 0){
delayMs();
i=3;
wait2();
state = debounceRelease;
}
break;
case led3:
if(PORTDbits.RD7 == 0){
delayMs();
i=1;
wait2();
state = debounceRelease;
}
break;
}
if(state == debounceRelease){
if(PORTDbits.RD7 == 1){
if(IFS0bits.T2IF == 1){
i=i+1;
if(i == 4) i=1;
turnOffTimer2();
}
delayMs();
if(i == 3){
turnOnLED(3);
state = led3;
}
else if(i == 1){
turnOnLED(1);
state = led1;
}
else {
turnOnLED(2);
state = led2;
}
}
}
}
return 0;
}
/**
* @brief Main program.
* @param None
* @retval None
*/
void main(void)
{
/* I2C clock Enable*/
CLK_PeripheralClockConfig(CLK_Peripheral_I2C, ENABLE);
/* system_clock / 1 */
CLK_MasterPrescalerConfig(CLK_MasterPrescaler_HSIDiv1);
/* Initialize LEDs mounted on the EVAL board */
STM_EVAL_LEDInit(LED2);
STM_EVAL_LEDInit(LED3);
I2C_DeInit();
/* Initialize I2C peripheral */
#ifdef I2C_slave_7Bits_Address
I2C_Init(100000, SLAVE_ADDRESS, I2C_DutyCycle_2, I2C_Ack_Enable,
I2C_AcknowledgedAddress_7bit);
#else
I2C_Init(100000, SLAVE_ADDRESS, I2C_DutyCycle_2, I2C_Ack_Enable,
I2C_AcknowledgedAddress_10bit);
#endif
/* Enable Error Interrupt*/
I2C_ITConfig((I2C_IT_TypeDef)(I2C_IT_ERR | I2C_IT_EVT | I2C_IT_BUF), ENABLE);
/* Enable general interrupts */
enableInterrupts();
/*Main Loop */
while (1)
{
/* infinite loop */
}
}
/**
* @brief Example main entry point.
* @par Parameters:
* None
* @retval
* None
*/
void main(void)
{
/* Initialize I/Os in Output Mode for LEDs */
GPIO_Init(LEDS_PORT, LED1_PIN | LED2_PIN, GPIO_MODE_OUT_PP_LOW_FAST);
/* Initialize I/O in Input Mode with Interrupt for button and joystick */
/* Button */
GPIO_Init(BUTTON_PORT, BUTTON_PIN, GPIO_MODE_IN_FL_IT);
/* Joystick */
GPIO_Init(JOYSTICK_PORT, JOYSTICK_DOWN_PIN, GPIO_MODE_IN_FL_IT);
/* Initialize the Interrupt sensitivity for button and joystick */
EXTI_SetExtIntSensitivity(EXTI_PORT_GPIOB, EXTI_SENSITIVITY_FALL_LOW);
EXTI_SetExtIntSensitivity(EXTI_PORT_GPIOC, EXTI_SENSITIVITY_FALL_LOW);
/*
Change the software priority between button and joystick:
- By hardware the PORTB (joystick) has a higher priority than PORTC (button)
- We configure the PORTC (button) to have a higher sw priority than PORTB (joystick)
*/
ITC_SetSoftwarePriority(ITC_IRQ_PORTB, ITC_PRIORITYLEVEL_1); /* joystick */
ITC_SetSoftwarePriority(ITC_IRQ_PORTC, ITC_PRIORITYLEVEL_2); /* button = higher sw priority */
enableInterrupts();
/* LEDs are ON together */
GPIO_WriteHigh(LEDS_PORT, (LED1_PIN | LED2_PIN));
while (1);
}
int main() {
SYSTEMConfigPerformance(10000000); //Configures low-level system parameters for 10 MHz clock
enableInterrupts(); //This function is necessary to use interrupts.
initLEDs();
initTimer1();
while(1){
switch(state) {
case INIT:
next_state = LED_0;
break;
case LED_0:
turnOnLED(0);
next_state = LED_1;
break;
case LED_1:
turnOnLED(1);
next_state = LED_2;
break;
case LED_2:
turnOnLED(2);
next_state = LED_0;
break;
}
}
return 0;
}
void main(void)
{
u16 trigpos;
u8 keycode;
SystemState = AutoRunMode;
// 现在还是使用软件触发
ADCState = Triggered; // ADCState = WaitTrigger;
CLK_Init(); // 主时钟初始化
TIM4_Init(); // TIM4 用于产生系统运行需要的定时信号
KEY_Init(); // 按键驱动初始化
KeyParse_Init(); // 按键处理模块初始化
LCD_Init(); // LCD驱动初始化
WDraw_Init(); // 波形显示模块初始化
TriggerInterruptInit(); // 外部触发中断初始化
ADC_Init(); // ADC采样程控模块初始化
DProc_Init(); // 数据处理模块初始化
enableInterrupts();
/* Infinite loop */
while (1)
{
if(flag_10ms_ok)
{
flag_10ms_ok = 0;
keycode = KEY_Scan();
switch(GET_KTYPE(keycode))
{
case KTYPE_NORMAL:
KeyParse(GET_KCODE(keycode));
default:
break;
}
}
switch(SystemState)
{
// to do
case AutoRunMode:
case ManualMode:
// 处理数据
if( ADCState == ADC_Buffer_Full )
{
trigpos = GetTriggerPostion(0, 64);
WDraw_DisplayUpdate(&ADC_Buffer[trigpos]);
ADCState = Triggered;
ADC_Index = 0;
}
break;
default:
break;
}
}
}
