Programm läuft nur mit JTAG Fuse

Philipp L. schrieb:

> Woran kann das liegen?

Singularität im Raum-Zeit-Kontinuum?

Grüßle
Volker

Was passiert denn, wenn du JTAG nur zur Laufzeit (statt per Fuse) 
ausschaltest?

Aber allgemein lässt sich die Frage kaum beantworten. Da braucht es 
schon paar Details mehr zur Beschaltung.

Gebe euch gern alle Infos, bin echt ratlos..

Philipp L. schrieb:
> Sobald ich die Fuse "HIGHJTAGEN" aber abschalte, funktioniert das
> Programm nicht mehr.

Das wird dann wohl an dem Programm liegen (lt. meinem Kaffeesatz).

Was passiert nun, wenn du JTD zur Laufzeit setzt?

1

/*

2

 * Aquacooler-V0.4-V0.1.c

3

 *

4

 * Created: 21.06.2020 13:51:20

5

 * Author : Viech

6

 */ 

7

8

//Defines

9

//------------------------------------------------------------------------------------------------------------------------------------------------ Defines

10

#define ENC_B      (1<<PD4)

11

#define ENC_B_1      (PIND & ENC_B)

12

13

14

15

16

//Includes

17

//------------------------------------------------------------------------------------------------------------------------------------------------ Includes

18

19

#include <avr/pgmspace.h>

20

#include <avr/io.h>

21

#include <stdlib.h>

22

#include <util/delay.h>

23

#include <avr/interrupt.h>

24

#include <util/sbit.h>

25

#include "UART.h"

26

#include "lcd.h"

27

#include "global.h"

28

#include "menu.h"

29

#include "ADCauslesen.h"

30

#include "internerADC.h"

31

#include "ADCwandeln.h"

32

33

34

//Variablen

35

//------------------------------------------------------------------------------------------------------------------------------------------------ Variablen

36

37

uint8_t pos = 0;

38

uint8_t Taster = 0;

39

char Wert[10];

40

41

uint16_t Test = 0;

42

uint8_t menuaktiv = 0;

43

44

//Init

45

//------------------------------------------------------------------------------------------------------------------------------------------------ Init

46

void initialisierung (void)

47

