Programm läuft nur mit JTAG Fuse

[Philipp L. (viech)]

Hallo,

ich habe ein Programm auf dem, welches auch wunderbar funktionert.

Nun brauche ich die Pins der JTAG Schnittstelle.
Sobald ich die Fuse "HIGHJTAGEN" aber abschalte, funktioniert das 
Programm nicht mehr.
Sobald ich JTAG wieder einschalte geht alles wieder (nur die PortC halt 
nicht).

Woran kann das liegen?

Atmega1284P  Atmelstudio7  C

[Volker B. (Firma: L-E-A) (vobs)]

Philipp L. schrieb:

> Woran kann das liegen?

Singularität im Raum-Zeit-Kontinuum?

Grüßle
Volker

[Jörg W. (dl8dtl) (Moderator)]

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.

[Philipp L. (viech)]

Gebe euch gern alle Infos, bin echt ratlos..

[Peter D. (peda)]

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).

[Jörg W. (dl8dtl) (Moderator)]

Was passiert nun, wenn du JTD zur Laufzeit setzt?

[Philipp L. (viech)]

/*
 * Aquacooler-V0.4-V0.1.c
 *
 * Created: 21.06.2020 13:51:20
 * Author : Viech
 */ 

//Defines
//------------------------------------------------------------------------------------------------------------------------------------------------ Defines
#define ENC_B      (1<<PD4)
#define ENC_B_1      (PIND & ENC_B)




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

#include <avr/pgmspace.h>
#include <avr/io.h>
#include <stdlib.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <util/sbit.h>
#include "UART.h"
#include "lcd.h"
#include "global.h"
#include "menu.h"
#include "ADCauslesen.h"
#include "internerADC.h"
#include "ADCwandeln.h"


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

uint8_t pos = 0;
uint8_t Taster = 0;
char Wert[10];

uint16_t Test = 0;
uint8_t menuaktiv = 0;

