Dip Schalter Abfrage

[Andreas B. (andybuett)]

Hallo zusammen,

ich habe mit einem Kollegen eine kleine DMX Funk Schaltung um einen Dip 
Switch erweitert, um dabei die Frequenzen umschalten zu können. Leider 
sind wir beide nicht wirklich fit in C und haben jetzt das Problem, dass 
die Umschaltung nicht funktioniert. Die Platine an sich funktioniert und 
tut was sie soll aber wenn man die Dip Schalter betätigt ändert sich 
nichts.
Die PullUps sind gesetzt und funktionieren auch, kann man an der Platine 
nachmessen.
Ich denke es ist ein simples programmier Problem, auf das wir einfach 
nicht kommen.
Mir ist auch bewußt, dass man das schöner machen kann, allerdings könne 
wir es leider nicht!! ;-)

Über jegliche Hilfe sind wir dankbar!!!

Hier das Werk:

#define F_CPU 12000000
#define DMX_BAUD 250000
#define DMX_LOST_TIMEOUT 500
#define DMX_BAUD_BREAK 80000

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <avr/eeprom.h>
#include <util/delay.h>
#include <stdlib.h>
#include <string.h>
#include "rf22.h"

volatile unsigned char dmx_buffer[514];
volatile unsigned char dmx_tmp_buffer[33];
volatile unsigned char new_dmx_data = 0;

volatile unsigned int dmx_lost = DMX_LOST_TIMEOUT;
 

#define TRANSMIT_BLOCKS 16  //1 Block 32Channels max.16 Blocks 512Channels
#define TRANSMIT_REPEAT  64

//############################################################################
//DMX Senderoutine
ISR (USART_TX_vect)
//############################################################################
{
  static unsigned int  dmx_channel_tx_count = 1;
  static unsigned char dmx_tx_state = 0;
  
  switch (dmx_tx_state)
  {
    case (0):
      UBRR0   = (F_CPU / (DMX_BAUD_BREAK * 16L) - 1);
      UDR0 = 0; //RESET Frame
      dmx_tx_state = 1;
      break;

    case (1):
      UBRR0   = (F_CPU / (DMX_BAUD * 16L) - 1);
      UDR0 = 0; //Start Byte
      dmx_tx_state = 2;
      break;

    case (2):
      _delay_us(10);
      //Ausgabe des Zeichens
      UDR0 = dmx_buffer[dmx_channel_tx_count];
      dmx_channel_tx_count++;
      
      if(dmx_channel_tx_count == 512)
      {
        dmx_channel_tx_count = 1;
        dmx_tx_state = 0;
      }
      break;
  }
}


//############################################################################
//DMX Empfangsroutine (RS485)
ISR (USART_RX_vect)
//############################################################################
{
  static unsigned int dmx_channel_rx_count = 0;
  static unsigned char dmx_valid = 0;
  unsigned char tmp = 0;
  
  tmp =  UDR0;
  
  if(UCSR0A&(1<<FE0))
  {
    if(dmx_channel_rx_count > 1)
    {
      dmx_lost = 0;
    }
    dmx_channel_rx_count = 0;  
    dmx_buffer[0] = tmp;
    
    if(dmx_buffer[0] == 0)
    {
      dmx_valid = 1;
      dmx_channel_rx_count++;
    }
    else
    {
      dmx_valid = 0;
    }
    return;
  }
  
  if(dmx_valid)
  {
    if(dmx_buffer[dmx_channel_rx_count] != tmp)
    {
      dmx_buffer[dmx_channel_rx_count] = tmp;  
      new_dmx_data = TRANSMIT_REPEAT;
    }
  
    if(dmx_channel_rx_count < 514)
    {
      dmx_channel_rx_count++;
    }
    return;
  }
}

//############################################################################
//Hier wird die Zeit gez‰hlt (Tick 1ms)
ISR (TIMER2_COMPA_vect)
//############################################################################
{
  if(dmx_lost<DMX_LOST_TIMEOUT)
  {
    dmx_lost++;
  }
}