{

48

49

  DDRA &= ~(1<<PA0);                //PA0 als Eingang deklarieren (NTC3  = Wärmetauscher)

50

  DDRA &= ~(1<<PA1);                //PA1 als Eingang deklarieren (NTC4  = Kühlkörper)

51

  DDRA &= ~(1<<PA2);                //PA2 als Eingang deklarieren (NTC5  = Lufttemperatur Eintritt)

52

  DDRA &= ~(1<<PA3);                //PA3 als Eingang deklarieren (NTC6  = Lufttemperatur Austritt)

53

  DDRA &= ~(1<<PA4);                //PA4 als Eingang deklarieren (Temp7 = Platinentemperatur)

54

  DDRA &= ~(1<<PA5);                //PA5 als Eingang deklarieren (Reserve)

55

  DDRA &= ~(1<<PA6);                //PA6 als Eingang deklarieren (VMESS = Ausgangsspannung)

56

  DDRA &= ~(1<<PA7);                //PA7 als Eingang deklarieren (SOLL von SPS =  )

57

58

  DDRB &= ~(1<<PB0);                //PB0 als Eingang deklarieren (FAN1_RPM  = Drehzahl Hauptlüfter)

59

  DDRB &= ~(1<<PB1);                //PB1 als Eingang deklarieren (FAN2_RPM  = Drehzahl Platinenlüfter)

60

  DDRB &= ~(1<<PB2);                //PB2 als Eingang deklarieren (ON        = Einschaltbefehl von extern)

61

  DDRB |= (1<<PB3);                //PB3 als Ausgang deklarieren (Pumpe     = Pumpe einschalten)

62

  DDRB &= ~(1<<PB4);                //PB4 als Eingang deklarieren (Reserve)

63

  DDRB &= ~(1<<PB5);                //PB5 als Eingang deklarieren (MOSI = nicht für andere Funktion verwendet)

64

  DDRB &= ~(1<<PB6);                //PB6 als Eingang deklarieren (MISO = nicht für andere Funktion verwendet)

65

  DDRB &= ~(1<<PB7);                //PB7 als Eingang deklarieren (SCK  = nicht für andere Funktion verwendet)  

66

67

  DDRC &= ~(1<<PC0);                //PC0 als Eingang deklarieren (SCL        = Bus zu Displayplatine intern)

68

  DDRC &= ~(1<<PC1);                //PC1 als Eingang deklarieren (SDA        = Bus zu Displayplatine intern)

69

  DDRC |= (1<<PC2);                //PC2 als Ausgang deklarieren (ADC_RST    = ADC Reset)

70

  DDRC |= (1<<PC3);                //PC3 als Ausgang deklarieren (EN         = Buck einschalten)

71

  DDRC |= (1<<PC4);                //PC4 als Ausgang deklarieren (HLF_BRD_L2 = Brücke low side Seite 2)

72

  DDRC |= (1<<PC5);                //PC5 als Ausgang deklarieren (HLF_BRD_H2 = Brücke high Side Seite 2)

73

  DDRC |= (1<<PC6);                //PC6 als Ausgang deklarieren (HLF_BRD_L1 = Brücke low side Seite 1)

74

  DDRC |= (1<<PC7);                //PC7 als Ausgang deklarieren (HLF_BRD_H1 = Brücke high Side Seite 1)  

75

76

  DDRD &= ~(1<<PD0);                //PD0 als Eingang deklarieren (RXD      = Bus zu Lichtcontroller)

77

  DDRD &= ~(1<<PD1);                //PD1 als Eingang deklarieren (TXD      = Bus zu Lichtcontroller)

78

  DDRD &= ~(1<<PD2);                //PD2 als Eingang deklarieren (S0       = Taster von Inkrementalgeber / INT0)

79

  DDRD &= ~(1<<PD3);                //PD3 als Eingang deklarieren (IN_A     = Inkrementalgeber / INT1)

80

  DDRD &= ~(1<<PD4);                //PD4 als Eingang deklarieren (IN_B     = Inkrementalgeber)

81

  DDRD |= (1<<PD5);                //PD5 als Ausgang deklarieren (OC1A     = Ausgangsspannung von Buck)

82

  DDRD |= (1<<PD6);                //PD6 als Ausgang deklarieren (FAN2_PWM = Drehzahlregelung Hauptlüfter)

83

  DDRD |= (1<<PD7);                //PD7 als Ausgang deklarieren (FAN1_PWM = Drehzahlregelung Platinenlüfter)  

84

85

  EICRA |= (1<<ISC01);              //INT0 (Taster Inkrementalgeber)  wird bei fallender Flanke ausgelöst

86

  EICRA |= (1<<ISC11);              //INT1 (Drehung Inkrementalgeber) wird bei fallender Flanke ausgelöst

87

  EIMSK |= (1<<INT0);                //Ext. Int0 aktivieren

88

  EIMSK |= (1<<INT1);                  //Ext. Int1 aktivieren

89

90

  TCCR0A = (1<<WGM00)+(1<<WGM01);          // WGM0,WGM1,WGM2 = 1 -> Fast PWM mit OCR0A=TOP

91

  TCCR0B = (1<<WGM02)+(1<<CS02)+(1<<CS00);    // CS00,CS02 = 1 -> prescaler = 1024 

92

  OCR0A = 78;                    // bei 8Mhz und prescaler von 1024 gibt es nach 0,009984s einen interrupt          

93

  TIMSK0 = (1<<TOIE0);              // Timer Overflow interrupt enable

94

95

  ICR1 = 1000;                  //TOP-Wert für Zähler = 1000

96

  OCR1A = 800;                  //Vergleichsregister = 1

97

  TCCR1A = (1<<COM1A1)+(1<<WGM11);        //WGM11+12+13 = Fast PWM mit ICR1 als TOP

98

  TCCR1B = (1<<WGM12)+(1<<WGM13)+(1<<CS10);    //CS10 = no prescaler

99

100

  OCR2A = 250;                      //Vergleichsregister = 125 -> 50%

101

  OCR2B = 50;                      //Vergleichsregister = 125 -> 50%

102

  TCCR2A = (1<<COM2A1)+(1<<COM2B1)+(1<<WGM20)+(1<<WGM21);  //WGM20+21 = Fast PWM mit 0xFF als TOP

103

  TCCR2B = (1<<CS20);                    //CS21 = no prescaler

104

105

  ICR3 = 7812;                      //TOP-Wert für Zähler = 7812

106

  TCCR3A = (1<<WGM31);                  //WGM11+12+13 = Fast PWM mit ICR1 als TOP

107

  TCCR3B = (1<<WGM33)+(1<<WGM32)+(1<<CS32)+(1<<CS30);    //CS30+CS32 = prescaler 1024

108

  TIMSK3 = (1<<TOIE3);                  //Timer3 overflow interrupt enable

109

110

//  MCUCR|=(1<<JTD);                // An dieser Stelle läuft der uC nicht an

111

//  MCUCR|=(1<<JTD);                // An dieser Stelle läuft der uC nicht an

112

113

  adcinit();                    //Externen ADC Initialisieren

114

  ADC_Init();                    //Internen ADC initialisieren

115

116

  USART_Init(uartbaud);              //UART mit 9600 baud initialisieren

117

118

  MCUCR|=(1<<JTD);

119

  MCUCR|=(1<<JTD);

120

121

  sei();                      //Interrupts generell aktivieren

122

}

