PIC18 sporadisches Problem während Sleep Mode

[No N. (pascee)]

Hallo zusammen,

ich schlage mich nun schon seit mehreren Tagen mit einem Problem herum 
und bin nun an einem Punkt an dem ich keine weiteren Ideen habe.

Zum Hintergrund:
Verwendet wird: MPLabX und der xc8 compiler in Verbindung mit dem ICD4 
Debugger.
Ich nutze einen PIC18 Modell 46k42 und versetze den durch eine bestimmte 
Aktion in den Schlafmodus und hole ihn durch einen Pin-Interrupt wieder 
heraus.

Das funktioniert auch in 90% der Fälle immer zuverlässig.
Jedoch kommt es manchmal zu einem (für mich noch unerklärlichen) 
Zustand, an dem der Pegelwechsel am Pin eindeutig vorhanden ist, jedoch 
der µC in seinem Sleep nicht mehr drauf reagiert. Ich weiß nicht woran 
es liegt um ehrlich zu sein.

Wenn das Ereignis eintritt um den PIC in den Sleep Mode zu setzen führe 
ich folgende Funktion aus:

void EnterSleep(void){
    GREEN_LED = LOW;
    RED_LED   = LOW;               
    TMR0_StopTimer();
    ADS1120_SetToSleep(ADC_DMS);
    ADS1120_SetToSleep(ADC_RateOfTurnVbat);
    ENABLE_5V_SetLow();

    bufferWPU.WPUA = WPUA;
    bufferWPU.WPUB = WPUB;
    bufferWPU.WPUC = WPUC;
    bufferWPU.WPUD = WPUD;   
    WPUA = 0;
    WPUB = 0;
    WPUC = 0;
    WPUD = 0;
    
    //
    CPUDOZEbits.IDLEN = 0;
    PIE3bits.U1TXIE = 0;
    PIR1bits.INT0IF = 0;
    VREGCONbits.VREGPM = 0; //Refering to P.176 -> normal power mode enabled 
                            // in sleep; draws higher current in sleep, faster wake up
    SLEEP();
}

Und wenn der Interrupt zum WakeUp kommt folgende Funktion:

void WakeUp(void)
{
  WPUA = bufferWPU.WPUA;
  WPUB = bufferWPU.WPUB;
  WPUC = bufferWPU.WPUC;
  WPUD = bufferWPU.WPUD;
  
  LED1_SetHigh();
  LED2_SetHigh();
  
  ENABLE_5V_SetHigh();
  __delay_ms(1);
  ADS1120_Init();
  ads1120_InitConfigurationRegister(ADC_DMS);
  ads1120_InitConfigurationRegister(ADC_RateOfTurnVbat); 
  LED1_SetLow();
  LED2_SetLow();

  if(ERR_5V_GetValue() == LOW)
  {
      int attempts = 0;
      bool state   = 0;
      while(attempts++ < 5 || !state)
      {
          __delay_us(1000);
          state = ERR_5V_GetValue();      
      }
      if(attempts >= 5 && state == LOW)
          Reset();
    
  }
  
  return;
}

Er geht auch nicht in einen Reset oder etwas dergleichen, weil ich den 
Neustart anhand der LED's erkennen würde.
Ich cleare auch extra das INT0IF bit um sicherzustellen, dass ich den 
nächsten Interrupt erkenne.


Ich wäre für jeden Tipp dankbar!

Schönen Sonntag noch

[H. B. (Gast)]

Schaltplan

[hirth (Gast)]

while (!Sleep()){
  sheep++;
}

[MosFeratu (Gast)]

No N. schrieb:
> Ich wäre für jeden Tipp dankbar!

Erstmal, wie es auch die Netiquette empfiehlt, ein Programm mit den 
minimal nötigen Funktionen erstellen und ggf hier als Anhang 
reinstellen.

[Volker S. (vloki)]

No N. schrieb:
> Zum Hintergrund:
> Verwendet wird: MPLabX und der xc8 compiler in Verbindung mit dem ICD4
> Debugger.
> Ich nutze einen PIC18 Modell 46k42 und versetze den durch eine bestimmte
> Aktion in den Schlafmodus und hole ihn durch einen Pin-Interrupt wieder
> heraus.

Wird der ICD im Debug Mode verwendet? Dann gibt es evtl. kein Sleep.

[pascee (Gast)]

Guten Morgen,

Sorry, wird natürlich sofort nachgereicht.
main.c:

#include "mcc_generated_files/mcc.h"
#include "defines.h"
#include <string.h>
#include "functionsCenter.h"
#include "devicectrl.h"
#include "mcc_generated_files/tmr2.h"
#include  "ads1120.h"


