按下3秒钟，如何使用Atmega8 1MHz测量时间？

Question

目前，我有Atmega8 1MHz微控制器。我正在使用C语言。 因此，基本上我的程序显示了7个段显示器上的数字。 而且，每次按下按钮时，它会

立即增加数字+1，我想测量时间，如果用户按下按钮3秒钟。我唯一需要的是如何测量中断到3秒钟。 我需要背后的逻辑，我应该使用if语句吗？否则我不知道

这里是我的代码：

#define F_CPU 1000000UL
#define IRQ1 INT0_vect
#define IRQ2 INT1_vect

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>

volatile int the_count = 0; 
volatile int i;
volatile int k;

ISR(IRQ1){
    if (the_count < 100){
        the_count++;
        i = the_count % 10;
        k = the_count / 10;
    }
    else{
         the_count = 0;
         i = the_count % 10;
         k = the_count / 10;
    }
}

ISR(IRQ2){
    if (the_count < 100){
        the_count = the_count;
        i = the_count % 10;
        k = the_count / 10;
    }
    else{
        the_count = 0;
        i = the_count % 10;
        k = the_count / 10;
    }
}

void init()
{
    DDRD = 0b00000111;
    DDRB = 0b11111111;
    PORTB = 255;
    _delay_ms(2000);
    PORTB = 0;
    GICR = 0xc0;
    MCUCR = 0x08;
    IRQ1;
    IRQ2;
}



int main(void){
    init();
    GICR = 0xc0;   
    MCUCR = 0x08; 
    sei();
    
    int digit[] = {0b000000101, 0b10111101, 0b00100110, 0b10100100, 0b10011100, 0b11000100, 0b01000100, 0b10101101, 0b00000100, 0b10001100};
    
    
    int dig1 = 0b00000110;  //first digit area on display
    int dig2 = 0b00000101;  //second digit area on display
    
    
    while (1) 
    {
        if (k < 1){                                             
            PORTB = digit[0];
            PORTD = dig1;
            _delay_ms(1);
            PORTD = dig2;
            PORTB = digit[i];
            _delay_ms(1);
        }
        
        else if (k>=1 && i==0 && the_count<100){                
            PORTB = digit[k];
            PORTD = dig1;
            _delay_ms(1);
            PORTD = dig2;
            PORTB = digit[0];
            _delay_ms(1);
        }
        else if (k>=1 && i!=0 && the_count<100){                   
            PORTB = digit[k];
            PORTD = dig1;
            _delay_ms(1);
            PORTD = dig2;
            PORTB = digit[i];
            _delay_ms(1);
        }
        else {                                                       
            the_count = 0;
        }
    }
}

Answer 1

我不会涉足所有这些代码来回答您的问题 - 尤其是因为您的命名约定，缺乏评论或I/O抽象使得很难确定I/O对于什么或代码做什么。但是“逻辑”将如下（替换时间和I / O呼叫与您可用的电话或可根据您适当实施的电话）：

bool buttonPressHoldDetect( uint32_t hold_time_millisec )
{
   static bool release_pending = false ;
   bool button_hold_time_event = false ;

   static bool previous_button_pressed_state = isButtonPressed() ;
   bool button_pressed = isButtonPressed() ;

   // If button down...
   if( button_pressed )
   {
       // If it was previously up...
       if( !previous_button_pressed_state )
       {
           // Timestamp the button down event
           uint32_t button_down_start = getTickMillisec() ;
       }

       // If button held down for  hold time...
       if( !release_pending && 
           (getTickMillisec() - button_down_start) > hold_time_millisec )
       {
           button_hold_time_event = true ;
           release_pending  = false ;
       }
   }
   else
   {
       // button released, allow a subsequent press to be timed
       release_pending = false ;
   }
   
   // Retain previous state for event detection
   previous_button_pressed_state = button_pressed ;

   // Return true when the button has been 
   // held for hold time
   return button_hold_time_event;
}

然后，您将具有表单的投票循环：

