RV8564 Interrupt funktioniert nicht

anfänger Gast #4339723
Lesenswert?
• ▲
▼ 
Hallo Leute,

folgendes Problem: Ich hbe hier einen Atmega32 und ein RV8564 RTC-Modul 
per I2C gekoppelt. Die Verbindung per I2C funktioniert sehr gut und nun 
wollte ich über das RTC- Modul sekündlich ein Interrupt am INT0 Pin 
auslösen.
Ich habe die Einstellungen in den Registern des RTC-Moduls vorgenommen 
sowie den INT0-Interrupt im Atmega32 aktiviert.

Zum testen hab ich eine kleine Testroutine in der INT0-ISR geschrieben. 
Allerdings tut sich da absolut nichts.

Hier der Programmabschnitt der nicht arbeitet (LCD ist initialisiert und 
funktioniert, hab hier nur den abschnitt stehen der nicht funktioniert)

1
ISR(INT0_vect)                        

2
{

3
    lcd_clear();

4
    lcd_setcursor(0,0);

5
    lcd_string("Test");

6
    _delay_ms(500);

7
    lcd_clear();

8
  

9
}

10


11
void rtc_init(void){

12
  rtc_writetimercontrol(0b10000010);

13
  rtc_writecontrol2(0b00000001);

14
  

15
  //INT0 Interrupt initialisieren

16
  MCUCR |= (1<<ISC01);

17
  GICR |= (1<<INT0 );

18
}

19
rtc_init();

20
sei();

21
int main (void)

22
{  

23
        while(1){

24


25
        }

26
}


Fällt euch auf was ich falsch gemacht habe?
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Anfänger Gast #4344969
Lesenswert?
• ▲
▼ 
Brauche da jetzt glaub ich wirklich Hilfe, ich finde meinen Fehler 
einfach nicht:

main.c
1
#include <avr/io.h>

2
#include <util/delay.h>

3
#include <avr/pgmspace.h>

4
#include <avr/interrupt.h>

5
#include <stdlib.h>

6
#include <inttypes.h>

7
#include "main.h"

8
#include "lcd.h"

9
#include "drehgeber.h"

10
#include "lcd_anzeigen.h"

11
#include "beep.h"

12
#include "rtc.h"

13
#include "i2cmaster.h"

14
#include "irmp.h"

15


16


17


18
ISR(TIMER0_COMP_vect)                        

19
{  

20
  

21
  (void) irmp_ISR(); 

22
  (void)encoderinterrupt();

23
  

24
}

25


26
ISR(INT0_vect)                        

27
{

28
    beep_att();

29
  

30
}

31


32


33
int main (void)

34
{  

35
  MCUCR |= (1<<ISC01);

36
  GICR |= (1<<INT0 );

37
  pin_input_init();

38
  pin_output_init();

39
  timer0_init();

40
  timer2_init();

41
  i2c_init();

42
  rtc_init();

43
  lcd_init();

44
  sei();

45
  lcd_led_onoff(1);

46
  lcd_intro();

47
  while(1){

48
    

49
    

50
  }

51
  

52
  

53
return 0;

54
}


rtc.c
1
#include <avr/io.h>

2
#include <util/delay.h>

3
#include "i2cmaster.h"

4
#include "rtc.h"

5


6
//Integer zu BCD Converter

7
void rtc_init(void){

8
  rtc_writetimercontrol(0b10000010);

9
  rtc_writecontrol2(0b00010001);

10
  

11
  //INT0 Interrupt initialisieren

12
  

13
}

14
uint8_t itobcd(uint8_t i)

15
{

16
   uint8_t lo, hi = 0;

17


18
   //Fehler mit unmoeglicher Zahl "von aussen" erkennbar machen

19
   if(i > 99)

20
      return(0xFF);

21


22
   //Division, entspricht "hi = i/10;"

23
   while (i > 9)

24
   {

25
      hi++;

26
      i -= 10;

27
   }

28


29
   //Der Rest der Division ist noch in "i", das ist der lo-Anteil

30
   //Der Compiler wird die Variable "lo" wegoptimieren

31
   lo = i;

32


33
   return((hi << 4) | lo);

34
}

