ATmega 644P/ 32 - ADC, 7-Segment, Multiplexen: Problem

[Dominik (Gast)]

Hallo erstmal,

Programmierung:
Gcc, AVR Studio, Prozessor ATmega644P

Ziel:
Die Temperatur wird über einen KTY10 eingelesen und soll nun auf den 7 
Segmentanzeigen ausgegeben werden.

Den ADC hab ich zuerst alleine ohne Ausgabe geteste: Er gibt die ADC 
werte richtig aus (HTerm, UART). Nun wollte ich die drei 7 Segmente dazu 
schalten und einfach mal bis 999 zählen lassen umzu kontrolliern ob mein 
multiplexing Programm funktioniert. Jedoch tritt hier der Fehler auf: 
Compeliern funktioniert wunderbar, jedoch sieht es soaus als würden die 
7 Sgmente nun zu wenig Spannung bekommen (?), bzw. es leuchtet nur eines 
sehr schwach.
Wenn ich den ADC Init auskommentiere lauft das Programm wieder wunderbar 
(7-Segmente zählen bis 999).

An was kann das liegen?
wäre um jede Hilfe sehr dankbar :)

mfg Dominik

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

//#include "uart.h"
#include "multiplexen.h"

uint8_t ADCwert;    //globale Variable für ADC wert
int i, k, l;
void init_Port()
{
  DISPLAY_DDR= 0xFF;
  SEGMENTS_DDR=0xFF;
  DISPLAY_PORT=0x00;
  SEGMENTS_PORT=0x00;
  
}

void init_timerA()
{
  TCCR1B |= (1<<WGM12);    //CTC mode
  TCCR1B |= (1<<CS12);    // Prescaler - 256 - 62500
          
  TIMSK1 |= (1<<OCIE1A);
  OCR1A = 625;  // 16e6/256/1000
}

void init_timerB()
{
                    
  TCCR2B |= (1<<CS22);    //Prescaler 64
                
  TIMSK2 |= (1<<TOIE2);    //Overflow enable
}

ISR (TIMER1_COMPA_vect){
  
  i++;
  
  if(i==1000) i=0;
  
  if(i<10)
  {
    display_array[0] = i%10;
  }
  else if(i>=10 && i<100)
  {
    display_array[0] = i%10;
    display_array[1] = (i%100-i%10)/10;    // z.B: 
  }
  else if(i>=100 && i<1000){
    display_array[0] = i%10;
    display_array[1] = (i%100-i%10)/10;
    display_array[2] = (i%1000-i%100)/100;
  }    
  else
  {
    display_array[0]=0;
    display_array[1]=0;
    display_array[2]=0;
  }    

}  

ISR(TIMER2_OVF_vect){
  refresh_display();
}  

void inti_ADC()
{
  int result;            //dient zur Aufwährmung des ADC
  
  ADMUX |= (1<<REFS0);          
  ADMUX &= ~ (1<<REFS1);          //AVCC wird als Reference eingestellt 
  
  ADCSRA |= (1<<ADEN);          //ADC wird Enabled, kann verwendet werden 
  ADCSRA |= (1<<ADSC);        // ADC Start Conversation, 
  //ADCSRA |= (1<<ADATE);          //Der ADC arbeitet im FreeRunning Mode, 
  ADCSRA |= (1<<ADIE);              //ADC-Interrupt aktiviert
  ADCSRA |= ((1<<ADPS0) | (1<<ADPS2) | (1<<ADPS1));    //Prescaler 128 
  
  while ( ADCSRA & (1<<ADSC) ) {}// auf Abschluss der Konvertierung warten}
    result = ADCW;          // ADCW muss einmal gelesen werden,
                      // sonst wird Ergebnis der nächsten Wandlung
                      // nicht übernommen.
}

uint8_t read_wert(uint8_t channel)
{
                         // Kanal waehlen, ohne andere Bits zu beeinflußen
  ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);
  ADCSRA |= (1<<ADSC);                 // eine Wandlung "single conversion"
  while (ADCSRA & (1<<ADSC) ) {}  // auf Abschluss der Konvertierung warten
  return ADCW;                      // ADC auslesen und zurückgeben