123

124

125

126

//Interrupts

127

//------------------------------------------------------------------------------------------------------------------------------------------------ Interrupts

128

129

ISR (INT0_vect)                    //Bei interrupt int0 (Taster Inkrementalgeber)

130

{

131

  Taster = 1;

132

}

133

134

135

ISR (INT1_vect)                    //Bei interrupt int1 (Drehung Inkrementalgeber)

136

{

137

  if(ENC_B_1)                    //Encoder B == 1

138

  pos--;

139

  else

140

  pos++;

141

}

142

143

144

ISR (TIMER3_OVF_vect)

145

{

146

  PID_I++;

147

  menuaktiv = 1;

148

}

149

150

151

152

ISR (TIMER0_OVF_vect)

153

{

154

155

}

156

157

158

//Main

159

//------------------------------------------------------------------------------------------------------------------------------------------------ Main

160

161

int main(void)

162

{

163

    /* Replace with your application code */

164

165

  initialisierung();

166

  LCD_I2C_ADR = 0x3C;                // Display 1

167

  lcd_init(LCD_DISP_ON);              // init lcd and turn on

168

  LCD_I2C_ADR = 0x3D;                // Display 2

169

  lcd_init(LCD_DISP_ON);              // init lcd and turn on

170

171

172

  Menu1();

173

174

  PORTC |= (1<<PC2);                  //ADC ein

175

  PORTC |= (1<<PC3);                  //Buck = ein

176

  PORTB |= (1<<PB3);                  //Pumpe = ein

177

178

  PORTC |= (1<<PC4);                //H-Brücke L1=ein

179

  PORTC |= (1<<PC5);                //H-Brücke H1=ein

180

181

  PORTC &= ~(1<<PC6);                //H-Brücke L2=ein

182

  PORTC &= ~(1<<PC7);                //H-Brücke H2=ein

183

184

185

  while (1) 

186

    {

187

188

  if (menuaktiv == 1)

189

  {

190

  Menu1();

191

  menuaktiv = 0;

192

  }

193

194

  adcdata = Auslesen();

195

  RNTC = ADC_to_NTC_bridge(adcdata);

196

  Tempin = NTC_to_Temp(RNTC);

197

198

  adcdata = ADC_Read(0);

199

  RNTC = ADC_to_NTC_div(adcdata,5.03,1024,9980);

200

  Luftout = NTC_to_Temp(RNTC);

201

202

  adcdata = ADC_Read(1);

203

  RNTC = ADC_to_NTC_div(adcdata,5.03,1024,9980);

204

  Luftin = NTC_to_Temp(RNTC);

205

206

  adcdata = ADC_Read(2);

207

  RNTC = ADC_to_NTC_div(adcdata,5.03,1024,9980);

208

  Tauscher = NTC_to_Temp(RNTC);

209

210

  adcdata = ADC_Read(3);

211

  RNTC = ADC_to_NTC_div(adcdata,5.03,1024,9980);

212

  Kuehler = NTC_to_Temp(RNTC);

213

214

  adcdata = ADC_Read(4);

215

  Buck = MCP9700_to_Temp(adcdata,5.0,1024);

216

217

218

   }

219

220

}