//############################################################################
//Hauptprogramm DMX FUNK ‹BERTRAGUNG
int main(void)
//############################################################################
{  
  unsigned int tmp;
  unsigned char packet_cnt = 0;
  unsigned long counter = 0;
  DDRB |= (1<<PB0); //LED PORT Output
  DDRD |= (1<<PD3); //Direction RS485 RX/TX
  
  PORTB |= (1<<0); //LED ON
  
//#############################################################  
  DDRC &= ~(1<<PC2); //M‰useklavier PINs als Eingang
  DDRC &= ~(1<<PC3);
  DDRC &= ~(1<<PC4);
  DDRC &= ~(1<<PC5);
  
  PORTC |= (1<<PC2); //M‰useklavier PULL UP einschalten
  PORTC |= (1<<PC3);
  PORTC |= (1<<PC4);
  PORTC |= (1<<PC5);
//#############################################################

  
  PORTC |= (1<<PC0);  //Pullup (Receiver/Transmitter)
  for(unsigned long b = 0;b<100000;b++){;asm("nop");};
  
  rf22_init();
  
//___________________________________________    
// Hier könnte das Problem liegen!!


  if ( ( !(PINC & (1<<PC2)) ) && (PINC & (1<<PC3)) && (PINC & (1<<PC4)) && (PINC & (1<<PC5)) )  // PINC2 eingeschaltet, 3, 4, 5 = 1; nicht eingeschaltet
    {
    rf22_setfreq(RF22FREQ(430.0));  // Frequenz z.B. jetzt 430 MHz
    }
    
  if ( (PINC & (1<<PC2)) && ( !(PINC & (1<<PC3)) ) && (PINC & (1<<PC4)) && (PINC & (1<<PC5)) )  // PINC3 eingeschaltet, 2, 4, 5 = 1; nicht eingeschaltet
  {
    rf22_setfreq(RF22FREQ(440.0));  // Frequenz z.B. jetzt 440 MHz
    }
  
//___________________________________________  
    
  
  
  rf22_rxmode();  
  
  
  if(PINC & (1<<PC0)) //Module als Sender oder Empf‰nger
  {
    PORTD &= ~(1<<PD3); //TX RS485
  
    //Init usart DMX-BUS
    UBRR0   = (F_CPU / (DMX_BAUD * 16L) - 1);
    UCSR0B|=(1 << RXEN0 | 1<< RXCIE0);
    UCSR0C|=(1<<USBS0); //USBS0 2 Stop bits  
    sei();//Globale Interrupts Enable
  
    //Timer2 Timecounter f¸r DMX Ausfall Kabel
    TCCR2A |= (1<<WGM21);
    TCCR2B |= (1<<CS22|1<<CS21|1<<CS20);
    TIMSK2 |= (1<<OCIE2A);
    OCR2A = F_CPU/1024/1000 - 1; //Tick Time
  
    while(1)
    {
      if(new_dmx_data > 0)
      {
        new_dmx_data--;  
        //512 Kan‰le werden zu je 32Bytes a 16 Packete versendet
        memcpy((unsigned char*)&dmx_tmp_buffer[1],(unsigned char *)&dmx_buffer[(packet_cnt*32)],32);
        dmx_tmp_buffer[0] = packet_cnt;
        packet_cnt++;
        
        if(packet_cnt == TRANSMIT_BLOCKS)
        {
          packet_cnt = 0;
        }
        
        rf22_sendpacket(dmx_tmp_buffer,33); //Packetcounter und 32DMX Bytes
      }
      
      //Abfrage ob DMX Packete via Kabel empfangen wurden
      if(dmx_lost==DMX_LOST_TIMEOUT)
      {
        PORTB &=~(1<<0); //LED AUS NO DMX
      }
      else
      {
        PORTB |= (1<<0); //LED AN DMX OK
      }  
    }
  }
  else
  {
    PORTD |= (1<<PD3); //RX RS485
    
    //Timer2 Timecounter f¸r DMX Ausfall Funk
    TCCR2A |= (1<<WGM21);
    TCCR2B |= (1<<CS22|1<<CS21|1<<CS20);
    TIMSK2 |= (1<<OCIE2A);  
    OCR2A = F_CPU/1024/1000 - 1; //Tick Time
    
    //Init usart DMX-BUS
    UBRR0   = (F_CPU / (DMX_BAUD * 16L) - 1);
    DDRD |= (1<<PD1); //Output TXD Pin ATmega88
    UCSR0B|=(1<<TXEN0)|(1<<TXCIE0); // TXEN0 Transmitter enable / TXCIE0 TX complete interrupt enable 
    UCSR0C|=(1<<USBS0); //USBS0 2 Stop bits  
    sei();//Globale Interrupts Enable
    UDR0 = 0;//Start DMX
    
    while(1)
    {  
      //Warte bis Packet empfangen wurde
      while(PIND&(1<<2))
      {
        if(dmx_lost == DMX_LOST_TIMEOUT)
        {
          PORTB &= ~(1<<0); //Status LED aus
          counter++;
          if(counter >1000000)
          {
            PORTB |= (1<<0);
            for(unsigned a = 0;a<5000;a++){;asm("nop");};
            PORTB &= ~(1<<0);
            counter = 0;
          }
        }
        else
        {
          PORTB |= (1<<0); //Status LED an
          counter = 0;
        }
      }

      tmp = rf22_getpacket(dmx_tmp_buffer); //Packetcounter und 32DMX Bytes
    
      //wurden alle Bytes empfangen?
      if(tmp == 33)
      {
        dmx_lost= 0;
        //512 Kan‰le werden zu je 32Bytes a 16 Packete empfangen
        packet_cnt = dmx_tmp_buffer[0];
        memcpy((unsigned char*)&dmx_buffer[(packet_cnt*32)],(unsigned char *)&dmx_tmp_buffer[1],32);
      }
    }
  }
}

