Attiny13A Atmel Studio6 Simulation überspringt Code

[Flo (Gast)]

Hallo,
ich lasse geade eine Atmel Studio 6 ATtiny13A Simulation laufen und ich 
drehe langsam durch....
Das Prgramm überspringt immer die unten im code mit "#!#" makierten 
Zeilen!
( #!# sind nicht im Code vorhanden)
Ich bekomme es nicht hin, dass die ausgeführt werden. Schritt für 
schritt ausführen springt immer über die beiden zeilen und durchlaufen 
lassen zeigt auch keine wirkung.
Wisst ihr was da los ist?

LG,
Florian

uint16_t readVccVoltage(void) {
  // Returns the current Vcc voltage as a fixed point number with 3 implied decimal places, i.e.
  // 5000 = 5.000 volts, 2500 = 2.500 volts, 1900 = 1.900 volts
  
  V_DEV_ON; //turning on the voltage divider by setting PB0 low
  
  // Select ADC input PB2 and 1.1V (Internal Ref) 
  ADMUX = (1<<REFS0)|(1<<MUX0);
  
  // Enable ADC, set prescaller to /8 which will give a ADC clock of 1.2Mhz/8 = 150kHz
  ADCSRA = (1<<ADEN) | (1<<ADPS1) | (1<<ADPS0) ;
  
  _delay_ms(1);

  ADCSRA |= (1<<ADSC); // Start a conversion
  while( ADCSRA & (1<<ADSC) ) ; // Wait for 1st conversion to be ready...
  //..and ignore the result
  uint8_t dummy = ADCH;
  
  ADCSRA |= (1<<ADSC); // Start a conversion
  while( ADCSRA & (1<<ADSC) ) ; // Wait for conversion to be ready...
  V_DEV_OFF;  // turning PB0 high to save voltage at the voltage divider
  
  uint8_t low = ADCL;
  uint8_t high = ADCH;
  
#!#  uint16_t adcVal = (high << 8) | low; // 0<= result <=1023
  
#!#  uint16_t Vin = (uint16_t)((uint16_t)4100*adcVal)/1000;
  
  ADCSRA &= ~(1<<ADEN ); // Disable ADC to save power
  return(Vin);
}

[chris (Gast)]

Da die beiden Variablen nicht benutzt werden, werden die beiden Zeilen 
wohl wegoptimiert.

[Flo (Gast)]

Aber die variablen werden doch benutzt. adcVal wird in der Vin Rechnung 
genutzt und Vin wird aus der Funktion retruned.

[chris (Gast)]

ups das habe ich übersehen :(
dann vergiss meine Bemerkung von oben^^

[Christian K. (the_kirsch)]

Der Compiler hat wohl einfach den Code bei optimiert, deswegen 
überspringt der Simulator die Zeilen.

statt

uint8_t low = ADCL;
uint8_t high = ADCH;
uint16_t adcVal = (high << 8) | low;

kann man auch

uint16_t adcVal = ADCW;

schreiben.


warum rechnest du hier nicht einfach mal 41 und dann durch 10, das 
reicht doch, oder willst du absichtlich einen integer Überlauf 
provozieren?

uint16_t Vin = (uint16_t)((uint16_t)4100*adcVal)/1000;

[Peter II (Gast)]

Christian K. schrieb:
> uint16_t Vin = (uint16_t)((uint16_t)4100*adcVal)/1000;

so mal die ganze cast nicht notwendig sind. denn adcVal ist ja schon 
uint16_t

[Thomas E. (thomase)]

Flo schrieb:
> Aber die variablen werden doch benutzt. adcVal wird in der Vin Rechnung
> genutzt und Vin wird aus der Funktion retruned.

Aber weiter werden sie nicht genutzt. Deshalb schmeisst der Compiler das 
gnadenlos raus und berechnet das in den Registern.

Deklariere die beiden Variablen zum Debuggen global und volatile, dann 
kriegst du auch einen Breakpoint darauf.

  return(4100* (high << 8) | low) / 1000);

//besser:
  return(41* ADC / 10);

Mehr wird da doch nicht gemacht. Was glaubst du, wozu ein Optimierer da 
ist?


mfg.

[Flo (Gast)]

Hallo Leute,
vielen Dank für eure Hilfe! Ich habe da eindeutig was dummes gemacht und 
das ACDW kannt ich noch nicht.

uint8_t low = ADCL;
uint8_t high = ADCH;
uint16_t adcVal = (high << 8) | low; // 0<= result <=1023
uint16_t Vin = (uint16_t)((uint16_t)4100*adcVal)/1000;
wurde durch
uint16_t Vin = (41*ADCW)/10;
ersetzt

Klappt wunderbar und spart Speicher. Vielen Dank!

[Bernd K. (prof7bit)]

Flo schrieb:
> uint8_t low = ADCL;
> uint8_t high = ADCH;
>
> uint16_t adcVal = (high << 8) | low; // 0<= result <=1023

Du kannst auch direkt:

uint16_t adcVal = ADC

16 bit in einem Rutsch auslesen (oder besser gesagt vom Compiler in 2 
8bit Zugriffe aufteilen und zusammenführten lassen, sieht aufgeräumter 
aus)


>> uint16_t Vin = (uint16_t)((uint16_t)4100*adcVal)/1000;

Das wird bei der Multiplikation überlaufen, probiers stattdessen mal so:

uint16_t Vin = (uint16_t)((uint32_t)4100*adcVal)/1000;