// PLL初始化子程序 BUS Clock=16M void setbusclock(void) { CLKSEL=0X00; // disengage PLL to system PLLCTL_PLLON=1; // turn on PLL SYNR=0x00 | 0x01; // VCOFRQ[7:6];SYNDIV[5:0] // fVCO= 2*fOSC*(SYNDIV + 1)/(REFDIV + 1) // fPLL= fVCO/(2 × POSTDIV) // fBUS= fPLL/2 // VCOCLK Frequency Ranges VCOFRQ[7:6] // 32MHz <= fVCO <= 48MHz 00 // 48MHz < fVCO <= 80MHz 01 // Reserved 10 // 80MHz < fVCO <= 120MHz 11 REFDV=0x80 | 0x01; // REFFRQ[7:6];REFDIV[5:0] // fREF=fOSC/(REFDIV + 1) // REFCLK Frequency Ranges REFFRQ[7:6] // 1MHz <= fREF <= 2MHz 00 // 2MHz < fREF <= 6MHz 01 // 6MHz < fREF <= 12MHz 10 // fREF > 12MHz 11 // pllclock=2*osc*(1+SYNR)/(1+REFDV)=32MHz; POSTDIV=0x00; // 4:0, fPLL= fVCO/(2xPOSTDIV) // If POSTDIV = $00 then fPLL is identical to fVCO (divide by one). _asm(nop); // BUS CLOCK=16M _asm(nop); while(!(CRGFLG_LOCK==1)); //when pll is steady ,then use it; CLKSEL_PLLSEL =1; //engage PLL to system; }
//main routine for ADC (linear) calibration testing void TestADCCalibration(void) { unsigned int * ADCBuffer; double * ADCRealValues; double P, Q; unsigned int i; unsigned int NumOfData; volatile double diffOrig; volatile double diffCalib; unsigned char DEBUG_STRING[30]; //set external clock (16MHz XTALL required) SetCPUClock(0); //allocate buffer space if ((ADCBuffer = malloc(ADC_BUFFER_SIZE * sizeof(ADCBuffer[0]))) == NULL) _asm("trap\n"); if ((ADCRealValues = malloc(ADC_BUFFER_SIZE * sizeof(ADCRealValues[0]))) == NULL) _asm("trap\n"); //main test { //collect data NumOfData = ADCCollectDataCalib(ADCBuffer, ADCRealValues); P= GetMultiplierCalib(ADCBuffer, ADCRealValues, NumOfData); diffOrig = GetErrorCalib(ADCBuffer, ADCRealValues, NumOfData, P, 0); //calib data ADCCalibratePQ(ADCBuffer, ADCRealValues, NumOfData, &P, &Q); diffCalib = GetErrorCalib(ADCBuffer, ADCRealValues, NumOfData, P, Q); //print errors sprintf(DEBUG_STRING, "Orig = %f", diffOrig); LCD_PrintString(LCD_LINE1, ENABLE, DISABLE, DEBUG_STRING); sprintf(DEBUG_STRING, "Calib= %f", diffCalib); LCD_PrintString(LCD_LINE2, ENABLE, DISABLE, DEBUG_STRING); delay(500000l);//to show results } //see real values after ADC calibration - for checking calibration LCD_Clear(); LCD_PrintString(LCD_LINE1, DISABLE, ENABLE, "Real calibrated U"); while(!JOY_SEL) { //start single conversion ADC2_StartConversion(); while (!ADC2_GetFlagStatus()); //clear end of conversion bit ADC2_ClearFlag(); //collect ADC value and display LCD_SetCursorPos(LCD_LINE2, 4);//set cursor position LCD_PrintDec4((P*ADC2_GetConversionValue() + Q)*1000); } //unallocate buffer free(ADCBuffer); }//TestADCCalibration
/***************************************************************************** Name: DisplayDelay Parameters: unit Returns: none Description: Delay routine for LCD display. May be used for setup and hold times. *****************************************************************************/ void DisplayDelay(unsigned long int units){ unsigned long int counter = units * 0x100; while(counter--){ _asm ("NOP"); _asm ("NOP"); _asm ("NOP"); } }
void setbusclock(void) //PLL setting { CLKSEL=0X00; //disengage PLL to system PLLCTL_PLLON=1; //turn on PLL SYNR=1; REFDV=1; //pllclock=2*osc*(1+SYNR)/(1+REFDV)=32MHz; _asm(nop); //BUS CLOCK=16M _asm(nop); while(!(CRGFLG_LOCK==1)); //when pll is steady ,then use it; CLKSEL_PLLSEL =1; //engage PLL to system; }
void setbusclk() { CLKSEL=0x00; //clodk=oscclk/2 use OSC clock PLLCTL_PLLON=1; //turnPLL SYNR=0xc0|9; REFDV=0xc0|1; //PLLCLK=2*osc*(1+SYN)/(1+REFDIV)=160 POSTDIV=0x00; //busclk=PLLCLK/OSDIV/2=80 _asm(nop); _asm(nop); _asm(nop); while(!(CRGFLG_LOCK==1)); //wait is to be steady CLKSEL_PLLSEL=1; //use PLL clock }
/** * @brief Utility function used to read CC register. * @param None * @retval CPU CC register value */ uint8_t ITC_GetCPUCC(void) { #ifdef _COSMIC_ _asm("push cc"); _asm("pop a"); return; /* Ignore compiler warning, the returned value is in A register */ #elif defined _RAISONANCE_ /* _RAISONANCE_ */ return _getCC_(); #else /* _IAR_ */ asm("push cc"); asm("pop a"); /* Ignore compiler warning, the returned value is in A register */ #endif /* _COSMIC_*/ }
/******************************************************** 用TIM2产生0.01S的时钟~然后循环100次产生1S的延迟~用PD显示 ********************************************************/ void main(void) { Init_GPIO(); Init_Tim2(); _asm("rim"); //开启全局中断 while (1); }
main() { unsigned int x=0; setupIO(); _asm("rim\n"); PB_ODR |= 0x20; while(1){ sendStandby(); sendByte(0x55); sendByte(0xa0); sendByte(0x03); sendByte(0x00); sendByte(0x00); b1 = readByte(); b2 = readByte(); b3 = lastRead(); for(x=0;x<60000;x++); for(x=0;x<60000;x++); for(x=0;x<60000;x++); for(x=0;x<60000;x++); for(x=0;x<60000;x++); } }
void System_init(void) { System_Clock_init(); UART1_Init(); delay_init(16); HekrInit(UART1_SendChar); _asm("rim"); }
uint8_t ITC_GetCPUCC(void) { #ifdef _COSMIC_ _asm("push cc"); _asm("pop a"); return; /* Ignore compiler warning, the returned value is in A register */ #endif #ifdef _RAISONANCE_ return _getCC_(); #endif #ifdef _IAR_SYSTEMS_ __asm("push cc"); __asm("pop a"); #endif }
//============================================================================================= //说明:软件延时//系统时钟72M 情况下 //输入:time延时时间,单位ms //输出:void //调用:void //修改:2011-01-20 KEN 初定 //============================================================================================= void DelayMs_Soft(u16 time) { u16 i=0; while(time--) { for(i=0;i<490;i++) _asm(""); } }
void TIM2_Init(void) { _asm("sim"); //sim是禁止中断 TIM2_IER = 0x00; //禁止中断 TIM2_EGR =0x01; // 允许产生更新标志 TIM2_PSCR =0x01; // 设置时钟分频 2M/2=1MHz---1us TIM2_ARRH = 0x27; // 0x2710=10000; 每10ms复位一次定时器2 TIM2_ARRL = 0x10; // ARR自动装载值,每1us递减1 TIM2_CNTRH=0x00; //初值 TIM2_CNTRL=0x00; TIM2_CR1 |= 0x81; //开启定时器 TIM2_IER |= 0x01; //允许中断 _asm("rim"); //rim使能中断 }
/*..........................................................................*/ void BSP_init(void) { uint16_t volatile delay; /* initialize the clock... */ prc0 = 1; /* allow writing to clock control registers */ cm07 = 0; /* clock selected by cm21 in CM2 (oscillation stop detect) */ cm21 = 0; /* clock selected by cm17 in CM1 (system clock select reg) */ cm17 = 0; /* clock source is main clock */ mcd = 0x12; /* set divide for BCLK to divide by 1 */ /* configure and switch main clock to PLL... */ /* set PLL to multiply by 6 and divide by 2 giving 30MHz when writing PLL * control registers write to both plc0 and plc1 (addresses 0026 and 0027) * using a word write command. Set divide ratio with the PLL off */ *(uint16_t *)&plc0 = 0x0253; _asm("nop"); *(uint16_t *)&plc0 = 0x02D3; /* turn the PLL on */ for (delay = 0; delay < 0x4000; ++delay) { /* delay for 20msec */ } cm17 = 1; /* make the PLL the CPU clock source */ prc0 = 0; /* protect clock control registers */ pd6 |= 0x0F; /* port 6 is used by E8 do not modify upper half of port */ /* enable the User Button */ SW1_DDR = 0; /* LED port configuration... */ LED0_DDR = 1; LED1_DDR = 1; LED2_DDR = 1; LED3_DDR = 1; LED0 = LED_OFF; LED1 = LED_OFF; LED2 = LED_OFF; LED3 = LED_OFF; /* start the 32kHz crystal subclock (remove if 32kHz clock not used)... */ prc0 = 1; /* unlock CM0 and CM1 and set GPIO to inputs (XCin/XCout) */ pd8_7 = 0; pd8_6 = 0; cm04 = 1; /* start the 32kHz crystal */ /* setup Timer A running from fc32... */ ta0mr = 0xC0; /* Timer mode, fc32, no pulse output */ ta0 = (int)((fc_CLK_SPEED/32 + BSP_TICKS_PER_SEC/2) / BSP_TICKS_PER_SEC) - 1; /* period */ ta0ic = TICK_ISR_PRIO; /* set the clock tick interrupt priority level */ if (QS_INIT((void *)0) == 0) { /* initialize the QS software tracing */ Q_ERROR(); } }
/*..........................................................................*/ void QF_onIdle(void) { #ifdef Q_SPY if (ti_u0c1 != 0) { uint16_t b = QS_getByte(); QF_INT_UNLOCK(dummy); /* unlock interrupts */ if (b != QS_EOD) { u0tb = b; /* stick the byte to the TX buffer */ } } else { QF_INT_UNLOCK(dummy); /* unlock interrupts */ } #elif (defined NDEBUG) /* low-power mode interferes with debugging */ /* stop all peripheral clocks that you can in your applicaiton ... */ _asm("FSET I"); /* NOTE: the following WAIT instruction will */ _asm("WAIT"); /* execute before entering any pending interrupt */ #else QF_INT_UNLOCK(dummy); /* just unlock interrupts */ #endif }
/*把总线时钟设置为24MHz,相当于锁相环*/ void initPLL(void){ //32M CPMUPROT = 0x26; //保护时钟配置寄存器 CPMUCLKS_PSTP = 0; //禁用PLL CPMUCLKS_PLLSEL = 1; //选择PLL作为系统时钟源 CPMUOSC_OSCE = 1; //外部晶振使能 CPMUSYNR = 0x07; //fVCO= 2*fOSC*(SYNDIV + 1)/(REFDIV + 1) fosc=16MHZ CPMUREFDIV = 0x03; CPMUPOSTDIV = 0x00; // PLL CLOCK = VCO CLOCK / (POSTDIV + 1) //BUS CLOCK = PLL CLOCK/2 _asm(nop); _asm(nop); _asm(nop); _asm(nop); CPMUPLL=0x10; //锁相环调频启用,用以减少噪音 while(CPMUFLG_LOCK == 0); //等待PLL稳定 CPMUPROT = 0x00; //关闭保护时钟 }
//-----------------------------------------------------------------------* //函数名: Light_Init时钟设置函数定义 * //功 能: 基于16MHz的外部晶振,设置总线时钟频率 * //参 数: fbus为目标总线频率值,推荐值为16、20、32、40、48、60MHz * //返 回: 无 * //-----------------------------------------------------------------------* void SetBusCLK_M(uint8 fbus) { CLKSEL=0x00; // 不加载IPLL到系统 REFDV=0x00 | 0x07; // REFFRQ[1:0];REFDIV[5:0] switch(fbus) // BUS CLOCK { case 16: SYNR =0x00 | 0x07;break; case 20: SYNR =0x00 | 0x09;break; case 32: SYNR =0x40 | 0x0F;break; case 40: SYNR =0x40 | 0x13;break; case 48: SYNR =0xC0 | 0x17;break; case 60: SYNR =0xC0 | 0x1D;break; default: break; } PLLCTL_PLLON=1; //启动IPLL _asm(nop); _asm(nop); while(!(CRGFLG_LOCK==1)); //等待IPLL稳定 POSTDIV=0x00; //POSTDIV[4:0], fPLL= fVCO/(2xPOSTDIV) //若POSTDIV = 0x00,则fPLL = fVCO CLKSEL_PLLSEL =1; //加载IPLL到系统 }
//8-bit AD convertor u8 ADC_8BIT(u8 ch) { u16 Adc; u8 i; ADC.CR2=0; ADC.CSR =ch &0x0F; ADC.CR1 |=0x1; // 启动ADC _asm("nop"); ADC.CR1 |=0x1; // 开始转换 for(i=0;(i<100)&&((ADC.CSR &ADC_CSR_EOC)==0);i++) Delay(1); Adc = ADC.DRH; //READ DATA 因为是右对齐所以先读低位 ADC.CR1 &=0xfe; // 关闭ADC return(Adc); }
static NO_REG_SAVE void krn_thread_shell (void) { //enable interrupts before thread start #if defined(__CSMC__) _asm("rim"); #elif defined(__IAR_SYSTEMS_ICC__) __enable_interrupt(); //rim(); #elif defined(__RCSTM8__) _rim_(); #endif //thread entry if (krn_thread_first && krn_thread_first->func) { krn_enter_thread(krn_thread_first->func); } }
void System_init(void) { //系统时钟初始化 内部16M System_Clock_init(); //串口初始化 9600 UART1_Init(); //串口发送函数绑定 HekrInit(UART1_SendChar); //16M主频延迟初始化 delay_init(16); //通过上电次数选择模式 必须先初始化延迟 串口 Bright_ModeInit(); //PWM 初始化 TIM2_Init(); //亮度调整定时器 TIM1_Init(); _asm("rim"); }
void interrupt 8 Port0_interrupt(void) // HS interrupt { static unsigned int i; TFLG1 = 0x01; // Clear HS flag if( g_SampleFlag == 0 ) // 不用这么搞,提前关行终中断就可以 { return; } row_counter++; if( row_counter % SAMPLE_INTERVAL == 0 ) { app = &buff[row][0]; row++; if( row_counter > 200 ) { g_SampleFlag = 0; TIE_C0I = 0; flag = 1; return; //test } for( i = 0; i < COLUMN_VALUE; i++ ) { _asm(nop);_asm(nop);_asm(nop); _asm(nop);_asm(nop);_asm(nop); _asm(nop);_asm(nop);_asm(nop); _asm(nop);_asm(nop);_asm(nop); _asm(nop);_asm(nop);_asm(nop); _asm(nop);_asm(nop);_asm(nop); //for 80Mhz *app++ = PORTB; } } }
/////////////////////////////////////////////////////////////////////////////// //> Name: PlayerLib_SetState // // Type: Function // // Description: Use the function to set the decoder to a specified state: // STOP, PLAY, PAUSE, TOGGLE (switches between PLAY & PAUSE, // PLAYs if STOPPED) // // Inputs: iState = state to set decoder to // bWait = if TRUE, function will not return until state is set // Outputs: Success returned if successful, Error if not. // // Notes: //< /////////////////////////////////////////////////////////////////////////////// RETCODE _reentrant PlayerLib_SetState (int iState,int bWait,int*ignored) { RETCODE rtn=PLAYERLIB_SUCCESS; ignored; switch (iState) // switch on the desired decoder state { case DECODER_STATE_STOP: // set Decoder to STOP state if(!(g_wDecoderSR & DECODER_STOPPED)) // if Decoder NOT stopped--> { #ifdef SYNC_LYRICS SysCallFunction(RSRC_LYRICS_API_CODEBANK,LyricsStop,0,0,0); #endif SysPostMessage(2,DECODER_STOP); // -->then post a message to STOP if(bWait) // check if we need to WAIT for STOP to occur { while(!(g_wDecoderSR & DECODER_STOPPED)) SysWaitOnEvent(EVENT_TIMER,0,10); // wait, 10ms ... } } // For fix FF hang DecoderForceInit(); // update decoder and force init SysPostMessage(2,DECODER_RESET); #ifdef AUDIBLE if( (DecoderResourcePtr != RSRC_AUDIBLE_ACELPDEC_CODE) && (DecoderResourcePtr != RSRC_AUDIBLE_DECMOD_CODE) ) { DecSetSongPosZero(); // reset byte positions to beginning of file } #else DecSetSongPosZero(); // reset byte positions to beginning of file #endif #ifdef WOW SysSpeedClockFree(SPEED_CLIENT_MENU_WOW); // let speed return to IDLE if not playing #endif break; case DECODER_STATE_PLAY: // set Decoder to PLAY state //it is possible that the player is already heading into play state and our play message will cause it to //go to pause state. The decoder should be fixed to avoid this problem. See decoder settling interval. g_iPlayerState = DECODER_PLAYING; // Wait decoder settling interval (ms), before checking decoder status. SysWaitOnEvent(EVENT_TIMER,0,100); // Prevents hang by keeping playerlib & decoder synchronized. // Now check the Decoder's updated status. if(!(g_wDecoderSR & DECODER_PLAYING)) // if Decoder NOT playing--> { #ifdef WOW // Calling SysSpeedIncrease() will decrease battery life, // so only call for WOW to increase battery life. (Stmp00008309) // But inter-song delay will be increased if speed is not increased. SysSpeedIncrease(SPEED_MAX,SPEED_CLIENT_MENU_WOW); // boost speed on MP3s #endif #ifdef SYNC_LYRICS SysCallFunction(RSRC_LYRICS_API_CODEBANK,LyricsStart,0,0,0); #endif #ifndef USE_PLAYLIST5 SysPostMessage(2,DECODER_PLAY); // -->then post a message to PLAY #else if((!g_bWait)|| filest_bHasDRM || filest_bHasJanusDRM) bWait = FALSE; SysPostMessage(2,DECODER_PLAY); // -->then post a message to PLAY // bWait = FALSE; #endif #ifdef MOTION_VIDEO #ifdef USE_PLAYLIST3 if(iJpegPlaySet == PLAYSET_MVIDEO) bWait = FALSE; #else #ifndef USE_PLAYLIST5 if(Playlist_GetPlaySet() == PLAYSET_MVIDEO) bWait = FALSE; #endif #endif #endif if(bWait) // check if we need to WAIT for PLAY to occur { while(!(((g_wDecoderSR & (DECODER_PLAYING|DECODER_BAD_FILE))||g_wCurrentSongBad))) { SysWaitOnEvent(EVENT_TIMER,0,10); // wait, 10 ms ... #ifdef USE_PLAYLIST5 if (bDRMLicExpired || filest_bHasDRM || filest_bHasJanusDRM) break; #endif } if((g_wDecoderSR & DECODER_BAD_FILE) || g_wCurrentSongBad) { g_iPlayerState = DECODER_STOPPED; rtn = PLAYERLIB_BAD_FILE; // return error code if file will not play } else // else, mark the current song as played in playlist { SysCallFunction(RSRC_PLAYLIST_CODEBANK,Playlist_MarkCurrentSongPlayed,0,0,0); } } } break; case DECODER_STATE_PAUSE: //it is possible that the player is already heading into pause state and our play message will cause it to //go to play state. The decoder should be fixed to avoid this problem. #ifdef SYNC_LYRICS SysCallFunction(RSRC_LYRICS_API_CODEBANK,LyricsPause,0,0,0); #endif // Decoder settling time wait (ms) prevents hang after PLAY, PR_FF, quickly followed by PH_FF. // Keeps playerlib & decoder synchronized. Stmp00003027/2947 Verified with decoder bitrate limits. // Note: Decoder settling time of 30 ms is insufficient for some MPEG rates. 100 ms prevents hang. if (bWait) // If we haven't yet waited for decoder settling time to expire, do so now. { SysWaitOnEvent(EVENT_TIMER,0,100); } if(!(g_wDecoderSR & DECODER_PAUSED)) // if Decoder NOT paused--> { if(g_wDecoderSR & DECODER_STOPPED) // if Decoder stopped==> SysPostMessage(2,DECODER_PLAY); // ==>then post a message to PLAY SysPostMessage(2,DECODER_PLAY); // -->then post a message to PLAY/PAUSE if(bWait) // check if we need to WAIT for PAUSE to occur { while(!((g_wDecoderSR & (DECODER_PLAYING|DECODER_BAD_FILE)||g_wCurrentSongBad))) SysWaitOnEvent(EVENT_TIMER,0,10); // wait, 10 ms ... if(g_wDecoderSR & DECODER_BAD_FILE) rtn = PLAYERLIB_BAD_FILE; // return error code if file will not play } } break; case DECODER_STATE_TOGGLE: // this function simply toggles between PLAY and PAUSE #ifdef SYNC_LYRICS if(!(g_wDecoderSR & DECODER_PAUSED)) // if Decoder NOT paused--> SysCallFunction(RSRC_LYRICS_API_CODEBANK,LyricsPause,0,0,0); else SysCallFunction(RSRC_LYRICS_API_CODEBANK,LyricsStart,0,0,0); #endif // As with state pause, decoder settling time wait (ms) prevents hang. Keeps playerlib & decoder synchronized. // Note: See comments for case decoder state pause above. SysWaitOnEvent(EVENT_TIMER,0,100); SysPostMessage(2,DECODER_PLAY); // if STOPPED -- toggle will cause a play if(bWait) { //ignoring wait for now. } break; default: _asm ( " debug"); break; } return PLAYERLIB_SUCCESS; }
int main() { unsigned long T_LED = 0L; // time of last digit update unsigned long T_time = 0L; // timer int i = 00, j = 00; U8 beep_delay = 0; int show_time_delay = 0; U8 counter_enabled = 0; key_state = 0; work_hours = (work_hours_t*)EEPROM_START_ADDR; keys_scan_buffer[0] = keys_scan_buffer[1] = keys_scan_buffer[2] = keys_scan_buffer[3] = 0; Global_time = 0L; // global time in ms ADC_value = 0; // value of last ADC measurement LED_delay = 1; // one digit emitting time // Configure clocking CLK_CKDIVR = 0; // F_HSI = 16MHz, f_CPU = 16MHz // Configure pins CFG_GCR |= 1; // disable SWIM LED_init(); // Configure Timer1 // prescaler = f_{in}/f_{tim1} - 1 // set Timer1 to 1MHz: 1/1 - 1 = 15 TIM1_PSCRH = 0; TIM1_PSCRL = 15; // LSB should be written last as it updates prescaler // auto-reload each 1ms: TIM_ARR = 1000 = 0x03E8 TIM1_ARRH = 0x03; TIM1_ARRL = 0xE8; // interrupts: update TIM1_IER = TIM_IER_UIE; // auto-reload + interrupt on overflow + enable TIM1_CR1 = TIM_CR1_APRE | TIM_CR1_URS | TIM_CR1_CEN; // configure ADC BEEP_CSR = 0x1e; // Configure BEEP _asm("rim"); // enable interrupts display_int(i); show_next_digit(); // show zero // Loop do { U8 *test = (U8*)0x4010; U8 result; if(((unsigned int)(Global_time - T_time) > DIGIT_PER) || (T_time > Global_time)) // set next timer value { T_time = Global_time; if(i && counter_enabled == 2) { PA_ODR |= (1<<2); // Relay is on i--; if(!i) { counter_enabled = 0; } } else { PA_ODR &= ~(1<<2); // Relay is off } if((i % 100) > 59) { i -= 40; } if(counter_enabled == 1) { if(j) { j--; if(!j) { i++; } if((j % 100) > 59) { j -= 40; } } if(!j) { counter_enabled = 2; add_minutes_to_eeprom(i/100); } } if(counter_enabled == 1) { display_int(-j); } else { display_int(i); } //if(i > 9999) i = -1200; // check ADC value to light up DPs proportionaly // values less than 206 == 0 } if((U8)(Global_time - T_LED) > LED_delay) { T_LED = Global_time; show_next_digit(); if(beep_delay) { beep_delay--; if(!beep_delay) { BEEP_CSR = 0x1e; // Configure BEEP } } if(show_time_delay) { show_time_delay--; if(!show_time_delay) { i = 0; // Stop show time } } } result = scan_keys(); if(result & KEY_0_PRESSED) // Start { if(counter_enabled == 1 && j < 859) // 859 - wait 3 sec from 1-st start press { BEEP_CSR = 0xbe; beep_delay = 200; counter_enabled = 2; add_minutes_to_eeprom(i/100); i++; j = 0; } if(!counter_enabled) { BEEP_CSR = 0xbe; beep_delay = 10; if(show_time_delay == 0 && i>0) { counter_enabled = 1; j = 901; // 6 minutes pre time } else { // Show Time i = work_hours->minutes + (int)(work_hours->hours_L) * 100 + (int)(work_hours->hours_H) * 10000; show_time_delay = 2450; } } } else { if(result && show_time_delay) { i = 0; show_time_delay = 0; } if(!counter_enabled) { if(result & KEY_3_PRESSED) { i+=100; display_int(i); BEEP_CSR = 0xbe; beep_delay = 10; } if(result & KEY_2_PRESSED) { if(i >= 100) { i-=100; display_int(i); } BEEP_CSR = 0xbe; beep_delay = 10; } } } if(result & KEY_1_PRESSED) //Stop { counter_enabled = 0; j = i = 0; display_int(i); BEEP_CSR = 0xbe; beep_delay = 40; show_time_delay = 0; } if((result & KEY_PRESSED) == KEY_PRESSED && Global_time < 1000) { BEEP_CSR = 0xbe; beep_delay = 40; clear_eeprom(); } } while(1); }
void select_plan() { unsigned long i; DDRB = 0xFF; DDRT = 0x04; PORTB = 0xFF; for (i=0; i<6000000; i++) { if (PORTA>100) { PTT_PTT2 = 1; PORTB_PB7 = ~PORTB_PB7; plan ++; _asm(nop); _asm(nop); _asm(nop); _asm(nop); _asm(nop); _asm(nop); _asm(nop); _asm(nop); _asm(nop); _asm(nop); _asm(nop); _asm(nop); PTT_PTT2 = 0; } } for (i=0; i<1000000; i++) PORTB = 0; }
uint8_t FlashEraseEW0( uint8_t block ) { volatile FLASH_PTR_TYPE flash_addr; uint8_t i, ret_value; #if (STATIC_RAM_CODE == 0) /* Allocate RAM space to hold the CPU-Rewrite code on the stack. */ uint8_t EW0_RAM_CODE[ RAM_CODE_SIZE ]; #endif /* Check if the RAM space is big enough to hold our re-write code */ asm("mov.w #((ERASE_CODE_END-ERASE_CODE_START+1)), _reflash_code_size"); if( RAM_CODE_SIZE < reflash_code_size ) { return 3; } /* Get highest even block address*/ flash_addr = (FLASH_PTR_TYPE) block_addresses[ block ]; /* Turn off maskable interrupts*/ DISABLE_INTERRUPTS; /* Specify to the assemble code below the RAM code address */ EW0_RAM_CODE_ptr = (int32_t) EW0_RAM_CODE; /* Copy code to RAM using SMOVF instruction (faster than a loop in 'C') */ /* Can use debugger to determine how big your RAM space needs to be */ /* R8C and M16C */ #pragma ASM pushm R1,R3,A0,A1 /* transfer count (number of words ) */ mov.w #((ERASE_CODE_END-ERASE_CODE_START+1) / 2 ),R3 ; /* source address */ mov.b #((ERASE_CODE_START >> 16) & 0FFh),R1H ; /* source address */ mov.w #(ERASE_CODE_START & 0FFFFh),A0 ; /* destination address (stored in EW0_ARM_CODE_ptr) */ mov.w _EW0_RAM_CODE_ptr,A1 ; /* copy 16 bits at a time */ smovf.w ; popm R1,R3,A0,A1 #pragma ENDASM /* Set EW0 select bit */ fmr01 = 0; fmr01 = 1; /* !! DISABLE ALL FLASH MEMORY LOCK AND PROTECT FUNCTIONALITY !! * NOTE: In order to use lock/protect bit functionality, please refer to * the Flash Memory section in the data sheet for your specific device. * Also note the that following bits clear back to 0 every time you enter * CPU Rewrite Mode. * Note that for some MCUs, if the lock bit is disabled, the error bits * do not function. */ #if R8C_FLASH == 1 /* R8C/M12A Series */ /* Lock bit disable select bit */ fmr13 = 0; /* Must write a 0 then a 1 in succession to SET */ fmr13 = 1; /* Data flash block A rewrite enabled */ fmr16 = 0; /* Data flash block B rewrite enabled */ fmr17 = 0; #endif /* Jump into RAM routine spcified by EW0_RAM_CODE_ptr */ _asm("jmpi.a _EW0_RAM_CODE_ptr"); /* Create an address label so we know where copy code from */ _asm("ERASE_CODE_START:"); /* Attempt to erase flash up to 3 times before returning failed */ for( i = 0; i<3; i++) { /* Clear status register */ *flash_addr = 0x50; /* Send erase command */ *flash_addr = 0x20; /* Send erase confirm command */ *flash_addr = 0xD0; /* Note: In EW0 Mode, we need to poll the Ready/Busy bit until the operation completed */ /* Wait for ready bit if executing in RAM for EW0 mode.*/ /* Perform other time critical operations such as "kicking" the watchdog timer.*/ #if R8C_FLASH == 1 /* R8C/M12A Series */ while(!fst7) { } #endif /* Check if operation was successful */ #if R8C_FLASH == 1 /* R8C/M12A Series */ /* Erasing Successful?*/ if( !fst5 ) #endif { break; } } /* Send Read Array command in order to tell flash controller to go back into Flash Read mode (as opposed to Read Status mode) */ *flash_addr = 0xFF; /* Disable CPU rewriting commands by clearing EW entry bit */ fmr0 = 0; _asm("nop"); /* If in RAM, this will jump you back to flash memory */ _asm("jmp.a ERASE_CODE_END"); _asm("ERASE_CODE_END:"); #if R8C_FLASH == 1 /* R8C/M12A Series */ /* Command Sequence Error?*/ if( fst4 && fst5 ) { ret_value = 2; } /* Erasing error?*/ else if( fst5 ) { ret_value = 1; } /* Erase Pass!!*/ else { ret_value = 0; } #endif /* Restore I flag to previsous setting*/ RESTORE_INTERRUPTS; return ret_value; }
uint8_t FlashWriteEW0(FLASH_PTR_TYPE flash_addr, BUF_PTR_TYPE buffer_addr, uint16_t bytes) { uint8_t ret_value = 0; #if (STATIC_RAM_CODE == 0) /* Allocate RAM space to hold the CPU-Rewrite code on the stack. */ uint8_t EW0_RAM_CODE[ RAM_CODE_SIZE ]; #endif /* Check if the RAM space is big enough to hold our re-write code */ asm("mov.w #((WRITE_CODE_END-WRITE_CODE_START+1)), _reflash_code_size"); if( RAM_CODE_SIZE < reflash_code_size ) { return 4; } /* Turn off maskable interrupts*/ DISABLE_INTERRUPTS; /* Specify to the assemble code below the RAM code address */ EW0_RAM_CODE_ptr = (int32_t) EW0_RAM_CODE; /* Copy code to RAM using SMOVF instruction (faster than a loop in 'C') */ /* Can use debugger to determine how big your RAM space needs to be */ /* R8C and M16C */ #pragma ASM pushm R1,R3,A0,A1 /* transfer count (number of words )*/ mov.w #((WRITE_CODE_END-WRITE_CODE_START+1) / 2 ),R3 ; /* source address*/ mov.b #((WRITE_CODE_START >> 16) & 0FFh),R1H ; /* source address*/ mov.w #(WRITE_CODE_START & 0FFFFh),A0 ; /* destination address (stored in EW0_RAM_CODE_ptr) */ mov.w _EW0_RAM_CODE_ptr,A1 ; /* copy 16 bits at a time*/ smovf.w ; popm R1,R3,A0,A1 #pragma ENDASM fmr01 = 0; /* Set EW0 select bit*/ fmr01 = 1; /* !! DISABLE ALL FLASH MEMORY LOCK AND PROTECT FUNCTIONALITY !! * NOTE: In order to use lock/protect bit functionality, please refer to * the Flash Memory section in the data sheet for your specific device. * Also note the that following bits clear back to 0 every time you enter * CPU Rewrite Mode. * Note that for some MCUs, if the lock bit is disabled, the error bits * do not function. */ #if R8C_FLASH == 1 /* R8C/M12A Series */ /* Lock bit disable select bit*/ fmr13 = 0; /* Must write a 0 then a 1 in succession to SET*/ fmr13 = 1; /* Data flash block A rewrite enabled*/ fmr16 = 0; /* Data flash block B rewrite enabled*/ fmr17 = 0; #endif /* Jump into RAM routine spcified by EW0_RAM_CODE_ptr*/ _asm("jmpi.a _EW0_RAM_CODE_ptr"); /* Create an address label so we know where copy code from*/ _asm("WRITE_CODE_START:"); /* Clear status register*/ *flash_addr = 0x50; while(bytes) { /* Write to the flash sequencer by writting to that area of flash memory */ /* Send write command */ *flash_addr = 0x40; /* Write next word of data */ *flash_addr = *buffer_addr; /* Note: In EW0 Mode, we need to poll the Ready/Busy bit until the operation completed */ /* Wait for ready bit if executing in RAM for EW0 mode.*/ /* Perform other time critical operations such as "kicking" the watchdog timer.*/ #if R8C_FLASH == 1 /* R8C/M12A Series */ while(!fst7) { } #endif #if R8C_FLASH == 1 /* R8C/M12A Series */ /* Read flash program status flag */ /* Write error?*/ if( fst4 ) { /* Command Sequence error ?*/ if( fst5 ) { /* Signal a Command Sequence error*/ ret_value = 3; } else { /* Signal the flash would not write*/ ret_value = 1; } /* Break out of while loop*/ break; } #endif /* Advance to next flash write address*/ flash_addr++; /* Advance to next data buffer address*/ buffer_addr++; /* NOTE: The R8C writes to flash a 8 bits at a time where as the M16C * writes to flash 16 bits at a time. */ /* Subract 1 from byte counter */ bytes--; } /* Send Read Array command in order to tell flash controller*/ *flash_addr = 0xFF; /* to go back into Flash Read mode (as opposed to Read Status mode)*/ /* disable EW mode by clearing EW entry bit*/ fmr0 = 0; _asm("nop"); /* If in RAM, this will jump you back to flash memory*/ _asm("jmp.a WRITE_CODE_END"); _asm("WRITE_CODE_END:"); /* Restore I flag to previous setting */ RESTORE_INTERRUPTS; /* Return Pass/Fail*/ return ret_value; }
static TARGET_INLINE void KERNEL_vEnterCriticalCode(void) { ubStoredCCValue = (UBYTE)_asm("PUSH CC\nPOP A\nPUSH #0\nPOP CC"); blKernelUpdateBlocked=TRUE; }
//===================================== void main() //===================================== { u16 i,j,k=0,g; SysTime = 0; SystemFlag = 0x00; mode = 0x01;//lora mode Freq_Sel = 0x00;//433M Power_Sel = 0x00;// Lora_Rate_Sel = 0x06;// BandWide_Sel = 0x07; Fsk_Rate_Sel = 0x00; _asm("sim"); //Disable interrupts. mcu_init(); ITC_SPR4 = 0xf3;//time2 interrupt priority 2¡¢level13 ITC_SPR5 = 0x3c;//UART1_RX ¡¢UART_TX interrupt priority 2 ITC_SPR6 = 0x00;//UART3_RX ¡¢UART_TX interrupt priority 2 _asm("rim"); //Enable interrupts. GREEN_LED_L(); RED_LED_L(); delay_ms(500); GREEN_LED_H(); RED_LED_H(); sx1278_Config(); sx1278_LoRaEntryRx(); TIM1_CR1 |= 0x01; //enable time1 MasterModeFlag=0; while(1) { if(GetOption()) //Slave { if(SystemFlag&PreviousOptionBit) { sx1278_LoRaEntryRx(); SystemFlag&=(!PreviousOptionBit); } if(sx1278_LoRaRxPacket()) { GREEN_LED_L(); delay_ms(100); GREEN_LED_H(); RED_LED_L(); sx1278_LoRaEntryTx(); sx1278_LoRaTxPacket(); RED_LED_H(); sx1278_LoRaEntryRx(); } } else //Master { if((SystemFlag&PreviousOptionBit)==0) { MasterModeFlag=0; SystemFlag|=PreviousOptionBit; } switch(MasterModeFlag) { case 0: if(time_flag==1) { time_flag=0; RED_LED_L(); sx1278_LoRaEntryTx(); sx1278_LoRaTxPacket(); RED_LED_H(); MasterModeFlag++; } break; case 1: sx1278_LoRaEntryRx(); for(i=0;i<30;i++) { delay_ms(100); if(sx1278_LoRaRxPacket()) { i=50; GREEN_LED_L(); delay_ms(100); GREEN_LED_H(); } } MasterModeFlag++; break; case 2: if(time_flag==1) { time_flag=0; MasterModeFlag=0; } break; } } } }
void iduBarrier() { #if defined(HP_HPUX) _asm("SYNC"); #endif }
/****************** ÑÓʱus ******************/ void delay_us(int n) //10us { while(n--){ _asm(nop); } }
static TARGET_INLINE void KERNEL_vLeaveCriticalCode(void) { blKernelUpdateBlocked=FALSE; _asm("PUSH A\nPOP CC\n", ubStoredCCValue); }