PIC24F aus dem SLEEP aufwecken

[andi (Gast)]

Hallo Leute,

ich versuche seit Tagen den PIC24FJ16GA004 per SLEEP-Befehl schlafen zu 
legen und dann per UART-Interrupt wieder aufzuwecken. Ohne SLEEP 
funktioniert alles wunderber, wenn ich den SLEEP-Befehl einfüge, dann 
geht der PIC schlafen und läßt sich nicht mehr aufwecken, obwohl er 
Daten von außen bekommt. Weiß da jemand einen Trick? Mit Errata kam ich 
nicht weiter. Das Einzige, was funktioniert, wenn der Watchdog aktiviert 
ist und im Sleep-Modus überläuft, dann wacht der PIC auf.

Gruß
Andy

[Zwirbeljupp (Gast)]

Du solltest Dir unbedingt mal das Kapitel 21.11 im Family Reference 
Manual anschauen - da offensichtlich noch nicht getan.

Ich zitieren: "The UART does not function in Sleep mode."

Ist ja auch logisch, da im Sleep üblicherweise die Taktquelle 
abgeschaltet ist, die für die Funktion der UART nun einmal nötig ist.

Allerdings gibt es ein Auto-Wake-up Feature. Möglicherweise ist das eine 
Option für Dich.

[andi (Gast)]

diesen Umstand kenne ich. Beim UART ist der Receive/Transmit-Interrupt 
aktiviert, der den PIC aufwecken sollte. Ohne den Sleep-Modus 
funktionieren alle Interrupts so wie sie sollten. Ich habe auch den 
Idle-Modus ausprobiert, mit gleichem Ergebnis. Aus irgendeinem Grund 
kann der UART-Receive-Interrupt den PIC nicht aufwecken.

[Zwirbeljupp (Gast)]

Ich frage mich gerade, warum ich hier meine Zeit investiere, um Dir zu 
helfen. Es ist mal wieder typisch: es werden zwei Zeilen hingetipt und 
dann darf man hier erst einmal herumorakeln und dem TE mühsam die 
Details aus der Nase ziehen, die er einfach eingangs hätte hinschreiben 
können. Ein paar Zeilen Code zu kopieren und hier einzufügen ist doch 
auch keine unlösbare Aufgabe?

Es gibt haufenweise mögliche Gründe, warum das so mit dem Wakeup nicht 
funktioniert. Z.B. an falsch gesetzten CPU- oder Interrupt-Prioritäten. 
Einfach zu testen, indem Du den PIC durch andere Interrupts mit 
identisch eingestellten Prioritäten versuchst aufzuwecken. DAS würde ich 
als erstes Testen.

Um den PIC per USART aufzuwecken, muss das Prozedere von Section 21.11.1 
eingehalten werden. Setzt Du das WAKE-Bit vorm Schlafengehen? Schickst 
Du tatsächlich ein Sync Break als Wakeup-Signal? Wenn nein: tja dann 
klappt das halt auch nicht.

[andi (Gast)]

tut mir leid, hast ja recht

void UART1_Init(void)
{
  IPC2bits.U1RXIP = 4;
  IPC3bits.U1TXIP = 4;
  
  // UART konfigurieren:
  // Baudrate (aufgerundet) einstellen
  U1BRG = (unsigned int)((((unsigned long)FCY + ((4*(unsigned long)BAUDRATE)/2)) / (4*(unsigned long)BAUDRATE)) - 1);
  // Modus: enable, stop in idle mode, use only U2TX and U2RX, 8-N, 1 stop bit
  // U1MODE = (1 << 15) | (1 << 13) | (0 << 8) | (0 << 1) | (0 << 0);
  U1MODE = (1 << 15);
  
  U1MODEbits.BRGH  = 1;
  
  // Status: irq when tx done, transmit enable, irq when rx done
  U1STA = (1 << 10);

  // TX-Interrupt-Flag löschen (wird durch Initialisierung ausgelöst)
  IFS0bits.U1TXIF = 0;

  // Interrupts aktivieren
  IEC0bits.U1TXIE = 1;  // TX
  IEC0bits.U1RXIE = 1;  // RX
}