35
/*

36


37
Auslesen der Register für Sekunde,Minute,Stunde,Tag,Monat,Jahr & Wochentag

38


39
*/

40


41
int rtc_readsek(void){

42
  int read;

43
  int sek;

44
  i2c_start(RTC_ADRESS_WRITE);

45
  i2c_write(RTC_SECONDS);

46
  i2c_rep_start(RTC_ADRESS_READ);

47
  read=i2c_readNak();

48
  i2c_stop();

49
  sek = (((read & 0x70) >> 4)*10)+(read & 0x0F);

50
  

51
  return sek;

52
}

53


54
int rtc_readmin(void){

55
  int read;

56
  int min;

57
  i2c_start(RTC_ADRESS_WRITE);

58
  i2c_write(RTC_MINUTES);

59
  i2c_rep_start(RTC_ADRESS_READ);

60
  read=i2c_readNak();

61
  i2c_stop();

62
  min = (((read & 0x70) >> 4)*10)+(read & 0x0F);

63
  

64
  return min;

65
}

66


67
int rtc_readhour(void){

68
  int read;

69
  int hour;

70
  i2c_start(RTC_ADRESS_WRITE);

71
  i2c_write(RTC_HOURS);

72
  i2c_rep_start(RTC_ADRESS_READ);

73
  read=i2c_readNak();

74
  i2c_stop();

75
  hour = (((read & 0x30) >> 4)*10)+(read & 0x0F);  // NOCH BEARBEITEN STUNDENREGISTER IST ANDERS AUFGEBAUT ALS SEKUNDEN MINUTEN UND STUNDEN

76
  

77
  return hour;

78
}

79


80
int rtc_readday(void){

81
  int read;

82
  int day;

83
  i2c_start(RTC_ADRESS_WRITE);

84
  i2c_write(RTC_DAYS);

85
  i2c_rep_start(RTC_ADRESS_READ);

86
  read=i2c_readNak();

87
  i2c_stop();

88
  day = (((read & 0x30) >> 4)*10)+(read & 0x0F);  // NOCH BEARBEITEN STUNDENREGISTER IST ANDERS AUFGEBAUT ALS SEKUNDEN MINUTEN UND STUNDEN

89
  

90
  return day;

91
}

92


93
int rtc_readweekday(void){

94
  int read;

95
  int weekday;

96
  i2c_start(RTC_ADRESS_WRITE);

97
  i2c_write(RTC_WEEKDAYS);

98
  i2c_rep_start(RTC_ADRESS_READ);

99
  read=i2c_readNak();

100
  i2c_stop();

101
  weekday = (read & 0x07);

102
  

103
  return weekday;

104
  

105
}

106
int rtc_readyear(void){

107
  int read;

108
  int year;

109
  i2c_start(RTC_ADRESS_WRITE);

110
  i2c_write(RTC_YEARS);

111
  i2c_rep_start(RTC_ADRESS_READ);

112
  read=i2c_readNak();

113
  i2c_stop();

114
  year = (((read & 0x70) >> 4)*10)+(read & 0x0F);

115
  

116
  return year;

117
}

118


119
int rtc_readmonth(void){

120
  int read;

121
  int month;

122
  i2c_start(RTC_ADRESS_WRITE);

123
  i2c_write(RTC_MONTH_CENTURY);

124
  i2c_rep_start(RTC_ADRESS_READ);

125
  read=i2c_readNak();

126
  i2c_stop();

127
  month = (read & 0x1F);

128
  

129
  return month;

130
  

131
}

132


133
/*

134


135
Beschreiben der Register des RTC

136


137
*/

138


139
void rtc_writecontrol1(int input){

140
  i2c_start(RTC_ADRESS_WRITE);

141
  i2c_write(RTC_CONTROL_STATUS1);

142
  i2c_write(input);

143
  i2c_stop();

144
}

145


146
void rtc_writecontrol2(int input){

147
  i2c_start(RTC_ADRESS_WRITE);

148
  i2c_write(RTC_CONTROL_STATUS2);

149
  i2c_write(input);

150
  i2c_stop();

151
}

152


153
void rtc_writeweekdays(int input){

154
  i2c_start(RTC_ADRESS_WRITE);

155
  i2c_write(RTC_WEEKDAYS);

156
  i2c_write(input);

157
  i2c_stop();

158
}