void main(void)
{
    SYSTEM_Initialize();
    // Enable high priority global interrupts
    INTERRUPT_GlobalInterruptHighEnable();
    // Enable low priority global interrupts.
    INTERRUPT_GlobalInterruptLowEnable();
    
    LED1_SetLow();
    LED2_SetLow();  
   
#if defined(ADS1120_ON)
    ADS1120_Init();
    ADS1120_OffsetCalibration(ADC1);
    ADS1120_OffsetCalibration(ADC2);
    devicectrl_InitStructures();
    WWDT_SoftEnable(); 
    while (1)
    {
            WWDT_TimerClear();
        if(STARTUP_FINISHED)
                MY_StateMachine();        
        if(devctrl_SetToSleepMode)
          devicectrl_EnterPowerDownMode();    //Set PIC into power saving mode    
    }
}

void SYSTEM_Initialize(void)
{
    //INTERRUPT_Initialize
      INTCON0bits.IPEN = 1;

    // Assign peripheral interrupt priority vectors
    // UTXI - high priority
    IPR3bits.U1TXIP = 1;
    // URXI - high priority
    IPR3bits.U1RXIP = 1;
    // TMRI - high priority
    IPR3bits.TMR0IP = 1;
    // IOCI - low priority
    IPR0bits.IOCIP = 0;    
    // URXI - low priority
    IPR6bits.U2RXIP = 0;    
    // UTXI - low priority
    IPR6bits.U2TXIP = 0;   
    //
  
    //PMD_Initialize
      // CLKRMD CLKR enabled; SYSCMD SYSCLK enabled; SCANMD SCANNER enabled; FVRMD FVR enabled; IOCMD IOC enabled; CRCMD CRC enabled; HLVDMD HLVD enabled; NVMMD NVM enabled; 
    PMD0 = 0x00;
    // NCO1MD DDS(NCO1) enabled; TMR0MD TMR0 enabled; TMR1MD TMR1 enabled; TMR4MD TMR4 enabled; TMR5MD TMR5 enabled; TMR2MD TMR2 enabled; TMR3MD TMR3 enabled; TMR6MD TMR6 enabled; 
    PMD1 = 0x00;
    // ZCDMD ZCD enabled; DACMD DAC enabled; CMP1MD CMP1 enabled; ADCMD ADC enabled; CMP2MD CMP2 enabled; 
    PMD2 = 0x00;
    // CCP2MD CCP2 enabled; CCP1MD CCP1 enabled; CCP4MD CCP4 enabled; CCP3MD CCP3 enabled; PWM6MD PWM6 enabled; PWM5MD PWM5 enabled; PWM8MD PWM8 enabled; PWM7MD PWM7 enabled; 
    PMD3 = 0x00;
    // CWG3MD CWG3 enabled; CWG2MD CWG2 enabled; CWG1MD CWG1 enabled; 
    PMD4 = 0x00;
    // U2MD UART2 enabled; U1MD UART1 enabled; SPI1MD SPI1 enabled; I2C2MD I2C2 enabled; I2C1MD I2C1 enabled; 
    PMD5 = 0x00;
    // DSMMD DSM1 enabled; CLC3MD CLC3 enabled; CLC4MD CLC4 enabled; SMT1MD SMT1 enabled; CLC1MD CLC1 enabled; CLC2MD CLC2 enabled; 
    PMD6 = 0x00;
    // DMA1MD DMA1 enabled; DMA2MD DMA2 enabled; 
    PMD7 = 0x00;
  //
  
    //PIN_MANAGER_Initialize
/**
    LATx registers
    */
    LATE = 0x00;
    LATD = 0x30;
    LATA = 0xF8;
    LATB = 0x12;
    LATC = 0x08;

    /**
    TRISx registers
    */
    TRISE = 0x07;
    TRISA = 0x86;
    TRISB = 0xF5;
    TRISC = 0xB1;
    TRISD = 0x88;

    /**
    ANSELx registers
    */
    ANSELD = 0x08;
    ANSELC = 0x90;
    ANSELB = 0xE1;
    ANSELE = 0x07;
    ANSELA = 0x02;

    /**
    WPUx registers
    */
    WPUD = 0x00;
    WPUE = 0x00;
    WPUB = 0x10;
    WPUA = 0x80;
    WPUC = 0x08;

    /**
    RxyI2C registers
    */
    RB1I2C = 0x00;
    RB2I2C = 0x00;
    RC3I2C = 0x00;
    RC4I2C = 0x00;
    RD0I2C = 0x00;
    RD1I2C = 0x00;
    /**
    ODx registers
    */
    ODCONE = 0x00;
    ODCONA = 0x00;
    ODCONB = 0x00;
    ODCONC = 0x00;
    ODCOND = 0x00;
    /**
    SLRCONx registers
    */
    SLRCONA = 0xFF;
    SLRCONB = 0xFF;
    SLRCONC = 0xFF;
    SLRCOND = 0xFF;
    SLRCONE = 0x07;
    /**
    INLVLx registers
    */
    INLVLA = 0xFF;
    INLVLB = 0xFF;
    INLVLC = 0xFF;
    INLVLD = 0xFF;
    INLVLE = 0x0F;
    /**
    IOCx registers 
    */
    //interrupt on change for group IOCAF - flag
    IOCAFbits.IOCAF2 = 0;
    //interrupt on change for group IOCAF - flag
    IOCAFbits.IOCAF7 = 0;
    //interrupt on change for group IOCAN - negative
    IOCANbits.IOCAN2 = 1;
    //interrupt on change for group IOCAN - negative
    IOCANbits.IOCAN7 = 1;
    //interrupt on change for group IOCAP - positive
    IOCAPbits.IOCAP2 = 1;
    //interrupt on change for group IOCAP - positive
    IOCAPbits.IOCAP7 = 0;
    //interrupt on change for group IOCBF - flag
    IOCBFbits.IOCBF4 = 0;
    //interrupt on change for group IOCBN - negative
    IOCBNbits.IOCBN4 = 1;
    //interrupt on change for group IOCBP - positive
    IOCBPbits.IOCBP4 = 0;
    // register default IOC callback functions at runtime; use these methods to register a custom function
    IOCAF2_SetInterruptHandler(IOCAF2_DefaultInterruptHandler);
    IOCAF7_SetInterruptHandler(IOCAF7_DefaultInterruptHandler);
    IOCBF4_SetInterruptHandler(IOCBF4_DefaultInterruptHandler);      
   // Enable IOCI interrupt 
    PIE0bits.IOCIE = 1;   
    U2RXPPS = 0x1F;   //RD7->UART2:RX2;    
    SPI1SCKPPS = 0x09;   //RB1->SPI1:SCK1;    
    RB1PPS = 0x1E;   //RB1->SPI1:SCK1;    
    RC1PPS = 0x13;   //RC1->UART1:TX1;    
    RB3PPS = 0x1F;   //RB3->SPI1:SDO1;    
    RC6PPS = 0x15;   //RC6->UART1:RTS1;    
    U1RXPPS = 0x10;   //RC0->UART1:RX1;    
    RD6PPS = 0x16;   //RD6->UART2:TX2;    
    SPI1SDIPPS = 0x0A;   //RB2->SPI1:SDI1;    
    U1CTSPPS = 0x15;   //RC5->UART1:CTS1;      
  //

    //WWDT_Initialize();
  WDTCON0 = 18;
    WDTCON1 = 7|48;
  //  
    OSCILLATOR_Initialize();
    TMR2_Initialize();  
    TMR0_Initialize();  
    SPI1_Initialize();
}