void hardwareInit(void)
{
  //Oszillator initialisieren 
  
  OSCCON  = 0x0000;
  
  OSCCONbits.COSC0 = 1;  //Interner FRC mit Postscaler (FRCDIV) ist eingestellt.
  OSCCONbits.COSC1 = 1;
  OSCCONbits.COSC2 = 1;  
  
  OSCCONbits.SOSCEN = 0;  //Secondary Oscillator deaktiviert.
  
  CLKDIV   = 0x0000;     
  
  CLKDIVbits.RCDIV0 = 0;  
  CLKDIVbits.RCDIV1 = 1;
  CLKDIVbits.RCDIV2 = 0;

  //PPS initialisieren

    
  //*************************************************************
  // Unlock Registers
  //*************************************************************
  __builtin_write_OSCCONL(OSCCON & 0xbf); //clear the bit 6 of OSCCONL to
  //unlock Pin Re-map
  //******************************************************************

  //************************************************************
  // Configure Input Functions
  //************************************************************
  //
  // Zuweisen U1Rx zu Pin RP15
  RPINR18bits.U1RXR = 15;

  // #ifdef DEBUG
    // Zuweisen U2Rx zu Pin RP11
    RPINR19bits.U2RXR = 11;
  // #endif
  
  //************************************************************
  // Configure Output Functions
  //************************************************************
  //
  // Zuweisen U1Tx zu Pin RP13
  //***************************
  RPOR6bits.RP13R = 3; 

  // #ifdef DEBUG
    // Zuweisen U2TX zu Pin RP10
    RPOR5bits.RP10R = 5; 
  // #endif

  // Zuweisen OC1 zu Pin RP21
  RPOR10bits.RP21R = 18;
  
  //************************************************************
  // Lock Registers
  //************************************************************
  __builtin_write_OSCCONL(OSCCON | 0x40); //set the bit 6 of OSCCONL to
  //lock Pin Re-map
  //******************************************************************

  
  //PORTs initialisieren
  
  TRISA  = (1<<0)    //RA0,RA1,RA7 sind Eingänge, RA8-RA10 sind Ausgänge
      | (1<<1)
      | (1<<7)
      ;
  TRISB  = (1<<0)    //RB0,RB1,RB2,RB3,RB11,RB12,RB15 sind Eingänge
      | (1<<1)    
      | (1<<2)
      | (1<<3)
      | (1<<11)   
      | (1<<12)
      | (1<<15)    
      ;
  
  TRISC  = (1<<0)    //RC0,RC1,RC2 sind Eingänge
      | (1<<1)
      | (1<<2)
      ;  
      
  AD1PCFG  = 0xFFFF;    //Alle Portpins erstmal digitale I/Os
  
  LATA  = 0x0000;
  LATB  = 0x0000;
  LATC  = 0x0000;
}



// JTAG | Code Protect | Write Protect | Background Debugger | Clip-on Emulation mode
// ICD pins select | Watchdog Timer | Windowed WDT | Watchdog prescaler | Watchdog postscale)
_CONFIG1(JTAGEN_OFF & GCP_OFF & GWRP_OFF & BKBUG_OFF & COE_OFF & ICS_PGx2 & FWDTEN_OFF & WINDIS_OFF & FWPSA_PR32 & WDTPS_PS4096) 
// Two Speed Start-up | Secondary Oscillator | Voltage Regulator Standby-mode Wake-up Timer
// Oscillator Selection | Clock switching and clock monitor | OSCO/RC15 function
// RP Register Protection | I2C1 pins Select | Oscillator Selection)
_CONFIG2(IESO_ON & SOSCSEL_SOSC & WUTSEL_LEG & FNOSC_FRCDIV & FCKSM_CSDCMD & OSCIOFNC_ON & IOL1WAY_OFF & I2C1SEL_PRI & POSCMOD_NONE)



int main(void)
{
   EnableWDT(WDT_ENABLE);  //Watchdog-Timer per Software (SWDTEN) aktivieren. 
   hardwareInit();
   ...
  
  while(1)
  {
    ClrWdt();
    
    ...  

    //EnableWDT(WDT_DISABLE);
  U1MODE |= (1 << 7);    //Set WAKE-Bit für UART1
    Sleep();
    
  }
    
}

[andi (Gast)]

Ich benutze den 2en UART, um Debug/Statusmeldungen auszugeben. Wenn ich 
disen UART initialisiere und eine kleine Zeichenkette ausgeben lasse, 
dann funktioniert das Aufwecken aus dem Sleep. Dieser Uart ist ohne 
Interrupts aufgesetzt.

[Zwirbeljupp (Gast)]

andi schrieb:
> Ich benutze den 2en UART, um Debug/Statusmeldungen auszugeben. Wenn ich
> disen UART initialisiere und eine kleine Zeichenkette ausgeben lasse,
> dann funktioniert das Aufwecken aus dem Sleep. Dieser Uart ist ohne
> Interrupts aufgesetzt.

Äh, da kann ich nicht ganz folgen. Wie kannst Du denn mit der zweiten 
UART eine Zeichenkette versenden, während der PIC schläft?

Und nochmal die wichtige Frage: klappt das Aufwecken durch einen anderen 
Interrupt, z.B. einen INT_EXT?

[andi (Gast)]

Die Zeichenkette verschicke ich kurz davor und wenn ich dann den PIC 
schlafen lege, dann wacht er auch wie erwartet auf, nur halt wenn ich 
diese Debug-Ausgabe abstelle, dann  geht das Aufwecken nicht mehr.

Einen anderen Interrupt habe ich noch nicht probiert, weil ich so auf 
das eigentliche UART-Interrupt fixiert war, werde ich aber machen.

andi