//Init
//------------------------------------------------------------------------------------------------------------------------------------------------ Init
void initialisierung (void)
{
  
  DDRA &= ~(1<<PA0);                //PA0 als Eingang deklarieren (NTC3  = Wärmetauscher)
  DDRA &= ~(1<<PA1);                //PA1 als Eingang deklarieren (NTC4  = Kühlkörper)
  DDRA &= ~(1<<PA2);                //PA2 als Eingang deklarieren (NTC5  = Lufttemperatur Eintritt)
  DDRA &= ~(1<<PA3);                //PA3 als Eingang deklarieren (NTC6  = Lufttemperatur Austritt)
  DDRA &= ~(1<<PA4);                //PA4 als Eingang deklarieren (Temp7 = Platinentemperatur)
  DDRA &= ~(1<<PA5);                //PA5 als Eingang deklarieren (Reserve)
  DDRA &= ~(1<<PA6);                //PA6 als Eingang deklarieren (VMESS = Ausgangsspannung)
  DDRA &= ~(1<<PA7);                //PA7 als Eingang deklarieren (SOLL von SPS =  )
  
  DDRB &= ~(1<<PB0);                //PB0 als Eingang deklarieren (FAN1_RPM  = Drehzahl Hauptlüfter)
  DDRB &= ~(1<<PB1);                //PB1 als Eingang deklarieren (FAN2_RPM  = Drehzahl Platinenlüfter)
  DDRB &= ~(1<<PB2);                //PB2 als Eingang deklarieren (ON        = Einschaltbefehl von extern)
  DDRB |= (1<<PB3);                //PB3 als Ausgang deklarieren (Pumpe     = Pumpe einschalten)
  DDRB &= ~(1<<PB4);                //PB4 als Eingang deklarieren (Reserve)
  DDRB &= ~(1<<PB5);                //PB5 als Eingang deklarieren (MOSI = nicht für andere Funktion verwendet)
  DDRB &= ~(1<<PB6);                //PB6 als Eingang deklarieren (MISO = nicht für andere Funktion verwendet)
  DDRB &= ~(1<<PB7);                //PB7 als Eingang deklarieren (SCK  = nicht für andere Funktion verwendet)  
  
  DDRC &= ~(1<<PC0);                //PC0 als Eingang deklarieren (SCL        = Bus zu Displayplatine intern)
  DDRC &= ~(1<<PC1);                //PC1 als Eingang deklarieren (SDA        = Bus zu Displayplatine intern)
  DDRC |= (1<<PC2);                //PC2 als Ausgang deklarieren (ADC_RST    = ADC Reset)
  DDRC |= (1<<PC3);                //PC3 als Ausgang deklarieren (EN         = Buck einschalten)
  DDRC |= (1<<PC4);                //PC4 als Ausgang deklarieren (HLF_BRD_L2 = Brücke low side Seite 2)
  DDRC |= (1<<PC5);                //PC5 als Ausgang deklarieren (HLF_BRD_H2 = Brücke high Side Seite 2)
  DDRC |= (1<<PC6);                //PC6 als Ausgang deklarieren (HLF_BRD_L1 = Brücke low side Seite 1)
  DDRC |= (1<<PC7);                //PC7 als Ausgang deklarieren (HLF_BRD_H1 = Brücke high Side Seite 1)  
  
  DDRD &= ~(1<<PD0);                //PD0 als Eingang deklarieren (RXD      = Bus zu Lichtcontroller)
  DDRD &= ~(1<<PD1);                //PD1 als Eingang deklarieren (TXD      = Bus zu Lichtcontroller)
  DDRD &= ~(1<<PD2);                //PD2 als Eingang deklarieren (S0       = Taster von Inkrementalgeber / INT0)
  DDRD &= ~(1<<PD3);                //PD3 als Eingang deklarieren (IN_A     = Inkrementalgeber / INT1)
  DDRD &= ~(1<<PD4);                //PD4 als Eingang deklarieren (IN_B     = Inkrementalgeber)
  DDRD |= (1<<PD5);                //PD5 als Ausgang deklarieren (OC1A     = Ausgangsspannung von Buck)
  DDRD |= (1<<PD6);                //PD6 als Ausgang deklarieren (FAN2_PWM = Drehzahlregelung Hauptlüfter)
  DDRD |= (1<<PD7);                //PD7 als Ausgang deklarieren (FAN1_PWM = Drehzahlregelung Platinenlüfter)  
  
  EICRA |= (1<<ISC01);              //INT0 (Taster Inkrementalgeber)  wird bei fallender Flanke ausgelöst
  EICRA |= (1<<ISC11);              //INT1 (Drehung Inkrementalgeber) wird bei fallender Flanke ausgelöst
  EIMSK |= (1<<INT0);                //Ext. Int0 aktivieren
  EIMSK |= (1<<INT1);                  //Ext. Int1 aktivieren

  TCCR0A = (1<<WGM00)+(1<<WGM01);          // WGM0,WGM1,WGM2 = 1 -> Fast PWM mit OCR0A=TOP
  TCCR0B = (1<<WGM02)+(1<<CS02)+(1<<CS00);    // CS00,CS02 = 1 -> prescaler = 1024 
  OCR0A = 78;                    // bei 8Mhz und prescaler von 1024 gibt es nach 0,009984s einen interrupt          
  TIMSK0 = (1<<TOIE0);              // Timer Overflow interrupt enable

  ICR1 = 1000;                  //TOP-Wert für Zähler = 1000
  OCR1A = 800;                  //Vergleichsregister = 1
  TCCR1A = (1<<COM1A1)+(1<<WGM11);        //WGM11+12+13 = Fast PWM mit ICR1 als TOP
  TCCR1B = (1<<WGM12)+(1<<WGM13)+(1<<CS10);    //CS10 = no prescaler

  OCR2A = 250;                      //Vergleichsregister = 125 -> 50%
  OCR2B = 50;                      //Vergleichsregister = 125 -> 50%
  TCCR2A = (1<<COM2A1)+(1<<COM2B1)+(1<<WGM20)+(1<<WGM21);  //WGM20+21 = Fast PWM mit 0xFF als TOP
  TCCR2B = (1<<CS20);                    //CS21 = no prescaler
  
  ICR3 = 7812;                      //TOP-Wert für Zähler = 7812
  TCCR3A = (1<<WGM31);                  //WGM11+12+13 = Fast PWM mit ICR1 als TOP
  TCCR3B = (1<<WGM33)+(1<<WGM32)+(1<<CS32)+(1<<CS30);    //CS30+CS32 = prescaler 1024
  TIMSK3 = (1<<TOIE3);                  //Timer3 overflow interrupt enable
  
//  MCUCR|=(1<<JTD);                // An dieser Stelle läuft der uC nicht an
//  MCUCR|=(1<<JTD);                // An dieser Stelle läuft der uC nicht an

  adcinit();                    //Externen ADC Initialisieren
  ADC_Init();                    //Internen ADC initialisieren
  
  USART_Init(uartbaud);              //UART mit 9600 baud initialisieren
  
  MCUCR|=(1<<JTD);
  MCUCR|=(1<<JTD);
    
  sei();                      //Interrupts generell aktivieren
}



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

ISR (INT0_vect)                    //Bei interrupt int0 (Taster Inkrementalgeber)
{
  Taster = 1;
}


ISR (INT1_vect)                    //Bei interrupt int1 (Drehung Inkrementalgeber)
{
  if(ENC_B_1)                    //Encoder B == 1
  pos--;
  else
  pos++;
}


ISR (TIMER3_OVF_vect)
{
  PID_I++;
  menuaktiv = 1;
}



ISR (TIMER0_OVF_vect)
{
  
}


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