for(;;)
{
    // If button held for three seconds...
    if( buttonPressHoldDetect( 3000 ) ;
    {
        // Do button held for three second stuff
    }

    // Do other stuff
}

零 - 列表 /无忙碌的等待投票使您可以在循环中执行其他工作。当然，其他工作也应避免延迟和繁忙的等待 - 您的循环时间（因此按钮轮询率）是循环中完成的所有工作（包括延迟）的总和，因此对于最响应的系统，您需要最大程度地减少完成的工作，并尽可能确定循环（恒定循环时间）。

具体来说：

• 您不需要使用中断（另一个也许是时间安排的刻度中断）。您可以，并且中断可能只是设置一个由isbuttonpresse（）返回的标志，但它仅添加了复杂性（尤其是WRT Switch de-Bounce），我建议简单地将其进行轮询，

• 您不应使用延迟 - 在延迟期间，您无需做其他有用的工作。
  （除非您使用的是多线程调度程序）。改用时间戳和经过时间，避免任何形式的“繁忙等待”。

您确实需要考虑开关反弹，这可以类似地处理：

bool isButtonPressed()
{
    static const uint32_t DEBOUNCE_MILLISEC = 20 ;
    static bool button_pressed = readInput( BUTTON ) != 0 ;
    static uint32_t button_event_time = 0 ;

    // Get the current time and button state
    uint32_t now = getTickMillisec() ;
    bool current_button_state = readInput( BUTTON ) != 0 ;

    // If button changes state after the debounce period...
    if( (now - button_event_time) > DEBOUNCE_MILLISEC
        && current_button_state != button_pressed )
    {
         // Change the button state and timestamp the event
         button_pressed = current_button_state ;
         button_event_time = now ;
    }

    return button_pressed ; 
}

进一步：如果循环中完成的工作很小，但是您需要一个特定而确定性的循环时间，该时间比身体执行时间更长（例如，这是必不可少的然后，在PID控件循环中：

static const int LOOP_TIME_MILLISEC = 20 ; // loop 50 times per second
int loop_start_time = 0 ;

for(;;)
{
    uint32_t now = getTickMillisec() ;

    // if time to start loop iteration...
    if( (now - loop_start_time) >= LOOP_TIME_MILLISEC )
    {
        loop_start_time = now ;

        // If button held for three seconds...
        if( buttonPressHoldDetect( 3000 ) ;
        {
            // Do button held for three second stuff
        }

        // Do other stuff
    }   
}

我很长一段时间没有使用AVR，但是如果您还没有合适的计时函数，则getTickMillisec（）（以及初始化和ISR）可以以以下方式实现：

#include <avr/io.h> ;
#include <avr/interrupt.h> ;

// Timer reload value for 1ms
#define SYSTICK_RELOAD (1000000UL / 1000)

// Millisecond counter
volatile uint32_t tick_millisec = 0 ;

ISR (TIMER1_COMPA_vect)
{
    tick_millisec ++;
}

void sysTickInit()
{
    // CTC mode, Clock/1
    TCCR1B |= (1 << WGM12) | (1 << CS10);

    // Load the output compare
    OCR1AH = (SYSTICK_RELOAD >> 8);
    OCR1AL = SYSTICK_RELOAD ;

    // Enable the compare match interrupt
    TIMSK1 |= (1 << OCIE1A);

    // Enable interrupts
    sei();
}

uint32_t getTickMillisec()
{
    uint32_t now = 0 ;

    // Read tick count and re-read if it is not consistent
    // (due interrupt pre-emption and update during non-atomic access)
    do
    {
        now = tick_millisec ;
    } while( now != tick_millisec ) ;

    return now ;
}
    

请注意getTickMillisec（） - 访问tick_millisec 在8位设备上是非原子一部分通过它被阅读。循环将其重新读取直到一致（即相同的值读了两次）。另外，您可以简单地禁用中断：

uint32_t getTickMillisec()
{
    // Read tick count with interrupts disabled to ensure consistency
    cli() ;
    uint32_t now = tick_millisec ;
    sei() ;

    return now ;
}
    

但这可能会影响中断处理程序的时机，因此最好避免。

有关16位timer1的详细信息，请参见 atmega8数据表来自第75页。