//  adc_wert = ADCW;
}

int main(void)
{
  init_Port();
  init_timerA();
  init_timerB();
  inti_ADC();
  //uart_init();
  init_Port();
  
  DDRA &=~(1<<PA0);    //Input ADC - Temp.Sensor
  
  //**************************Varbialen************************************
  char text [] = "ADC-WERT:_";
  char wert[20];
  
  sei();

    while(1)
    {
    ADCwert = read_wert(0);
  /*  
    for (i=0;text[i];i++)
      uart_putchar(text[i]);
    
    sprintf (wert, "%3.1d",ADCwert);
    
    for (i=0; wert[i];i++)
      uart_putchar(wert[i]);
      
    _delay_ms(1000);  
    
        //TODO:: Please write your application code 
    */
  int p=0;
  p++;
    }
}

*****************************************************
multiplexen.h
*****************************************************

#ifndef MULTIPLEXEN_H_
#define MULTIPLEXEN_H_


unsigned int display_array[3];

#define SEGMENTS_DDR  DDRB
#define SEGMENTS_PORT  PORTB
#define DISPLAY_DDR    DDRD  
#define DISPLAY_PORT  PORTD

//****************************_Init_7_Segment_*****************************
#define a  0b00000001
#define b  0b00000010
#define c  0b00000100
#define d  0b00001000
#define e  0b00010000
#define f  0b00100000
#define g  0b01000000
#define dp  0b10000000

#define NULL  a|b|c|d|e|f
#define EINS  b|c
#define ZWEI  a|b|g|e|d
#define DREI  a|b|c|d|g
#define VIER  b|c|f|g
#define FUENF  a|f|g|c|d
#define SECHS  a|f|g|e|d|c
#define SIEBEN  a|b|c
#define ACHT  a|b|c|d|e|f|g
#define NEUN  a|b|c|d|f|g

//***************************_Init_von_2_Segmente_**************************
#define EINER    0b00000001
#define ZEHNER    0b00000010
#define HUNDERTER  0b00000100


void refresh_display();




#endif /* MULTIPLEXEN_H_ */

***************************************************
multiplexen.c
**************************************************

#include <avr/io.h>
#include "multiplexen.h";


unsigned int cnt=0;

void refresh_display(){
  
  //Display disable
  DISPLAY_PORT = 0x00;
  SEGMENTS_PORT= 0x00;
  
  switch (display_array[cnt]) {
    case 0:  SEGMENTS_PORT |= NULL;  break;
    case 1:  SEGMENTS_PORT |= EINS;  break;
    case 2:  SEGMENTS_PORT |= ZWEI;  break;
    case 3:  SEGMENTS_PORT |= DREI;  break;
    case 4:  SEGMENTS_PORT |= VIER;  break;
    case 5:  SEGMENTS_PORT |= FUENF;  break;
    case 6:  SEGMENTS_PORT |= SECHS;  break;
    case 7:  SEGMENTS_PORT |= SIEBEN;  break;
    case 8:  SEGMENTS_PORT |= ACHT;  break;
    case 9:  SEGMENTS_PORT |= NEUN;  break;
  }
  switch (cnt) {
    case 0:    DISPLAY_PORT |= EINER;  break;          //Zuschalten der jeweiligen Anzeige
    case 1:    DISPLAY_PORT |= ZEHNER; break;
    case 2:    DISPLAY_PORT |= HUNDERTER; break;
  }
  cnt++;                        //steter Wechsel zwischen Anzeigen
  if (cnt == 3)
    cnt = 0;
}

[Krapao (Gast)]

Dein AVR stürzt dauernd ab, weil du in inti_ADC() einen IRQ frei gibst, 
für den du keine ISR hast. AVR startet, LED-Anzeige startet, AVR stürzt 
ab, LED-Anzeige ist dunkel...

