Atmega 1284 Pin-Change Interrupt, funktioniert nicht

[Matthias (Gast)]

Hallo zusammen,

Ich bin grade ahnungslos über die Art des Problems.
Ich möchte 7 Taster über die PinChange Interrupts auswerten.

Tatsächlich hat es in meinem Komplett-Programm mit den Tastern niemals 
so funktioniert dass der gewünschte Wert herausgekommen wäre, zudem 
hatte ich noch diverse sehr seltsame nebeneffekte mit den Tastern.

Daher habe ich den Code immer weiter reduziert bis nur noch dies hier 
bleibt:

Die Taster funktionieren leider überhaupt nicht.
Auf die LEDs kann ich jedoch die Wunschwerte ausgeben.

Könnt ihr mir vielleicht sagen, warum das mit den Tastern so absolut 
überhaupt nicht funktionieren kann?
Ich habe schon Stunden investiert ohne nun überhaupt noch eine Idee zu 
haben...

GetSwitch.c

/*PChange 
PC2 = 18 / SW5 
PC3 = 19 / SW4 
PC4 = 20 / SW3 
PC5 = 21 / SW2 
PC6 = 22 / SW1 
PC7 = 23 / SW0 --> PC = 0xfc
PD6 = 30 / SW6 --> PD = 0x40
*/

void SW_Init()
{
  PCICR  = 0x0c; //--> PC+PD 
  PCMSK0 = 0x00;
  PCMSK1 = 0x00;
  PCMSK2 = 0xfc;
  PCMSK3 = 0x40;
}

Main.c

#ifndef F_CPU
#define F_CPU 20000000UL
#endif

#include <avr/interrupt.h>
#include <avr/io.h>
#include <util/delay.h>
#include <string.h>
#include <stdlib.h>
#include "GetSwitch.h"

uint8_t switches =0x00;

void InituC()
{
  DDRA |= 0xff;   //D4/D5/D6/D7/RS/E/BEL/LED4 --> Alle Ausgang
  DDRB |= 0x0f;   //LED3/LED2/LED1/LED0       --> Als Ausgang, SPI unverändert
  DDRC |= 0x03;   //Switches 5/4/3/2/1/0 als eingang, I2C als Ausgang
  DDRD |= 0xb4;   //LED5/LED6/SPK/RGB-LED    --> Ausgang
  
  PORTA |= 0x00;  //All Outputs
  PORTB |= 0x00;  //All outputs/undefined
  PORTC |= 0xff;  //SW 0..5 with Pull-Up
  PORTD |= 0x40;  //SW 6 with Pull-Up
  SW_Init();    //Initialize Taster
  sei();          //Global IRQ-Enable
  //SW_Init();    //Initialize Taster

}
  
int main(void)
{
    InituC();
    while(1)
    {
  LEDs(switches);
    }
}

ISR (PCINT2_vect)
{
  if (!(PIND&0x40)) // Detect rising Edge
  {
    switches |= 0x40; // Reset by function-call
  }
  else
  {
    switches &= 0xbf; // Reset by function-call
  }  
}
ISR (PCINT3_vect)
{
  if (!(PINC&0x80))
  {
    switches |= 0x01;
  }
  else
  {
    switches &= 0xfe; // Reset by function-call
  }
  if (!(PINC&0x40))
  {
    switches |= 0x02;
  }
  else
  {
    switches &= 0xfd; // Reset by function-call
  }
  if (!(PINC&0x20))
  {
    switches |= 0x04;
  }
  else
  {
    switches &= 0xfb; // Reset by function-call
  }
  if (!(PINC&0x10))
  {
    switches |= 0x08;
  }
  else
  {
    switches &= 0xf7; // Reset by function-call
  }
  if (!(PINC&0x08))
  {
    switches |= 0x10;
  }
  else
  {
    switches &= 0xef; // Reset by function-call
  }
  if (!(PINC&0x04))
  {
    switches |= 0x20;
  }
  else
  {
    switches &= 0xdf; // Reset by function-call
  }
}

