membervariable in isr ändern

[Franz (Gast)]

Hallo,
ich versuche zum ersten mal einen Mikrocontroller in C++ zu 
Programmieren. Das funktioniert auch soweit ganz gut, bis auf ISR. Diese 
habe ich als external "C" eingebunden.
Hierbei habe ich Probleme.
So habe ich eine ISR für einen Timer,
timer.h

#ifndef TIMER_H_
#define TIMER_H_

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

extern "C" void TIMER0_COMPA_vect(void) __attribute__ ((signal));
extern "C" void TIMER2_COMPA_vect(void) __attribute__ ((signal));

class timer {
    
    public:
    timer(volatile uint8_t &tccra, uint8_t tccraNewState,
          volatile uint8_t &tccrb, uint8_t tccrbNewState,
          volatile uint8_t &ocra, uint8_t ocraNewState,
          volatile uint8_t &timsk, uint8_t timskNewState);
    ~timer();

    uint16_t getMilliseconds();
    uint8_t getSeconds();
    uint8_t getMinutes();
    uint8_t getHours();
    bool    getNewTime();

    void setMilliseconds(uint16_t milliseconds);
    void setSeconds(uint8_t seconds);
    void setMinutes(uint8_t minutes);
    void setHours(uint8_t hours);
    void setNewTime(bool newTime);

    friend void TIMER0_COMPA_vect(void);
    friend void TIMER2_COMPA_vect(void);
    
    static uint8_t _newTime;

    private:
    uint8_t _tccrb;
    uint8_t _tccrbNewState;
    static uint16_t _milliseconds;
    static uint8_t _seconds;
    static uint8_t _minutes;
    static uint8_t _hours;


};

#endif

timer.cpp

#include <avr/interrupt.h>
#include <avr/io.h>
#include "timer.h"
#include "../Button/button.h"

uint16_t timer::_milliseconds = 0;
uint8_t timer::_seconds = 0;
uint8_t timer::_minutes = 0;
uint8_t timer::_hours = 0;
uint8_t timer::_newTime = 0;



timer::timer(volatile uint8_t &tccra, uint8_t tccraNewState,
             volatile uint8_t &tccrb, uint8_t tccrbNewState,
             volatile uint8_t &ocra, uint8_t ocraNewState,
             volatile uint8_t &timsk, uint8_t timskNewState)
{
    tccra |= tccraNewState;
    tccrb |= tccrbNewState;
    ocra |= ocraNewState;
    timsk |= timskNewState;
}

timer::~timer()
{
}

uint16_t timer::getMilliseconds()
{
    return _milliseconds;
}

void timer::setMilliseconds(uint16_t milliseconds)
{
    _milliseconds = milliseconds;
}

uint8_t timer::getSeconds()
{
    return _seconds;
}

void timer::setSeconds(uint8_t seconds)
{
    _seconds = seconds;
}

uint8_t timer::getMinutes()
{
    return _minutes;
}

void timer::setMinutes(uint8_t minutes)
{
    _minutes = minutes;
}

uint8_t timer::getHours()
{
    return _hours;
}

void timer::setHours(uint8_t hours)
{
    _hours = hours;
}

bool timer::getNewTime()
{
    return _newTime;
}

void timer::setNewTime(bool newTime)
{
    _newTime = newTime;
}

void TIMER0_COMPA_vect(void)
{
    timer::_milliseconds++;
    timer::_newTime = true;
    if(timer::_milliseconds >= 500 )
    {
        PORTB ^= ( 1 << PORTB5 );
        timer::_seconds++;
        timer::_milliseconds = 0;
        timer::_newTime = true;
        if(timer::_seconds >= 10 )
        {
            timer::_minutes++;
            timer::_seconds = 0;
            if(timer::_minutes >= 10)
            {
                timer::_hours++;
                timer::_minutes = 0;
                if(timer::_hours >= 10)
                {
                    timer::_hours = 0;
                }
            }
        }
    }
}


void TIMER2_COMPA_vect(void)
{
    static uint16_t millis = 0;
    static uint8_t seconds = 0;
    millis++;
    if(millis >= 500 )
    {
        //PORTB ^= ( 1 << PORTB5 );
        seconds++;
        millis = 0;
    }

}

In der Hauptfunktion erstelle ich zwei Timer (timer0 timer2) (AVR, beide 
Timer 8-bit).

Problem 1)
in der while-Schleife in der Hauptfunktion frage ich die Variable 
_newTime ab. Wenn diese True ist, ist eine Sekunde vorüber. Zum Testen 
habe ihc diese mal vor dem Sekundenübergang gesetzt. Diese wird also bei 
jedem Interrupt true.
Aus der HAuptfunktion

if(timer0.getNewTime() == true)
    {
        timer0.setMilliseconds(0);

damit setzte ich die Millisekunden immer wieder auf null, sodass nie 
eine Sekunde vergeht und die LED nicht blinkt. Das funktioniert auch. 
schreibe ich allerdings

timer2.setMilliseconds(0)

passiert genau das selbe. Also die Millisekunden von Timer0 werden 
zurückgesetzt. Aber warum? Ich wollte eigentlich die Millisekunden von 
timer2 zurücksetzen.

Problem2)
Ich habe einen weiteren Interrupt(einen externen Interrupt -> Button). 
Wenn ich diesen drücke, möchte ich gerne die Zeiten alle auf 0 setzen. 
Allerdings kennt die ISR vom Button die Objekte timer0 und timer2 nicht. 
Wie kann ich dennoch auf die Variablen zugreifen?

Franz

[Rolf M. (rmagnus)]

Franz schrieb:
> Also die Millisekunden von Timer0 werden zurückgesetzt. Aber warum?

Na weil du geschrieben hast, dass alle einen gemeinsamen 
millisekunden-Zähler haben sollen:

> static uint16_t _milliseconds;
  ~~~~~~

Was meinst du denn, was static macht?

[Franz (Gast)]

Wie kann ich denn in der ISR auf die Variablen zugreifen? Habe sie schon 
Public gemacht, aber dadurch das in der ISR kein Objekt vorhanden ist, 
kennt diese die Variablen nicht.

[MaWin (Gast)]

Franz schrieb:
> aber dadurch das in der ISR kein Objekt vorhanden ist,

Dann musst du die Objekte bekanntmachen.

[Franz (Gast)]

MaWin schrieb:
> Dann musst du die Objekte bekanntmachen.

Weisst du auch, wie ich das am besten mache? Oder besser noch, hast du 
einen Link oder ähnliches, wo ich mir das beschrieben ist?

[MaWin (Gast)]

Franz schrieb:
> Weisst du auch, wie ich das am besten mache? Oder besser noch, hast du
> einen Link oder ähnliches, wo ich mir das beschrieben ist?

Im einfachsten Fall sind die Instanzen einfach globale Objekte. Das kann 
dann natürlich noch beliebig komplizierter werden mit Pointern und new 
oder ähnlichem.