[Dominik (Gast)]

ah danke für die schnelle Antwort :)

hmm bin wirklich noch der Leihe im Gebiet AVR programmierung.

hab jz den: ADCSRA |= (1<<ADIE);              //ADC-Interrupt
deaktiviert.

Was wäre denn dein Lösungsvorschlag wie ich dieses Problem am besten 
bewältige?

mfg Dominik

[Krapao (Gast)]

> hab jz den:
> ADCSRA |= (1<<ADIE); //ADC-Interrupt
> deaktiviert.

Welches Problem jetzt noch? Dass du ADCwert noch auf die Anzeige bringen 
musst?

volatile uint16_t spannung;

ISR (TIMER1_COMPA_vect)
{
  // i++;
  // if(i==1000) i=0;
  i = spannung; // Anzuzeigende Spannung kopieren, 
                // dann Ziffern extrahieren
...

in main():
[C]
...
    // Ref.: AVCC with external capacitor at AREF pin
    ADCwert = read_wert(0);
    // Anzeige der Spannung in "Centivolt",
    // da Anzeige nur dreistellig
    ADCwert = (ADCwert * 500UL) / 1024;
    cli(); // atomarer Zugriff!
    spannung = ADCwert;
    sei();
...
[C]

[Dominik (Gast)]

hab vorhin vergessen zuschreiben,
Die ADC-Werte lassen sich nun auf den 7Segment Anzeigen ausgeben.
Möchte ich aber die Werte mit dem UART zusätzlich auslesen, gibts ein 
Problem.

  init_Port();
  init_timerA();
  init_timerB();
  inti_ADC();
  uart_init(); // Problemm
  init_Port();

Wenn ich uart_init(); mit einbeziehe fangen die 7 Segmente zu flakern 
an... bzw. iwas zu tun...(?)

#define F_CPU 16000000UL
#define BAUD 19200UL
#define UBRR_BAUD ((F_CPU/(16UL*BAUD))-1)


unsigned char uart_putchar(unsigned char x)
{
  //Warten bis der Sendepuffer frei ist
  while(!(UCSR0A & (1<<UDRE0)));
  //Daten in den Puffer schreiben und damit senden
  UDR0= x;
  return(x);
}


unsigned char uart_getchar()
{
  //Warten bis Daten empfangen wurden
  while(!(UCSR0A & (1<<RXC0)));
  //Empfangsregister auslesen
  return(UDR0);
}


//USART initialisieren
void uart_init(void)
{
  //Baudrate einstellen (nomal MOde)
  UBRR0H = (uint8_t) (UBRR_BAUD>>8);
  UBRR0L = (uint8_t) (UBRR_BAUD & 0x0ff); //uint8_t

  //Aktivieren von receiver und transmitter
  UCSR0B =(1<<RXEN0)|(1<<TXEN0);

  //Einstellen des Datenformats: 8 Datenbits, 1 Stopbit, no Parity
  //UCSR1C= (1<<URSEL)|(1<<UCSZ11)|(1<<UCSZ10);
  UCSR0C= (1<<UCSZ01)|(1<<UCSZ00);
}

[Krapao (Gast)]

> #define DISPLAY_DDR    DDRD
> #define DISPLAY_PORT  PORTD

Die TX/RX Leitungen hängen beim Atmega644P doch auch auf Port D. Es ist 
klar, dass sich UART und Display beeinflussen. Vielleicht kannst du das 
Display auf Port C hängen und den Code umschreiben (Defines anpassen).

[Krapao (Gast)]

Port C: JTAGEN Fuse abschalten nicht vergessen!

[Dominik (Gast)]

super danke für deine Hilfe :)
funktiniert alles

ich werde nun noch einen kleinen 5V Computerventilator in mein kleines 
Projekt implementieren :) der in abhängigkeit der Temperatur, schneller 
oder langsamer dreht.

ich melde mich wenn es geklappt hat :)

danke nochmals
mfg Dominik