Okay...

Wenn ich das vor sei() in der Funktion "Initialisierung" schreibe, läuft 
das Programm und die Ports sind verfügbar.

Wenn ich das aber 3 Zeilen höher ansiedele, läuft nix.
Gefühlt läuft der uC nicht an und es sind alle Ports aus.
Auch direkt am Anfang der Initialisierung() geht es nicht.

Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Philipp L. schrieb:

1

   DDRA &= ~(1<<PA0);                //PA0 als Eingang deklarieren (NTC3 

2

 = Wärmetauscher)

3

   DDRA &= ~(1<<PA1);                //PA1 als Eingang deklarieren (NTC4 

4

 = Kühlkörper)

Das ist nicht sinnvoll. Nicht nur, dass die Bits sowieso beim Reset alle 
0 sind, wenn schon, dann beschreibt man in der Initialisierungsphase 
doch sinnvollerweise alle Port-Register jeweils am Stück mit einem 
kompletten Byte, statt da lauter CBI- oder SBI-Befehle aneinander zu 
ketten.

> Wenn ich das vor sei() in der Funktion "Initialisierung" schreibe, läuft
> das Programm und die Ports sind verfügbar.

Dann hast du zumindest einen Würgaround. :)

> Wenn ich das aber 3 Zeilen höher ansiedele, läuft nix.
> Gefühlt läuft der uC nicht an und es sind alle Ports aus.
> Auch direkt am Anfang der Initialisierung() geht es nicht.

Vermutung: das Ding rennt aus irgendeinem Grund immer wieder in einen 
Reset (oder Interrupt, für den kein Vektor da ist).

Jörg W. schrieb:
> Das ist nicht sinnvoll. Nicht nur, dass die Bits sowieso beim Reset alle
> 0 sind, wenn schon, dann beschreibt man in der Initialisierungsphase
> doch sinnvollerweise alle Port-Register jeweils am Stück mit einem
> kompletten Byte, statt da lauter CBI- oder SBI-Befehle aneinander zu
> ketten.

Am Stück beschreiben ist sicher sinnvoller.
Habe ich nur gemacht damit ich jedem Pin eine Beschreibung zum nachsehen 
verpassen kann.
Aber ja, geht bestimmt besser.

Jörg W. schrieb:
> Vermutung: das Ding rennt aus irgendeinem Grund immer wieder in einen
> Reset (oder Interrupt, für den kein Vektor da ist).

Einen Overflow Interrupt gibt es nur für Timer0 und Timer3.
Für beide gibt es einen Vektor.
Oder muss da etwas drin stehen?
Denn für Timer0 ist der noch leer...

1

C-Code

2

ISR (TIMER0_OVF_vect)

