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

#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++;

    }

}

#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_ */

#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;

}