[Hmmm (Gast)]

Andreas B. schrieb:
> rf22_setfreq(RF22FREQ(430.0));  // Frequenz z.B. jetzt 430 MHz
> rf22_setfreq(RF22FREQ(440.0));  // Frequenz z.B. jetzt 440 MHz

Da darfst Du nicht senden, und das Modul wird es Dir vermutlich auch 
nicht erlauben.

[Patrick J. (ho-bit-hun-ter)]

Hi

Ich sehe nicht Mal, wo Ihr die DIP-Schalter zum Programm-Start abfragt.

Ok, könnte damit zusammen hängen, daß mir C nicht viel sagt :)

Dann sehe ich weiter nicht, daß Ihr per Timer-Interrupt (oder bei dem 
DMX-lost) diese Schalter erneut abfragt und darauf reagiert.
Oder per PC-Interrupt auf Änderungen der DIP-Schalter reagiert.

MfG

[Stefan F. (Gast)]

> Ich sehe nicht Mal, wo Ihr die DIP-Schalter zum Programm-Start abfragt.

Direkt unter dem Kommentar "Hier könnte das Problem liegen"

Der Code zur Initialisierung von Port C und der Code zur Abfrage sehen 
Ok aus. Um ganz sicher zu sein, könntest du mit einer LED anzeiogen, ob 
und welche der beiden IF Bedingungen zutrifft. Oder du gibst 
Log-meldungen auf einem seriellen Port (wahlweise auf einem I/O Pin per 
Software Emulation) aus.

Genrell sollte man sich immer wenigstens einen I/O Pin für 
Statusanzeigen und zum Debugging frei halten. Ich hoffe, das ist bei 
Deiner Anwendung der Fall.

[Andreas B. (andybuett)]

Hmmm schrieb:
> Andreas B. schrieb:
>> rf22_setfreq(RF22FREQ(430.0));  // Frequenz z.B. jetzt 430 MHz
>> rf22_setfreq(RF22FREQ(440.0));  // Frequenz z.B. jetzt 440 MHz
>
> Da darfst Du nicht senden, und das Modul wird es Dir vermutlich auch
> nicht erlauben.

Das funktioniert aber ohne die Dip Schalter mit der original Schaltung 
so perfekt. Daran kann es nicht liegen.

Mit dem was Patrick schreibt kann ich auch nicht viel anfangen. 
Allerdings hört sich das schon schlüssig an. Müsste es dann aber nicht 
wenigstens teilweiße funktionieren??

[Andreas B. (andybuett)]