159


160
void rtc_writesek(int input){

161
  i2c_start(RTC_ADRESS_WRITE);

162
  i2c_write(RTC_SECONDS);

163
  i2c_write(itobcd(input));

164
  i2c_stop();

165
}

166


167
void rtc_writemin(int input){

168
  i2c_start(RTC_ADRESS_WRITE);

169
  i2c_write(RTC_MINUTES);

170
  i2c_write(itobcd(input));

171
  i2c_stop();

172
}

173


174
void rtc_writehour(int input){

175
  i2c_start(RTC_ADRESS_WRITE);

176
  i2c_write(RTC_HOURS);

177
  i2c_write(itobcd(input));

178
  i2c_stop();

179
}

180


181
void rtc_writeday(int input){

182
  i2c_start(RTC_ADRESS_WRITE);

183
  i2c_write(RTC_DAYS);

184
  i2c_write(itobcd(input));

185
  i2c_stop();

186
}

187
void rtc_writeyear(int input){

188
  i2c_start(RTC_ADRESS_WRITE);

189
  i2c_write(RTC_YEARS);

190
  i2c_write(itobcd(input));

191
  i2c_stop();

192
}

193


194
void rtc_writemonth(int input){

195
  i2c_start(RTC_ADRESS_WRITE);

196
  i2c_write(RTC_MONTH_CENTURY);

197
  i2c_write(input);

198
  i2c_stop();

199
}

200


201
void rtc_writeminutealarm(int enable,int input){

202
  int minalarm;

203
  minalarm = ((enable<<7) | itobcd(input));

204
  i2c_start(RTC_ADRESS_WRITE);

205
  i2c_write(RTC_MINUTE_ALARM);

206
  i2c_write(minalarm);

207
  i2c_stop();

208
}

209


210
void rtc_writehouralarm(int enable,int input){

211
  int houralarm;

212
  houralarm = ((enable<<7) | itobcd(input));

213
  i2c_start(RTC_ADRESS_WRITE);

214
  i2c_write(RTC_HOUR_ALARM);

215
  i2c_write(houralarm);

216
  i2c_stop();

217
}

218


219
void rtc_writedayalarm(int enable,int input){

220
  int dayalarm;

221
  dayalarm = ((enable<<7) | itobcd(input));

222
  i2c_start(RTC_ADRESS_WRITE);

223
  i2c_write(RTC_DAYALARM);

224
  i2c_write(dayalarm);

225
  i2c_stop();

226
}

227


228
void rtc_writeweekdayalarm(int enable,int input){

229
  int weekdayalarm;

230
  weekdayalarm = ((enable<<7) | itobcd(input));

231
  i2c_start(RTC_ADRESS_WRITE);

232
  i2c_write(RTC_WEEKDAY_ALARM);

233
  i2c_write(weekdayalarm);

234
  i2c_stop();

235
}

236


237
void rtc_writeclkout(int input){

238
  i2c_start(RTC_ADRESS_WRITE);

239
  i2c_write(RTC_CLKOUT_FREQUENCY);

240
  i2c_write(input);

241
  i2c_stop();

242
}

243


244
void rtc_writetimercontrol(int input){

245
  i2c_start(RTC_ADRESS_WRITE);

246
  i2c_write(RTC_TIMER_CONTROL);

247
  i2c_write(input);

248
  i2c_stop();

249
}

250


251
void rtc_writetimer(int input){

252
  i2c_start(RTC_ADRESS_WRITE);

253
  i2c_write(RTC_TIMER);

254
  i2c_write(input);

255
  i2c_stop();

256
}


Es wird partout kein Interrupt ausgelöst... was ist das verkehrt? 
Erkennt es jemand?
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Anfänger Gast #4345940
Lesenswert?
• ▲
▼ 
Cyblord -. schrieb:
> Anfänger schrieb:
> Ich werde heute Abend mal das Osziloskop ran hängen. Der Fehler muss ja
> eigentlich da liegen.
>
> So was kann man auch erst mal machen BEVOR man einen Thread eröffnet.
> Also wirklich....

Ich bin stark von einem Softwarefehler ausgegangen deswegen der Thread.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren