MPLABX - Timer-Verfahren (nach Peter Dannegger) AVR

[Karl W. (acm2014)]

möchte gerne die Routine von Peter Dannegger testen.

kann mir jemand dabei helfen? bin neu in der PIC Programmierung.

habe einen pic12f1572, mplabx, einen taster mit led.

nutze den INTOSC mit 4MHZ, und die ISR mit 1ms Timer. (war Vorgabe)

kann man das so übersetzen wie ich es mache?

Hier das Programm:

#include <xc.h>
#include <stdbool.h>

//*** PIC12F1572 Configuration Bit Settings
// CONFIG1
#pragma config FOSC = INTOSC    
#pragma config WDTE = OFF      
#pragma config PWRTE = ON       
#pragma config MCLRE = ON     
#pragma config CP = OFF         
#pragma config BOREN = OFF      
#pragma config CLKOUTEN = OFF   

//*CONFIG2
#pragma config WRT = OFF        
#pragma config PLLEN = ON      
#pragma config STVREN = ON      
#pragma config BORV = LO       
#pragma config LPBOREN = OFF    
#pragma config LVP = ON         

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


//#define KEY_DDR         TRISA   // DDRB
//#define KEY_PORT        LATA    // PORTB
#define KEY_PIN         PORTA   // PINB
#define KEY0            0
#define KEY1            PORTAbits.RA4   // BUTTON
#define KEY2            2
#define ALL_KEYS        (1<<KEY0 | 1<<KEY1 | 1<<KEY2)

#define REPEAT_MASK     (1<<KEY1 | 1<<KEY2)       // repeat: key1, key2
#define REPEAT_START    500                       // after 500ms
#define REPEAT_NEXT     200                       // every 200ms

#define LED_DDR         TRISA  // DDRA
#define LED_PORT        LATA   // PORTA
#define LED0            0
#define LED1            LATAbits.LATA2    // LED
#define LED2            2

#define word unsigned int

// global variables
volatile word key_state;             // debounced and inverted key state:
                                     // bit = 1: key pressed
volatile word key_press;             // key press detect
volatile word key_rpt;               // key long press and repeat
static word ct0,ct1,rpt;
word i;
static word w1ms = 248;              // overflow factor


void interrupt isr(void)
{
    TMR0 = 256 - w1ms;        // increment interrupt count (every 1000 us)

    i = key_state ^ ~KEY_PIN;            // key changed ?
    ct0 = ~( ct0 & i );                  // reset or count ct0
    ct1 = ct0 ^ (ct1 & i);               // reset or count ct1
    i &= ct0 & ct1;                      // count until roll over ?
    key_state ^= i;                      // then toggle debounced state
    key_press |= key_state & i;          // 0->1: key press detect

    if( (key_state & REPEAT_MASK) == 0 ) // check repeat function
       rpt = REPEAT_START;               // start delay
    if( --rpt == 0 ){
      rpt = REPEAT_NEXT;                 // repeat delay
      key_rpt |= key_state & REPEAT_MASK;  
    }

    INTCONbits.TMR0IF = 0;               // clear interrupt flag
}

///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed. Each pressed key is reported
// only once
//
word get_key_press( word key_mask )
{
  di();                        // disable global interrupts
  key_mask &= key_press;                          // read key(s)
  key_press ^= key_mask;                          // clear key(s)
  ei();                        // enable global interrupts
  return key_mask;
}

///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed long enough such that the
// key repeat functionality kicks in. After a small setup delay
// the key is reported being pressed in subsequent calls
// to this function. This simulates the user repeatedly
// pressing and releasing the key.
//
word get_key_rpt( word key_mask )
{
  di();                        // disable global interrupts
  key_mask &= key_rpt;                            // read key(s)
  key_rpt ^= key_mask;                            // clear key(s)
  ei();                        // enable global interrupts
  return key_mask;
}

///////////////////////////////////////////////////////////////////
//
// check if a key is pressed right now
//
word get_key_state( word key_mask )

{
  key_mask &= key_state;
  return key_mask;
}

///////////////////////////////////////////////////////////////////
//
word get_key_short( word key_mask )
{
  di();                        // disable global interrupts
  return get_key_press( ~key_state & key_mask );
}

///////////////////////////////////////////////////////////////////
//
word get_key_long( word key_mask )
{
  return get_key_press( get_key_rpt( key_mask ));
}

int main(void)
{
    //*** Initialisation
    // configure port
    ANSELA = 0x00;             // set PortA digital
    LED_PORT = 0b00000100;     // Set RA2 high  -> LED off
    LED_DDR = 0b00011011;   // set RA2 as output and RA4, RA5 as input

    // Configure debouncing routines
    //KEY_DDR &= ~ALL_KEYS;   // configure key port for input
    //KEY_PORT |= ALL_KEYS;   // and turn on pull up resistors

    /*
    TCCR0 = (1<<CS02)|(1<<CS00);         // divide by 1024
    TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5); 
    TIMSK |= 1<<TOIE0;                   // enable timer Interrupt
    sei();
    */

    // configure oscillator
    OSCCONbits.SCS1= 1;          // select Internal oscillator block
    OSCCONbits.IRCF = 0b1101;    // Set Internal Oscillator to 4MHz HF
                                 // -> 1 us / instruction cycle

    // configure Timer0
    OPTION_REGbits.TMR0CS = 0;   // select timer mode
    OPTION_REGbits.PSA = 0;      // assign prescaler to Timer0
    OPTION_REGbits.PS  = 0b001;  // prescaling = 4, 255 * 1us * 4
                                 // -> increment TMR0 every 1024 uss

    // enable interrupts
    INTCONbits.TMR0IE = 1;       // enable Timer0 interrupt
    ei();                        // enable global interrupts

      while(1){
        if( get_key_short( 1<<KEY1 ))
          LED_PORT ^= 1<<LED1;

        if( get_key_long( 1<<KEY1 ))
          LED_PORT ^= 1<<LED2;

        // single press and repeat

        if( get_key_press( 1<<KEY2 ) || get_key_rpt( 1<<KEY2 )){
          word i = LED_PORT;

          i = (i & 0x07) | ((i << 1) & 0xF0);
          if( i < 0xF0 )
            i |= 0x08;
          LED_PORT = i;
        }
      }
    return 0;
}