Viele Grüße,
Matthias

[Matthias (Gast)]

Habe nun 2Taster die wie erwartet funktionieren und der Code sieht so 
aus:

Es sind PD6 und PC2. Die anderen haben keine Funktion.
Verständniss für das Problem habe ich dennoch keines??

#ifndef F_CPU
#define F_CPU 20000000UL
#endif

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

uint8_t switches =0xff;

void InituC()
{
  DDRA |= 0xff;   //D4/D5/D6/D7/RS/E/BEL/LED4 --> Alle Ausgang
  DDRB |= 0x0f;   //LED3/LED2/LED1/LED0       --> Als Ausgang, SPI unverändert
  DDRC |= 0x03;   //Switches 5/4/3/2/1/0 als eingang, I2C als Ausgang
  DDRD |= 0xb4;   //LED5/LED6/SPK/RGB-LED    --> Ausgang
  
  PORTA |= 0x00;  //All Outputs
  PORTB |= 0x00;  //All outputs/undefined
  PORTC |= 0xff;  //SW 0..5 with Pull-Up // c-->f
  PORTD |= 0x40;  //SW 6 with Pull-Up
  SW_Init();    //Initialize Taster
  sei();          //Global IRQ-Enable
}

void SW_Init()
{
  PCICR  = 0x0c; //--> PC+PD 
  PCMSK0 = 0x00;
  PCMSK1 = 0x00;
  PCMSK2 = 0xfc;
  PCMSK3 = 0x40;
}
  
int main(void)
{
  InituC();
    while(1)
    {
    _delay_ms(300);
    LEDs(switches);
    }
}

ISR (PCINT2_vect)
{
  switches = 0x0f;
}
ISR (PCINT3_vect)
{
  switches = 0x55;
}

[Ralf G. (ralg)]

Matthias schrieb:
> DDRC |= 0x03;   //Switches 5/4/3/2/1/0 als eingang, I2C als Ausgang
Matthias schrieb:
> PORTC |= 0xff;  //SW 0..5 with Pull-Up // c-->f

Die Zuweisungen mach nicht das, was im Kommentar steht.

Edit(h) meint noch:
Für bessere Übersicht würde ich die Schreibweise mit '0bnnnnnnnn' 
verwenden.

[HildeK (Gast)]

Ralf G. schrieb:
> Matthias schrieb:
>> DDRC |= 0x03;   //Switches 5/4/3/2/1/0 als eingang, I2C als Ausgang
>
> Die Zuweisungen mach nicht das, was im Kommentar steht.

Doch, schon. SW 5..0 hängen an PC7...PC2.

> Matthias schrieb:
>> PORTC |= 0xff;  //SW 0..5 with Pull-Up // c-->f
Da hast du recht, aber es schadet auch nicht, dass die beiden freien 
Pins PC1 und PC0 auf HIGH gesetzt sind.
Eher unschön ist, dass es in PORTB und PORTD einige Pins gibt als 
Eingang ohne Pullup. Beides hat aber vermutlich nichts mit seinem 
Problem zu tun.

[Ralf G. (ralg)]

HildeK schrieb:
> Doch, schon. SW 5..0 hängen an PC7...PC2.
Aaah, verstehe... steht weiter oben.

[S. Landolt (Gast)]

Ohne mir das näher anzuschauen, die Standardfrage in solchen Fällen: 
JTAG? (liegt auf C2..5)

[Stefan F. (Gast)]

Die Variable "switches" muss volatile sein, weil sie sowohl innerhalb 
von ISR als auch außerhalb von ihnen benutzt wird. Der Compiler neigt 
sonst dazu, sie in CPU Registern zu cachen und verpasst dadurch 
Änderungen durch die ISR.