int main(void)
{
    /* Replace with your application code */
    
  initialisierung();
  LCD_I2C_ADR = 0x3C;                // Display 1
  lcd_init(LCD_DISP_ON);              // init lcd and turn on
  LCD_I2C_ADR = 0x3D;                // Display 2
  lcd_init(LCD_DISP_ON);              // init lcd and turn on


  Menu1();

  PORTC |= (1<<PC2);                  //ADC ein
  PORTC |= (1<<PC3);                  //Buck = ein
  PORTB |= (1<<PB3);                  //Pumpe = ein

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

  PORTC &= ~(1<<PC6);                //H-Brücke L2=ein
  PORTC &= ~(1<<PC7);                //H-Brücke H2=ein
       
  
  while (1) 
    {
  
  if (menuaktiv == 1)
  {
  Menu1();
  menuaktiv = 0;
  }
    
  adcdata = Auslesen();
  RNTC = ADC_to_NTC_bridge(adcdata);
  Tempin = NTC_to_Temp(RNTC);
  
  adcdata = ADC_Read(0);
  RNTC = ADC_to_NTC_div(adcdata,5.03,1024,9980);
  Luftout = NTC_to_Temp(RNTC);
  
  adcdata = ADC_Read(1);
  RNTC = ADC_to_NTC_div(adcdata,5.03,1024,9980);
  Luftin = NTC_to_Temp(RNTC);
    
  adcdata = ADC_Read(2);
  RNTC = ADC_to_NTC_div(adcdata,5.03,1024,9980);
  Tauscher = NTC_to_Temp(RNTC);
    
  adcdata = ADC_Read(3);
  RNTC = ADC_to_NTC_div(adcdata,5.03,1024,9980);
  Kuehler = NTC_to_Temp(RNTC);
  
  adcdata = ADC_Read(4);
  Buck = MCP9700_to_Temp(adcdata,5.0,1024);

  
   }
  
}

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.

[Peter D. (peda)]

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

[Jörg W. (dl8dtl) (Moderator)]

Philipp L. schrieb:

   DDRA &= ~(1<<PA0);                //PA0 als Eingang deklarieren (NTC3 
 = Wärmetauscher)
   DDRA &= ~(1<<PA1);                //PA1 als Eingang deklarieren (NTC4 
 = 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).

[BlaBla (Gast)]

Philipp L. schrieb:
> ISR (TIMER0_OVF_vect)
> {
>
> }

Wird dieser Interrupt nicht wegoptimiert?

[Philipp L. (viech)]

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...

C-Code
ISR (TIMER0_OVF_vect)
{
  
}

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

[Jörg W. (dl8dtl) (Moderator)]

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.

[Philipp L. (viech)]

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?

[Jörg W. (dl8dtl) (Moderator)]

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.

[au weia (Gast)]

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

Auf jeden Fall hast du nur einen müden Abblock-Kondensator
an deinem 1284P, es gehört aber an jeden einzelnen Vcc Pin
(es gibt drei davon) und an den AVcc Pin jeweils ein dezidierter
Abblock-Kondensator zum nächsten Masse-Pin des Controllers.

Wenn du jetzt meinst das was ich sage ist ohne Belang, dann
gut, dann schmiede weiterhin dein eigenes Glück.

[Jörg W. (dl8dtl) (Moderator)]

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.

[Philipp L. (viech)]

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.

[Jörg W. (dl8dtl) (Moderator)]

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.

[Philipp L. (viech)]

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).

[leo (Gast)]

Philipp L. schrieb:
> Taster = 1;

Das ist nicht volatile, anderes wohl auch nicht. Sonst mal 
zusammenstreichen, formatieren, bis es lesbar ist und nur der Fehler 
uebrig bleibt.

leo

[Jörg W. (dl8dtl) (Moderator)]

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

void USART_Transmit( unsigned char data )
{
  // Wait for empty transmit buffer
  while ( !( UCSR0A & (1<<UDRE0)) )
  // Put data into buffer, sends the data
  {
    UDR0 = data;
  };
}

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

[Volker B. (Firma: L-E-A) (vobs)]

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

[Philipp L. (viech)]

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.

[c-hater (Gast)]

Jörg W. schrieb:
> Ich denke zwar nicht, dass das das aktuelle Problem ist, aber *darüber*
> solltest du nochmal nachdenken …

;o)

Definitiv. Das ist völliger Schwachsinn.

[Volker B. (Firma: L-E-A) (vobs)]

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

[Philipp L. (viech)]

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 :-)

[Jörg W. (dl8dtl) (Moderator)]

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.

[Philipp L. (viech)]

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.

[c-hater (Gast)]

Philipp L. schrieb:

> Ach wie blöd wir alle sind :-)

Das sehe ich dann doch eine wenig anders...

[Philipp L. (viech)]

Das war es, läuft jetzt.

[Volker B. (Firma: L-E-A) (vobs)]

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

[Jörg W. (dl8dtl) (Moderator)]

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.

[Philipp L. (viech)]

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

Dafür stand doch der :-) dahinter.