3

{

4

5

}

Aber auch wenn ich da etwas reinschreibe läuft das Programm nicht mehr, 
wenn ich das deaktivieren an den Anfang der Initialisierung() 
schreibe...

BlaBla schrieb:
> Philipp L. schrieb:
>> ISR (TIMER0_OVF_vect)
>> {
>>
>> }
>
> Wird dieser Interrupt nicht wegoptimiert?

Ja, wird er nicht.

ISR ist ein Makro, der die damit beschriebenen Funktionen u.a. mit dem 
Attribut "used" versieht.

Also keine weitere Idee, warum es darauf ankommt an welcher Stelle ich 
das im Programm deaktiviere ?

Ich habe mal gehört, dass man für JTAG "anders" compilieren muss.
Muss ich dem Compiler das evtl. irgendwie sagen es nicht für JTAG 
compiliert werden soll?

Man lies immer "JTAG in den Fuses deaktivieren" und gut, das würde ich 
eigentlich auch gern so handhaben.
ich muss nur das eine "HIGHJTAGEN" entfernen, oder muss ich sonst noch 
etwas umstellen?

Philipp L. schrieb:
> Also keine weitere Idee, warum es darauf ankommt an welcher Stelle ich
> das im Programm deaktiviere ?

Nö, so richtig nicht.

Muss ja irgendwas mit der Initialisierung der beiden ADCs zu tun haben.

> Ich habe mal gehört, dass man für JTAG "anders" compilieren muss.

Wo hast du das denn gehört?

> Man lies immer "JTAG in den Fuses deaktivieren" und gut, das würde ich
> eigentlich auch gern so handhaben.

Wo liest "man" das?

Ich persönlich nehme, wenn ich das schon brauche, allemal lieber JTD, 
und dann lege ich auf die JTAG-Pins unwichtigen Krempel wie Status-LEDs. 
Wenn man dann durch die beiden Zeilen zum Setzen des JTD single-step 
durchgeht, wird die zeitliche Bedingung für das Deaktivieren des JTAG 
nicht eingehalten, und man kann weiter debuggen (die LEDs an den 
JTAG-Leitungen blinkern dann halt irgendwas zusammen).

Läuft der Code fullspeed da durch, wird JTAG abgeschaltet, und die vier 
Drähte werden von der Software gesteuert.

Ohne Fuse-Gefummel …

> ich muss nur das eine "HIGHJTAGEN" entfernen, oder muss ich sonst noch
> etwas umstellen?

Du musst natürlich insbesondere die Fuses auch wirklich programmieren. 
Von allein wandert das nicht aus dem Sourcecode in die entsprechende 
Kommandozeile des Programmers. (Die Fuses grundsätzlich jedes Mal über 
zu programmieren, würde ich nicht tun, da hätte ich Angst, dass sie 
vorzeitig verschleißen. Sind ja auch nur Flash-Zellen mit endlicher 
Lebensdauer.)

Aber: solange die Software abstürzt, hat das natürlich keinen Sinn, da 
an der Fuse überhaupt zu schrauben.

Kann es sein, dass deine Externinterrupts irgendwelchen Müll einkoppeln 
und die CPU dann nur noch mit dem Behandeln von deren ISRs beschäftigt 
ist?

Würde allerdings nicht erklären, warum dann alle Ports aus wären.

Jörg W. schrieb:
> Kann es sein, dass deine Externinterrupts irgendwelchen Müll
> einkoppeln
> und die CPU dann nur noch mit dem Behandeln von deren ISRs beschäftigt
> ist?
>
> Würde allerdings nicht erklären, warum dann alle Ports aus wären.

Das würde doch auch nicht erklären, warum das Programm super läuft.
Auch über Stunden...
Nur sobald ich JTAG (in den Fuses oder an einer "falschen" Stelle im 
Programm) deaktiviere läuft nix mehr.