Die internen Pull-Up Widerstände sind langfristig zu schwach. Die 
allermeisten Taster benötigen mehr Stromfluss, um langfristig gut zu 
kontaktieren. Deswegen empfehle ich im finalen Aufbau Widerstände 
zwischen 1kΩ und 4,7kΩ zu verwenden. Das Fachwort dazu ist "Wetting 
Current". Ist leider in den wenigstens Datenblättern angegeben.

Die Kontakte von Tastern prellen. Wenn der Interrupt ausgelöst wird, 
weil ein Kontakt geschlossen wurde, dann kann die darauf folgende 
Abfrage durchaus "Taste ist nicht gedrückt" liefern.

Ich empfehle dir, Taster in einem Timer-Interrupt abzufragen. Zum 
Beispiel alle 10ms. Dort kannst du auch sie auch bequem per Software 
entprellen.

Dazu hat der Peter einen umfangreichen Artikel samt vorbildlichem 
Beispielcode geschrieben 
https://www.mikrocontroller.net/articles/Entprellung.

[Matthias (Gast)]

Hallo zusammen,
Vielen Dank für die kommentare :)

S. Landolt schrieb:
> Ohne mir das näher anzuschauen, die Standardfrage in solchen Fällen:
> JTAG? (liegt auf C2..5)

Der JTAG ist ausgefused.

Ich bin nun etwas weiter.

Habe die Funktion aller taster durch
LEDs(PINC>>2);
getestet, die jeweilige LED geht bei Tastensruck aus, ebenso bei Port D.
Somit sollte die HW an sich in orndung sein.

Auch habe ich getestet ob die Pin-Change IRQs überhaupt mal ausgeführt 
werden.
-->Ja sie werden ausgeführt, und dies auch für jeden Taster.

Habe es gefunden, die Interruptvektoren waren vertauscht!!!
Habe schon meiner Frau die Sache erklärt... und war am zweifeln ob ich 
nicht eine UND verknüpfung falsch verstehe...

Unglaublich.

Vielen Dank für eure Kommentare :)

Hier noch die schlussendliche lösung:

#ifndef F_CPU
#define F_CPU 20000000UL
#endif

#include <avr/interrupt.h>
#include <avr/io.h>
#include <util/delay.h>
#include <string.h>
#include <stdlib.h>
#include "GetSwitch.h"

uint8_t switches =0x00;

uint8_t get_sw(void)
{
  uint8_t ret = switches;
  switches = 0x00;
  return ret;
}

void set_sw(uint8_t inp)
{
  switches = switches | inp;
}

void InituC()
{
  DDRA |= 0xff;   //D4/D5/D6/D7/RS/E/BEL/LED4 --> Alle Ausgang
  DDRB |= 0x0f;   //LED3/LED2/LED1/LED0       --> Als Ausgang, SPI unverändert
  DDRC |= 0x03;   //Switches 5/4/3/2/1/0 als eingang, I2C als Ausgang
  DDRD |= 0xb4;   //LED5/LED6/SPK/RGB-LED    --> Ausgang
  
  PORTA |= 0x00;  //All Outputs
  PORTB |= 0x00;  //All outputs/undefined
  PORTC |= 0xff;  //SW 0..5 with Pull-Up // c-->f
  PORTD |= 0x40;  //SW 6 with Pull-Up
  SW_Init();    //Initialize Taster
  sei();          //Global IRQ-Enable
}
  
int main(void)
{
  InituC();
    while(1)
    {
    _delay_ms(300);
    LEDs(get_sw());
    }
}

ISR (PCINT3_vect)
{
  uint8_t pd = PIND;
  if (!(pd&0x40)) // Detect falling Edge
  {
    set_sw(0x40);
  }
}

ISR (PCINT2_vect)
{
  uint8_t pc = PINC;
  if (!(pc&0x80))
  {
    set_sw(0x01);
  }
  if (!(pc&0x40))
  {
    set_sw(0x02);
  }
  if (!(pc&0x20))
  {
    set_sw(0x04);
  }
  if (!(pc&0x10))
  {
    set_sw(0x08);
  }
  if (!(pc&0x08))
  {
    set_sw(0x10);
  }
  if (!(pc&0x04))
  {
    set_sw(0x20);
  }
}