Und hier die Interrupt routine aus dem pin_manager.c

void IOCAF2_DefaultInterruptHandler(void){
        if(STARTUP_FINISHED)
    {
        if(Conn_GetValue() == LOW)
        {        
            devctrl_SetToSleepMode = true;         
        }
        else if(Conn_GetValue() == HIGH)
        {          
                WakeUp(); //siehe erster Beitrag
                devctrl_SetToSleepMode = false;
          
            }
              ADS1120_StartConversion(ADC1);
              ADS1120_StartConversion(ADC2);
        }                   
    }
    IOCBFbits.IOCBF4 = 0;
}

viele Grüße und einen guten Start in die neue Woche !

[Teo D. (teoderix)]

Nix für ungut aber..... ;)

[pascee (Gast)]

Ahhhh :-D F**k sorry !!!!

Der µC wird im Release Modus betrieben, also ohne Debugger.
Der ICD4 kann auch mit dem Sleep Modus umgehen.


viele Grüße

pascee

[Peter D. (peda)]

Bei den AVRs gibt es eine Fallgrube, kann gut sein, daß es beim PIC 
ähnlich ist:
Der Interrupt zum Aufwachen kann ja direkt vor dem Sleep erfolgen und 
sich selber disablen, dann schläft der AVR für immer.
Man muß also beim AVR erstmal die Interrupts disablen, dann den 
Aufwacher enablen und dann Interrupt enable + Sleep direkt 
hintereinander schreiben. Der AVR führt den nächsten Befehl nach 
Interrupt enable immer aus, d.h. so kann vor dem Sleep kein Interrupt 
dazwischen grätschen.