Stefan U. schrieb:
>> Ich sehe nicht Mal, wo Ihr die DIP-Schalter zum Programm-Start abfragt.
>
> Direkt unter dem Kommentar "Hier könnte das Problem liegen"
>
> Der Code zur Initialisierung von Port C und der Code zur Abfrage sehen
> Ok aus. Um ganz sicher zu sein, könntest du mit einer LED anzeiogen, ob
> und welche der beiden IF Bedingungen zutrifft. Oder du gibst
> Log-meldungen auf einem seriellen Port (wahlweise auf einem I/O Pin per
> Software Emulation) aus.
>
> Genrell sollte man sich immer wenigstens einen I/O Pin für
> Statusanzeigen und zum Debugging frei halten. Ich hoffe, das ist bei
> Deiner Anwendung der Fall.

Hört ich gut an. Daran habe ich auch schon gedacht! Aber wie ich das 
umsetzen soll weiß ich nicht!?
Könnte man nicht die LED an PB0 dafür nehmen?

Wie könnte denn ein Code Schnipsel dafür aussehen?

[Stefan F. (Gast)]

> Könnte man nicht die LED an PB0 dafür nehmen?

Sicher.

> Wie könnte denn ein Code Schnipsel dafür aussehen?

Sorry, aber DAS kannst du alleine herausfinden. LED's einschalten ist in 
sämtlichen Tutorials immer die allererste Übungsaufgabe.

[Andreas B. (andybuett)]

Stefan U. schrieb:
> Sorry, aber DAS kannst du alleine herausfinden. LED's einschalten ist in
> sämtlichen Tutorials immer die allererste Übungsaufgabe.

Das ist schon richtig und an sich auch nicht das Problem. Hatte das auch 
schon versucht, bin aber nicht weitergekommen. Evtl. weil das Problem 
schon davor lag! Werde es aber nochmal testen.

Falls sonst noch jemand einen Tip bzw. Vorschlag hat, wäre ich sehr 
dankbar!

[Andreas B. (andybuett)]

Habe Stefans Vorschlag beherzigt und nochmal mit der LED an PB0 
getestet. Hatte da beim ersten mal zu kompliziert gedacht Habe jetzt 
alles was die Frequenz Umschaltung angeht mal auskommentiert und 
wirklich nur mit der IF Abfrage versucht die LED an bzw. auch mal 
auszumachen. Leider ohne Erfolg!

Sprich der Fehler muss irgendwo dort, bei der Abfrage des Dips liegen! 
Aber wo?

[Stefan F. (Gast)]

Dann schalte die LED mal vor den IF Abfragen ein um zu sehen, ob dieser 
Block Code überhaupt ausgeführt wird.

[Peter D. (peda)]

Die Abfrage ist viel zu unleserlich und damit fehlerträchtig.
Definier erstmal ne Maske für die Inputs und dann entscheide per 
switch/case:

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

#define SWITCH_MASK (1<<2 | 1<<3 | 1<<4 | 1<<5)

void read_switch( void )
{
  DDRC &= ~SWITCH_MASK;
  PORTC |= SWITCH_MASK;
  DDRB |= 1<<0;
  _delay_us( 100 );               // time to tie open inputs high
  switch( PINC & SWITCH_MASK ){
    case 0b111000: PORTB |= 1<<0; break;
    case 0b110100: PORTB &= ~(1<<0); break;
  }
}

[Rufus Τ. F. (rufus)]

Peter D. schrieb:
> Die Abfrage ist viel zu unleserlich und damit fehlerträchtig.

Die Mischung aus Konstanten-Bitschieberei und des nicht-portablen 
0b-Präfixes findest Du leserlicher und weniger fehlerträchtig?

Insbesondere, da Du die Konstantenbitschieberei genau andersherum 
anstellst als die 0b-Konstanten schreibst ...

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

#define SWITCH_MASK (1<<5 | 1<<4 | 1<<3 | 1<<2)

#define SWITCH_A (1<<5 | 1<<4 | 1<<3)
#define SWITCH_B (1<<5 | 1<<4        | 1<<2)



void read_switch( void )
{
  DDRC &= ~SWITCH_MASK;
  PORTC |= SWITCH_MASK;
  DDRB |= 1<<0;
  _delay_us( 100 );               // time to tie open inputs high
  switch( PINC & SWITCH_MASK ){
    case SWITCH_A: PORTB |= 1<<0; break;
    case SWITCH_B: PORTB &= ~(1<<0); break;
  }

Hier sind natürlich sinnvollere Namen für die verschiedenen 
Schalterzustände zu wählen als "SWITCH_A", "SWITCH_B" etc.



}