Vielleicht bring das ja jemandem noch was...

[Matthias (Gast)]

Stefan ⛄ F. schrieb:
> Die Variable "switches" muss volatile sein, weil sie sowohl innerhalb
> von ISR als auch außerhalb von ihnen benutzt wird. Der Compiler neigt
> sonst dazu, sie in CPU Registern zu cachen und verpasst dadurch
> Änderungen durch die ISR.

Vielen Dank für den Hinweis, hast recht baue ich gleich ein...

Die Funktionalität selbst möchte ich erstmal so nutzen...

[Stefan F. (Gast)]

Matthias schrieb:
> Die Funktionalität selbst möchte ich erstmal so nutzen...

Dann musst du extern mit R/C Gliedern entprellen, falls es zuverlässig 
funktionieren soll.

[Matthias (Gast)]

Stefan ⛄ F. schrieb:
> Dann musst du extern mit R/C Gliedern entprellen, falls es zuverlässig
> funktionieren soll.

Durch die Funktionenn set_sw und get_sw sehe ich es als entprellt an.
Es wird ja nicht immer abgefragt.

Mit den Pull-Ups hast du recht, ich verwende den I2C da liegen die Pins 
von taster und SDA diekt nebeneinander. Der Switch hat mehrfach ohne 
Betätigung ausgelöst. Nun mit Pull-Up passiert das nicht mehr :)

[Stefan F. (Gast)]

Matthias schrieb:
> Nun mit Pull-Up passiert das nicht mehr :)

Das wäre ein weiterer Grund für externe stärkere Pull-Ups, hat mit dem 
von mir gemeinten Wetting Current allerdings nichts zu tun.

[HildeK (Gast)]

Stefan ⛄ F. schrieb:
> Das wäre ein weiterer Grund für externe stärkere Pull-Ups,

IMHO sind die internen gut zum Verhindern, dass ein ungenutzter 
Eingangspin floatet. Für funktional genutzte Pins sollte man immer einen 
externen spendieren.

[Peter D. (peda)]

Matthias schrieb:
> Durch die Funktionenn set_sw und get_sw sehe ich es als entprellt an.

Entprellen durch die sich rein zufällig ergebenden Programmlaufzeiten 
ist die mit Abstand schlechteste Entprellmethode.

Besser Du entprellst sie gleich richtig. Eine Entprelllib hat den 
Charme, daß sie fertige Ereignissse liefert und man sich fürderhin nie 
mehr drum kümmern muß.

Es ist aber Deine Sache, ob Du die faulen Eier drinlassen willst und 
erst später darüber stolperst. Je älter die faulen Eier, umso besser 
stinken sie, sprich umso mehr Aufwand macht es, sie zu beseitigen.

[c-hater (Gast)]

Peter D. schrieb:

> Entprellen durch die sich rein zufällig ergebenden Programmlaufzeiten
> ist die mit Abstand schlechteste Entprellmethode.

Jepp. Das ergibt sich ja schon aus dem Problem selber. Wenn man logisch 
denken kann...

> Besser Du entprellst sie gleich richtig. Eine Entprelllib hat den
> Charme, daß sie fertige Ereignissse liefert und man sich fürderhin nie
> mehr drum kümmern muß.

Ja, wenn man faul und doof ist, ist das sicher die optimale Lösung.

Wenn's aber etwas spezieller wird (z.B.: benutze ein- und dieselbe 
Matrix für Taster-Polling und LED-Multiplexing), dann muß man doch 
wieder selber aktiv werden. Natürlich könnte man den vorhandenen (guten) 
Entprellcode dafür benutzen und entsprechend aufhübschen, aber dazu 
müsste man ihn erstmal verstanden haben.

Und das ist ja nun gerade wieder nicht das Ding der Dummen und Faulen...

Die sind halt immer irgendwie gearscht. Ungerechte Welt...