[pascee (Gast)]

vielen Dank für den Tipp!
Um dir richtig folgen zu können:


Peter D. schrieb:
> Bei den AVRs gibt es eine Fallgrube, kann gut sein, daß es beim
> PIC
> ähnlich ist:
> Der Interrupt zum Aufwachen kann ja direkt vor dem Sleep erfolgen und
> sich selber disablen, dann schläft der AVR für immer.

Du meinst, dass wenn der Fall des Interrupts kurz vor dem Aufruf der 
Sleepfunktion eintritt, ich in diesem case lande weil ich das interrupt 
flag dadurch nicht zurücksetze richtig?

> Man muß also beim AVR erstmal die Interrupts disablen, dann den
> Aufwacher enablen und dann Interrupt enable + Sleep direkt
> hintereinander schreiben. Der AVR führt den nächsten Befehl nach
> Interrupt enable immer aus, d.h. so kann vor dem Sleep kein Interrupt
> dazwischen grätschen.

Ab hier kann ich dir nicht mehr ganz folgen :-)
Ab wann müsste ich die Interrupts disablen?

[herba (Gast)]

Schon mal versuchsweise den Soft-Watchdog deaktiviert? So wie ich das in 
Erinnerung habe, weckt dieser den Pic auf.
Gruss herba

[pascee (Gast)]

Hi,

Das mit der Instruktion nach dem SLEEP() Aufruf stimmt übrigens und gilt 
auch für die PIC-Family.

Den Watchdog Timer deaktiviere ich immer wenn ich in den Sleep Mode 
gehe.

Habe jetzt noch eine Art Standby timer eingebaut, welcher während dem 
Sleep mode durchläuft und alle 10 sek einen Tick auslöst. Bei jedem Tick 
setze ich den HWPin-Interrupt zurück und nach 10 Minuten gibt es 
Sicherheitshalber ein HW-Reset sofern 10 Minuten im Sleep mode vergehen. 
Im laufenden Modus bleiben diese Funktionen natürlich deaktiviert.

Ich habe das System nun über Nacht einem Dauerstresstest unterzogen und 
der Fehler ist kein einziges mal aufgetreten. Sprich: in 10 Stunden ca. 
8000 Versuche. Das sollte doch ein Indiz dafür sein, dass der Fehler 
jetzt behoben sein sollte oder? :-)


viele Grüße und ein schönes Wochenende,

[Peter D. (peda)]

pascee schrieb:
> Habe jetzt noch eine Art Standby timer eingebaut, welcher während dem
> Sleep mode durchläuft und alle 10 sek einen Tick auslöst.

Sowas nennt man einen Würg-Around. Du hast also die Ursache nicht 
gefunden und verschleierst den Fehler nur mit einem Timeout. Ein 
laufender Timer bedeutet in der Regel ein höherer Stromverbrauch im 
Sleep. Auch kann ein 10s Schluckauf dem Benutzer durchaus auffallen.

Deine unklare Fehlerbeschreibung und die Schnipseltaktik nützt aber 
keinem, da durchzusehen. Du müßtest schon ein komplettes compilierbares 
Programm als Zip anhängen. Und vor allen erstmal den ganzen sonstigen 
Schrunz raushauen, der mit dem Sleep-Problem nichts zu tun hat. Fehler 
findet man besser, wenn man das Programm so weit wie möglich 
vereinfacht.

[pascee (Gast)]

Peter D. schrieb:
> pascee schrieb:
>> Habe jetzt noch eine Art Standby timer eingebaut, welcher während dem
>> Sleep mode durchläuft und alle 10 sek einen Tick auslöst.
>
> Sowas nennt man einen Würg-Around. Du hast also die Ursache nicht
> gefunden und verschleierst den Fehler nur mit einem Timeout. Ein
> laufender Timer bedeutet in der Regel ein höherer Stromverbrauch im
> Sleep. Auch kann ein 10s Schluckauf dem Benutzer durchaus auffallen.

Sorry ! Habe mich falsch ausgedrückt. Das Zurücksetzen des Pin Interrupt 
Flags gleich nach der Sleep Instruction hat geholfen. Das hat auch der 
Stresstest bewiesen :-)
Der Fehler ist bis heute nicht mehr aufgetaucht.

Den Timer habe ich Sicherheitshalber implementiert, da dass Gerät an 
eine unerreichbare Stelle kommt und ich keine Möglichkeit habe, es so 
einfach neuzustarten.

viele Grüße