Und die Externen Interrupts funktionieren doch sonst auch und liegen 
nicht auf den JTAG Ports.

Jörg W. schrieb:
> Du musst natürlich insbesondere die Fuses auch wirklich programmieren.

Ja, schon klar.
Auch beim auslesen wird mir das korrekt angezeigt.

Philipp L. schrieb:
> Das würde doch auch nicht erklären, warum das Programm super läuft.
> Auch über Stunden.

Richtig.

Ich bin nur immer etwas skeptisch mit Externinterrupts, die nicht 
dediziert von irgendwelchen aktiven Bauteilausgängen (mit genau 
bekannter Charakteristik der treibenden Signale) angesteuert werden. 
Wenn man sowas unbedingt braucht, würde ich in der ISR als erstes den 
entsprechenden Interrupt abklemmen, damit es keinen "Interruptsturm" 
gibt.

Einen Encoder oder Taster entprellt man ohnehin besser in einem 
Timerinterrupt.

Back to topic: da du das Problem ja schon auf die Initialisierung der 
beiden ADCs eingekreist hast, solltest du dir diese nochmal genau 
ansehen.

Jörg W. schrieb:
> Back to topic: da du das Problem ja schon auf die Initialisierung der
> beiden ADCs eingekreist hast, solltest du dir diese nochmal genau
> ansehen.


ja, das habe ich.
Da wird kein MCUCR gesetzt (siehe Anhänge).

Ich denke zwar nicht, dass das das aktuelle Problem ist, aber darüber 
solltest du nochmal nachdenken …

1

void USART_Transmit( unsigned char data )

2

{

3

  // Wait for empty transmit buffer

4

  while ( !( UCSR0A & (1<<UDRE0)) )

5

  // Put data into buffer, sends the data

6

  {

7

    UDR0 = data;

8

  };

9

}

(Gibt es einen wichtigen Grund, den Sourcecode als PDF statt als 
C-Quellen anzuhängen?)

Philipp L. schrieb:

> Das würde doch auch nicht erklären, warum das Programm super läuft.
> Auch über Stunden...
> Nur sobald ich JTAG (in den Fuses oder an einer "falschen" Stelle im
> Programm) deaktiviere läuft nix mehr.

Ohne jetzt den Code im Detail untersucht zu haben, würde ich den Fehler 
an der Ansteuerung Deiner beiden Halbbrücken vermuten, da alle 4 am Port 
C hängen. Durch den Pull-Down sind die Low-Side-FETs aktiv, solange der 
Port nicht initialisiert ist. Bist Du Dir sicher, dass bei der 
Initialiserung der zugehörigen High-Side-Ausgänge kein 
Brückenkurzschluss ("Heißer Zweig") entsteht?

Vermutung: Der Kurzzschluss könnte auch die Versorgung der MCU 
beeinflussen, so dass der Brownout zuschlägt. Mir fehlt die Geduld in 
Deinem Suchspiel, aka Schaltplan, nach der Versorgung der 
MOSFET-Halbbrücken zu suchen.

Grüßle
Volke

Volker B. schrieb:
> Philipp L. schrieb:
>
>> Das würde doch auch nicht erklären, warum das Programm super läuft.
>> Auch über Stunden...
>> Nur sobald ich JTAG (in den Fuses oder an einer "falschen" Stelle im
>> Programm) deaktiviere läuft nix mehr.
>
> Ohne jetzt den Code im Detail untersucht zu haben, würde ich den Fehler
> an der Ansteuerung Deiner beiden Halbbrücken vermuten, da alle 4 am Port
> C hängen. Durch den Pull-Down sind die Low-Side-FETs aktiv, solange der
> Port nicht initialisiert ist. Bist Du Dir sicher, dass bei der
> Initialiserung der zugehörigen High-Side-Ausgänge kein
> Brückenkurzschluss ("Heißer Zweig") entsteht?
>
> Vermutung: Der Kurzzschluss könnte auch die Versorgung der MCU
> beeinflussen, so dass der Brownout zuschlägt. Mir fehlt die Geduld in
> Deinem Suchspiel, aka Schaltplan, nach der Versorgung der
> MOSFET-Halbbrücken zu suchen.
>
> Grüßle
> Volke


Die Halbbrücken-Fets werden durch Treiber IRS2183S getrieben, welche 
einen Kurzschluss schon selbst verhindern.
Wenn alle Ports 0 sind, steuern beide Treiber Masse durch.

Wie gesagt funktioniert es schon nicht, wenn ich die JTAG Abschaltung 
hinter die Port Initialisierung und vor die ADC + UART Initialisierung 
stelle.

Philipp L. schrieb:

> Die Halbbrücken-Fets werden durch Treiber IRS2183S getrieben, welche
> einen Kurzschluss schon selbst verhindern.

das ist mir klar. Aber welche Spannung hängt an den High-Side-Drains? 
Vout/3 finde ich in Deinem "Suchspiel" nicht.

> Wie gesagt funktioniert es schon nicht, wenn ich die JTAG Abschaltung
> hinter die Port Initialisierung und vor die ADC + UART Initialisierung
> stelle.

Ich würde schnell&einfach die Beschaltung der Port-C-Pins abklemmen und 
schrittweise wieder zuschalten, bis es erneut hängt. Dann hast Du den 
Schuldigen und die Ordnung des Rätsels würde sich drastisch reduzieren.

Grüßle
Volker

Volker B. schrieb:
> das ist mir klar. Aber welche Spannung hängt an den High-Side-Drains?
> Vout/3 finde ich in Deinem "Suchspiel" nicht.

Das ist Vout auf Seite.3 auf welcher der Buck ist.
Also Vout vom Buck.

Volker B. schrieb:
> Ich würde schnell&einfach die Beschaltung der Port-C-Pins abklemmen

Du meinst hardwaremäßig ?
Schwierig auf der fertigen Platine :-)

Philipp L. schrieb:
> Du meinst hardwaremäßig ?
> Schwierig auf der fertigen Platine :-)

Den SO8, der an Pin 23/24 klemmt, kannst du mit Heißluft mal ablöten. 
Damit hättest du schon zwei der vier Leitungen verifiziert.

Ach wie blöd wir alle sind :-)
Bin zwar nicht mehr am PC, aber es ist bestimmt der ADC Reset Pin.

Aktuell setze ich diesen vor der adc_init noch nicht auf 1, wodurch der 
ads112 bei deaktivieren des JTAG ausschaltet.

Somit hängt das Programm, da der ads112 nicht mehr antwortet.

Das war es, läuft jetzt.

Philipp L. schrieb:
> Ach wie blöd wir alle sind :-)
(...)
> Aktuell setze ich diesen vor der adc_init noch nicht auf 1, wodurch der
> ads112 bei deaktivieren des JTAG ausschaltet.
>
> Somit hängt das Programm, da der ads112 nicht mehr antwortet.

Naja, blöde ist der, der in seinem I2C-Code nicht sämtliche 
while()-Schleifen auf ein Timeout prüft, sondern nur ein paar wenige... 
:-/

Mich würde jetzt nur interessieren, wie Du Dir in Deinem 
Eröffnungsposting vorgestellt hast, zielführende Informationen zu 
erhalten, ohne jeglichen Code oder Schaltplan zu zeigen?

Grüßle
Volker

Nun hack mal nicht zu viel auf ihm 'rum. Ich denke, er hat einiges dabei 
gelernt, auch sicher ein Stück, wie man eine Frage stellt.

Btw., @Phillip, schau dir auf jeden Fall deine serielle Ausgabe nochmal 
an.

Mädelz...
fühlt euch mit dem "blöde" doch nicht gleich so angegriffen...

Dafür stand doch der :-) dahinter.