MSP430 F167 schläft ein

[Stefan S. (blacknighthawk)]

Hallo MSP430 Spezialisten.

Heute Abend hatte ich ein seltsames Phänomen.
Ich betreibe eine selbst gebaute und programmierte Steuerung für meinen 
wassergeführten Holzofen (Temperaturen messen, Pumpe schalten, Mischer 
auf und zu fahren), diese lief seit dem letzten Winter bis jetzt ohne 
Probleme.

Heute wurden plötzlich die Ausgänge nicht mehr geschaltet und ich konnte 
auch über USART nichts mehr auslesen, also auch nicht sehen welche 
Temperaturen gemessen werden.
Die Tastenabfrage (über ISR) ging noch.
Nach einem Reset lief wieder alles wie gewohnt.

Ich benutze (meines Wissens) keine Art von LPM.
Allerdings kam es mir vor als würde alles außer was in der while(1) 
steht noch gehen.

Hier ist mal mein Code, für Verbesserungsvorschläge bin ich immer 
dankbar.
Und nebenbei erwähnt, ich erhebe nicht den Anspruch als Profi angesehen 
zu werden, ich stehe erst am Anfang.

/*
 * Ofensteuerung V2.00c
 * Mehrstufige Temperaturumrechnung
 * RS232 über USAT 1
 * Baud rate auf 19200
 * Taktfrequenz runter auf 8MHz wegen Problemen
 * Brennerabschaltung bei Pufferteperatur > 60°C
 */

#include <msp430f167.h>
#include <intrinsics.h>
#include <stdlib.h>
#include <string.h>

#define Offset 2588                //Offset von -50°C zu 0°C beim PT1000 1,79V (*100)
#define Steigung 1692             //Steigung 1/3 mV/°C (*10000)
#define Uref 28600                  //ADC Referenzspannung 2860,0mV (*10)
#define MaxDigit 4095             //Maximale Digits bei 12-Bit adc
volatile int cycles = 12500;      //Anzahl der Perioden Timer_A, 1sek. bei 100KHz DCO

#define A1_on (P4OUT |= BIT0)     //Relais 1 ein, Mischer auf
#define A1_off (P4OUT &= ~BIT0)   //Relais 1 aus
#define A2_on (P4OUT |= BIT1)     //Relais 2 ein, Mischer zu
#define A2_off (P4OUT &= ~BIT1)   //Relais 2 aus
#define A3_on (P4OUT |= BIT2)     //Relais 3 ein, Pumpe Rücklaufanhebung ein
#define A3_off (P4OUT &= ~BIT2)   //Relais 3 aus, Pumpe Rücklaufanhebung aus
#define A4_on (P4OUT |= BIT3)
#define A4_off (P4OUT &= ~BIT3)
#define A5_on (P4OUT |= BIT4)
#define A5_off (P4OUT &= ~BIT4)
#define A6_on (P4OUT |= BIT5)
#define A6_off (P4OUT &= ~BIT5)
#define A7_on (P4OUT |= BIT6)     //Relais 7 ein, Heizkessel
#define A7_off (P4OUT &= ~BIT6)   //Relais 7 aus, Heizkessel
#define A8_on (P4OUT |= BIT7)
#define A8_off (P4OUT &= ~BIT7)


void Timer_A(void);  //Timer A liest ADC und bildet  8 Mittelwerte
void Init_ADC(void); //ADC initialisierung
void Read_ADC(void); //Temp. T1 - T8 lesen
void Format(long l, char *s);
long int Temperatur (long int Digit);
void scrPos(char* x, char* y);
int uart_putc(char c);
void uart_puts (char* s);
void init_XT(void); //Ext. Quarz 8MHz

char buffer_1[6], buffer_2[6], buffer_3[6], buffer_4[6], buffer_5[6], buffer_6[6], buffer_7[6], buffer_8[6];
volatile long int Digit_1, Digit_2, Digit_3, Digit_4, Digit_5, Digit_6, Digit_7, Digit_8;
volatile long int Summe_1, Summe_2, Summe_3, Summe_4, Summe_5, Summe_6, Summe_7, Summe_8;
volatile long int Mittelwert_1, Mittelwert_2, Mittelwert_3, Mittelwert_4, Mittelwert_5, Mittelwert_6, Mittelwert_7, Mittelwert_8;
volatile long int Mittelwert_11, Mittelwert_12, Mittelwert_13, Mittelwert_14, Mittelwert_15, Mittelwert_16, Mittelwert_17, Mittelwert_18;
volatile int Temperatur_1, Temperatur_2, Temperatur_3, Temperatur_4, Temperatur_5, Temperatur_6, Temperatur_7, Temperatur_8;
volatile int i_scr = 0;
unsigned short int i_init;
short int delta_1;  //Differenz zur Mischersteuerung
short int delta_2;  //Differenz zur Pumpensteuerung



void main(void)
{
//Ext. Quarz 8MHz und Stop WDT
//DCO auf 100KHz
  init_XT();

  //Definition des Ports A für Schalter S1 bis S8
  P1SEL = 0x00;  //Port A I/O Funktion
  P1DIR = 0x00;  //Port A Input
  P1OUT = 0x00;  //Port A
  P1IE = 0xFF;   //Port A Interrupt freigegeben
  P1IES = 0xFF;  //Port A Interrupt H -> L
  P1IFG = 0x00;  //Port A Iterrupt Flag löschen

  //Definition des Ports B für 8 Bit Display
  P2SEL = 0x00;  //Port B I/O Funktion
  P2DIR = 0xFF;  //Port B Output
  P2OUT = 0x00;  //Port B Low
  P2IE = 0x00;   //Port B Interrupt nicht freigegeben
  P2IES = 0xFF;  //Port B Interrupt H -> L
  P2IFG = 0x00;  //Port B Iterrupt Flag löschen


  //Definition des Ports C für P3.0 und P3.2 (Stecker SV)
  P3SEL &= ~(BIT0 | BIT2);  //Port C P3.0 und P3.2 I/O Funktion
  P3DIR |= BIT0 + BIT2;  //Port C P3.0 und P3.2 Output
  P3OUT &= ~(BIT0 | BIT2);  //Port C P3.0 und P3.2 Low

  //Definition des Ports C für P3.1 und P3.3 für I2C
  //P3SEL |= BIT1 + BIT3;  //Port C P3.0 und P3.2 Aux Funktion
  //U0CTL |= I2C + SYNC;                      // Switch USART0 to I2C mode
  //U0CTL &= ~I2CEN;                          // Recommended I2C init procedure
  //I2CTCTL = I2CSSEL_2;                      // SMCLK
  //I2CSCLH = 0x03;                           // High period of SCL
  //I2CSCLL = 0x03;                           // Low period of SCL
  //I2CNDAT = 0x01;                           // Transmit one byte
  //I2CSA = 0x01;                             // Slave address
  //U0CTL |= I2CEN;                           // Enable I2C, 7 bit addr,
  //I2CIE = RXRDYIE;                          // I2C receive ready interrupt enable

  //Definition des Port C für P3.6 bis P3.7 (UART1) für RS232
  P3SEL |= BIT6 + BIT7;  //Port C P3.6 bis P3.7 Aux Funktion

  ME2 |= UTXE1 + URXE1;        //USART1 Rx + Tx einschalten
  UCTL1 |= CHAR;               //USART1 8N1
  UTCTL1 |= SSEL0;             //ACLK
    UBR01 = 0xA0;                       // 19200 baud bei 8 MHz erzeugen
    UBR11 = 0x01;                       // 19200 baud bei 8 MHz erzeugen
    UMCTL1 = 0x5B;                      // Korrektur der division noetig
    UCTL1 &= ~SWRST;                // USART1 freigeben
   // IE2 |= UTXIE1;                  // TX-interrupt anschalten
   // IFG2 &= ~UTXIFG1;            // initales interrupt-flag loeschen




  //Definition des Ports D für 8 Relais Ausgänge
  P4SEL = 0x00;  //Port D I/O Funktion
  P4DIR = 0xFF;  //Port D Output
  P4OUT = 0x00;  //Port D Low

// Interrupts freigeben
  __enable_interrupt();


//ADC initieren
//Timer A starten
  Init_ADC();
  Timer_A ();

//Zeit um genügend Mittelwerte zu bilden
  for (i_init = 0; i_init <= 1625; i_init++)
  {
    uart_puts ("System startet...\t\t");
  }
  uart_puts ("\x1b\[2J"); //Bildschirm löschen

while (1)
{

// Gemittelte Digits in Temperatur umrechen lassen
  Temperatur_1 = Temperatur (Mittelwert_11); // Temp. Puffer oben
  Temperatur_2 = Temperatur (Mittelwert_12); // Temp. Heizkreis-Rücklauf
  Temperatur_3 = Temperatur (Mittelwert_13); // Temp. Holzofen
  Temperatur_4 = Temperatur (Mittelwert_14); // Temp. Puffer- Rücklauf
  Temperatur_5 = Temperatur (Mittelwert_15);
  Temperatur_6 = Temperatur (Mittelwert_16);
  Temperatur_7 = Temperatur (Mittelwert_17);
  Temperatur_7 = Temperatur (Mittelwert_18);

// Differenzbildung aus Puffer-Temperatur oben
// und Heizkreis-Rücklauf
// Ansteuerung der Ausgänge A1 und A2 zur
// Mischersteuerung
delta_1 = Temperatur_1 - Temperatur_2;

        if (delta_1 >= 7)
        {
          A2_off;
          A1_on;
        }


        if (delta_1 <= 2)
        {
            A1_off;
             A2_on;
        }

//Rücklaufanhebung an A3 ein- und ausschalten
delta_2 = Temperatur_3 - Temperatur_1;

if (Temperatur_3 >= 90)
  A3_on;
else
   {
      if (delta_2 >= 2)
        {
          if (Temperatur_3 >= 65)
            A3_on;

          if (Temperatur_3 <= 60)
            A3_off;
        }
      else
     A3_off;
   }

//Brennerabschaltung bei Puffertemp. > 60°C
if (Temperatur_1 >= 60)
  A7_on;

if (Temperatur_1 <= 58)
  A7_off;




//Umwandlung INT -> ASCII, Zuweisung buffer_x
  Format (Temperatur_1, buffer_1);  //Temp. Puffer oben
  Format (Temperatur_2, buffer_2);  //Temp. Heizkreis Rücklauf
  Format (Temperatur_3, buffer_3);  //Temp. Holzofen
  Format (Temperatur_4, buffer_4);  //Temp. Puffer Rücklauf
  Format (delta_1, buffer_5);       //Differenz zw. Puffer oben und Heizkreis Rücklauf
  Format (Mittelwert_11, buffer_6); //Digits Puffer oben



// Positionen, Texte und Werte (Maske) setzen
  scrPos ("1", "25"); uart_puts ("\x1b\[1K"); uart_puts("Holzofensteuerung v2.00c");
  scrPos ("2", "25"); uart_puts ("\x1b\[1K"); uart_puts("von Stefan Sachs");
  scrPos ("4", "1"); uart_puts ("Temperatur Holzofen: ");
  scrPos ("5", "1"); uart_puts ("Temperatur Puffer oben: ");
  scrPos ("6", "1"); uart_puts ("Temperatur Heizkreis-Ruecklauf: ");
  scrPos ("7", "1"); uart_puts ("Temperatur Differenz: ");
  scrPos ("8", "1"); uart_puts ("Temperatur Puffer-Ruecklauf: ");
  scrPos ("4", "34"); uart_puts (buffer_3);
  scrPos ("5", "34"); uart_puts (buffer_1);
  scrPos ("5", "40"); uart_puts (buffer_6);
  scrPos ("6", "34"); uart_puts (buffer_2);
  scrPos ("7", "34"); uart_puts (buffer_5);
  scrPos ("8", "34"); uart_puts (buffer_4);


  }
}

//Ab hier Funktionen

// Hier werden die Positionen auf dem
// Bildschirm angefahren
void scrPos(char* x, char* y)
{
  uart_puts ("\x1b\[");  // x1b ESC- Zeichen
  uart_puts (x);         // Zeilenauswahl
  uart_putc (';');       // Gehört zur ESC- Sequenz
  uart_puts (y);         // Spaltenauswahl
  uart_putc ('H');       // Gehört zur ESC- Sequenz
  //uart_puts ("\x1b\[K");

}


//Hier wird der Timer A eigestellt
void Timer_A (void)
{
  TACTL = TASSEL_2 + TACLR;   //SMCLK (DCO) + Clear Timer A
  TACCTL0 = CCIE;             //Capture / compare interrupt en.
  TACCR0 = cycles;            //s. #define cycles
  TACTL |= MC_2 |ID_3;        //Continuous- Mode to TACCR0 + clock/8
}


// Hier wird der 8MHz Quarz aktiviert
// und der DCO auf 100KHz eigestellt
void init_XT(void)
{
  unsigned int i;
  WDTCTL = WDTPW + WDTHOLD;             // Stop WDT
  DCOCTL = DCO1 + DCO0;                 // SMCLK 100KHz
  BCSCTL1 &= ~RSEL2 |RSEL1 |RSEL0;      // SMCLK 100KHz
  BCSCTL1 |= XTS;                       // ACLK = LFXT1 = HF XTAL
  do
  {
    IFG1 &= ~OFIFG;                    // Clear OSCFault flag
    for (i = 0xFF; i > 0; i--);        // Time for flag to set
  }
  while ((IFG1 & OFIFG) == OFIFG);     // OSCFault flag still set?
  BCSCTL2 |= SELM1+SELM0;              // MCLK = LFXT1 (safe)
}

// Hier werden INT- Zahlen in ASCII umgewandelt (einfache Version)
void Format(long zahl, char* string) {
  int i;

  string[5]='\0';                  // String Terminator
  if( zahl < 0 ) {                  // ist die Zahl negativ?
    string[0] = '-';
    zahl = -zahl;
  }
  else string[0] = ' ';             // Zahl ist positiv

  for(i=4; i>=1; i--) {
    string[i]=(zahl % 10) +'0';     // Modulo rechnen, dann den ASCII-Code von '0' addieren
    zahl /= 10;
  }
}



// Umrechnung der Digits in Temperatur
long int Temperatur (long int Digit)
{

  if (Digit <= 2824)
      return (((Digit - Offset) * 1471) / 10000);

  if ((Digit >= 2825) && (Digit <= 2884))
    return (((Digit - Offset) * 1493) / 10000);

  if ((Digit >= 2885) && (Digit <= 2938))
      return (((Digit - Offset) * 1548) / 10000);

  if ((Digit >= 2939) && (Digit <= 2988))
      return (((Digit - Offset) * 1595) / 10000);

  if ((Digit >= 2989) && (Digit <= 3036))
      return (((Digit - Offset) * 1650) / 10000);

  if ((Digit >= 3037) && (Digit <= 3081))
      return (((Digit - Offset) * 1695) / 10000);

  if ((Digit >= 3082) && (Digit <= 3123))
      return (((Digit - Offset) * 1751) / 10000);

  if ((Digit >= 3124) && (Digit <= 3162))
      return (((Digit - Offset) * 1799) / 10000);

  if ((Digit >= 3163) && (Digit <= 3196))
      return (((Digit - Offset) * 1862) / 10000);

  if (Digit >= 3197)
      return (((Digit - Offset) * 1919) / 10000);


  //return (((Digit * ((Uref / MaxDigit) * Steigung)) / 10000) - Offset);
  //return (Digit - 2588);
}



// Senden eines Zeichens
int uart_putc(char c)
{
  while (!(IFG2 & UTXIFG1));  /* warten bis Senden moeglich */

    U1TXBUF = c;                      /* sende Zeichen */
    return 0;
}


// Senden eines Strings
void uart_puts (char *s)
{
    while (*s)
    {   /* so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)" */
        uart_putc(*s);
        s++;
    }
}


//Hier wird der ADC eingestellt
void Init_ADC(void)
{
  P6SEL = 0xFF;  // Analogeingänge A0 - A7 (P6.0 - P6.7)
  ADC12CTL0 = ADC12ON + REFON + REF2_5V + MSC + SHT0_12 + SHT1_12;
  ADC12CTL1 = ADC12SSEL_1 + ADC12DIV_7 + SHP + CONSEQ_1;
  ADC12MCTL0 = SREF_7 + INCH_0; // Wert von A0 landet in ADC12MEM0
  ADC12MCTL1 = SREF_7 + INCH_1; // Wert von A1 landet in ADC12MEM1
  ADC12MCTL2 = SREF_7 + INCH_2; // Wert von A2 landet in ADC12MEM2
  ADC12MCTL3 = SREF_7 + INCH_3; // Wert von A3 landet in ADC12MEM3
  ADC12MCTL4 = SREF_7 + INCH_4; // Wert von A4 landet in ADC12MEM4
  ADC12MCTL5 = SREF_7 + INCH_5; // Wert von A5 landet in ADC12MEM5
  ADC12MCTL6 = SREF_7 + INCH_6; // Wert von A6 landet in ADC12MEM6
  ADC12MCTL7 = SREF_7 + INCH_7 + EOS; // Wert von A7 landet in ADC12MEM7
  ADC12IE = 0x80;  //ADC Interrupts freigeben
  ADC12CTL0 |= ENC;  // Konvertierung freigenben
}



//Hier wird der ADC gestartet
void Read_ADC(void)
{
  while (ADC12CTL1 & ADC12BUSY);  //ADC noch beschäftigt?
  ADC12CTL0 |= ADC12SC;   // Neue Konvertierung starten
}






//Ab hier ISR's

// Hier wird der ADC angestoßen
// und 8 Mittelwerte gebildet
#pragma vector=TIMERA0_VECTOR
__interrupt void TimerA0_VECTOR (void)
{
    Read_ADC();

//a=1/4
      Mittelwert_1 = ((Mittelwert_1 * 3) >> 2) + (Digit_1 >> 2);
      Mittelwert_2 = ((Mittelwert_2 * 3) >> 2) + (Digit_2 >> 2);
      Mittelwert_3 = ((Mittelwert_3 * 3) >> 2) + (Digit_3 >> 2);
      Mittelwert_4 = ((Mittelwert_4 * 3) >> 2) + (Digit_4 >> 2);
      Mittelwert_5 = ((Mittelwert_5 * 3) >> 2) + (Digit_5 >> 2);
      Mittelwert_6 = ((Mittelwert_6 * 3) >> 2) + (Digit_6 >> 2);
      Mittelwert_7 = ((Mittelwert_7 * 3) >> 2) + (Digit_7 >> 2);
      Mittelwert_8 = ((Mittelwert_8 * 3) >> 2) + (Digit_8 >> 2);

//a=1/2
      Mittelwert_11 = (Mittelwert_11 >> 1) + (Mittelwert_1 >> 1);
      Mittelwert_12 = (Mittelwert_12 >> 1) + (Mittelwert_2 >> 1);
      Mittelwert_13 = (Mittelwert_13 >> 1) + (Mittelwert_3 >> 1);
      Mittelwert_14 = (Mittelwert_14 >> 1) + (Mittelwert_4 >> 1);
      Mittelwert_15 = (Mittelwert_15 >> 1) + (Mittelwert_5 >> 1);
      Mittelwert_16 = (Mittelwert_16 >> 1) + (Mittelwert_6 >> 1);
      Mittelwert_17 = (Mittelwert_17 >> 1) + (Mittelwert_7 >> 1);
      Mittelwert_18 = (Mittelwert_18 >> 1) + (Mittelwert_8 >> 1);

  CCR0 += cycles;                        // Add Offset to CCR0
}



// Hier werden 8 ADC-Werte zugewiesen
#pragma vector=ADC12_VECTOR
__interrupt void ADC12ISR (void)
{
  Digit_1 = ADC12MEM0;
  Digit_2 = ADC12MEM1;
  Digit_3 = ADC12MEM2;
  Digit_4 = ADC12MEM3;
  Digit_5 = ADC12MEM4;
  Digit_6 = ADC12MEM5;
  Digit_7 = ADC12MEM6;
  Digit_8 = ADC12MEM7;

}


/*
// UART0 TX ISR
#pragma vector=USART0TX_VECTOR
__interrupt void usart0_tx (void)
{
  char i, j;
  for (j=0; j<2; j++)
  {
  for (i=0; i < sizeof Digit[j]; i++)
    TXBUF0 = Digit[j];

  }
}
*/

//Hier werden die Tasten abgefragt
#pragma vector = PORT1_VECTOR
__interrupt void PORT1_ISR (void)
{
//  __low_power_mode_off_on_exit();

  int i;

  //funktion = funktion + set;
      //  set = 0;
      //  if (funktion > 5) {funktion = 0;}
      //  if (funktion < 0) {funktion = 5;}

        if (!(P1IN & BIT0))
        {
          //P4OUT ^= BIT0;
          for (i=1; i <= 1200; i++){}

        //  set = 1;
        }

        P1IFG &= ~BIT0;  // Interrupt Flag löschen


        if (!(P1IN & BIT1))
        {
          //P4OUT ^= BIT1;
          for (i=1; i <= 1200; i++){}

        //  set = -1;
        }
        P1IFG &= ~BIT1;  // Interrupt Flag löschen


        if (!(P1IN & BIT2))
        {
          //P4OUT ^= BIT2;
          for (i=1; i <= 1200; i++){}

          //  set = -1;
        }
        P1IFG &= ~BIT2;  // Interrupt Flag löschen


        if (!(P1IN & BIT3))
        {
          P4OUT ^= BIT3;
          for (i=1; i <= 1200; i++){}

          //  set = -1;
        }
        P1IFG &= ~BIT3;  // Interrupt Flag löschen


        if (!(P1IN & BIT4))
        {
          P4OUT ^= BIT4;
          for (i=1; i <= 1200; i++){}

          //  set = -1;
        }
        P1IFG &= ~BIT4;  // Interrupt Flag löschen


        if (!(P1IN & BIT5))
        {
          P4OUT ^= BIT5;
          for (i=1; i <= 1200; i++){}

          //  set = -1;
        }
        P1IFG &= ~BIT5;  // Interrupt Flag löschen


        if (!(P1IN & BIT6))
        {
          P4OUT ^= BIT6;
          for (i=1; i <= 1200; i++){}

          //  set = -1;
        }
        P1IFG &= ~BIT6;  // Interrupt Flag löschen


        if (!(P1IN & BIT7))
        {
          P4OUT ^= BIT7;
          for (i=1; i <= 1200; i++){}

          //  set = -1;
        }
        P1IFG &= ~BIT7;  // Interrupt Flag löschen



}

Besten Dank

[Found (Gast)]

Ein paar Dinge fallen mir auf:

  int           long int      long int
Temperatur_1 = Temperatur (Mittelwert_11)
Hier reichen durchgängig 16 Bit.

Format (Temperatur_1, buffer_1)
          int          char[6]
Hier reichen die 6 Byte nicht. 1 Byte Vorzeichen + 5 Zeichen für int + 1 
Byte '/'.

for (i=1; i <= 1200; i++){}
Das ist in einer ISR gar nicht gut. Such einmal nach Entprellung 
http://www.mikrocontroller.net/articles/Entprellung oder hier im Forum.

[Stefan S. (blacknighthawk)]

Hallo Found,

besten Dank für deine Tips.
Bei den char[6] habe ich doch glatt vergessen das Schlusszeichen mit 
einzubeziehen.

Das mit der Entprellung werde ich mir mal genauer ansehen.

Dann mal noch eine allgemeine Frage an alle:

Wenn ich nicht explizit einen LPM aktiviere, dann kann der MSP doch 
unter keinen Umständen "schlafen" gehen, ist das richtig?

Oder soll ich zur Sicherheit alle Register die für LPM sind auf "0" 
setzten?

[MartinK (Gast)]

Von alleine geht der MSP nicht in den Schlafzustand.
Hast du mal den Stromverbrauch gemessen?

[Stefan S. (blacknighthawk)]

MartinK schrieb:
> Von alleine geht der MSP nicht in den Schlafzustand.

Diese Aussage alleine reicht mir schon.

> Hast du mal den Stromverbrauch gemessen?

Da komme ich in der fertigen Schaltung nicht mehr so gut dran, dafür 
müsste ich Leiterbahnen auftrennen.
Und bis jetzt läuft die Anlage wieder ohne Zwischenfälle, ich weiß also 
nicht wann der nächste Crash passiert.

[EMV (Gast)]

Wie steht es um EMV. Hast du deine Schaltung gut entkoppelt und 
geschützt? Sonst kannst du die Wertebereiche vor der Verarbeitung 
überprüfen. Wie verhält sich dein Code bei unerwarteten Werten?

Stefan S. schrieb:
> if (Digit <= 2824)
>       return (((Digit - Offset) * 1471) / 10000);
>
>   if ((Digit >= 2825) && (Digit <= 2884))
>     return (((Digit - Offset) * 1493) / 10000);
>
>   if ((Digit >= 2885) && (Digit <= 2938))
>       return (((Digit - Offset) * 1548) / 10000);
Das lässt sich optimieren:

if (Digit <= 2824)
      return (((Digit - Offset) * 1471) / 10000);
else if (Digit <= 2884)
     return (((Digit - Offset) * 1493) / 10000);
else if (Digit <= 2938)
     return (((Digit - Offset) * 1548) / 10000);

Und da du mit return den restlichen Teil der Funktion überspringst, geht 
es hier auch ohne die else.

[Stefan S. (blacknighthawk)]

EMV schrieb:
> Wie steht es um EMV. Hast du deine Schaltung gut entkoppelt und
> geschützt? Sonst kannst du die Wertebereiche vor der Verarbeitung
> überprüfen.

EMV hin oder her, ich habe 6 Jahre in einem EMV- Labor gearbeitet und so 
manchen seltsamen Effekt gesehen.
Natürlich kann der Ausfall von neulich auch auf eine seltene Störung von 
außen zurückzuführen sein.
Die AVCC ist über 15uH von der DVCC entkoppelt, allerdings liegen AVSS 
und DVSS auf der selben Masse.

Die Roh- Digits vom ADC sind sehr unruhig, da dachte ich zuerst auch ein 
Problem in meiner Schaltung. Aber Arbeitskollegen haben mir von 
ähnlichen Erfahrungen berichtet, was die Stabilität der ADC- Werte 
angeht.

> Wie verhält sich dein Code bei unerwarteten Werten?

Ich hätte ja mal behauptet, alles was kleiner / gleich 2824 Digits ist 
(entspricht glaube ich 0°C) wird mit

return (((Digit - Offset) * 1471) / 10000);

behandelt.
Und alles was größer / gleich 3197 Digits ist (entspricht glaube ich 120 
°C) wird mit

return (((Digit - Offset) * 1919) / 10000);

behandelt.
Klar dass alles was unter 0°C und über 120°C ungenau wird, aber in der 
Anlage herrschen Temperaturen von min. 20°C und max. 90°C.
Aber wenn hier ein Denkfehler vorliegt, bitte sagen.


> Das lässt sich optimieren:
>

> if (Digit <= 2824)
>       return (((Digit - Offset) * 1471) / 10000);
> else if (Digit <= 2884)
>      return (((Digit - Offset) * 1493) / 10000);
> else if (Digit <= 2938)
>      return (((Digit - Offset) * 1548) / 10000);
>

> Und da du mit return den restlichen Teil der Funktion überspringst, geht
> es hier auch ohne die else.

Da hast du allerdings Recht, die ganzen else's hätte ich mir sparen 
können.

Was ich allerdings mal noch gerne implementieren würde ist, die Digit- 
Werte in einer Tabelle abzulegen und zu interpolieren. Da weiß ich aber 
noch nicht wie es geht.


Was mir noch eingefallen ist, macht es überhaupt Sinn oder ist es sogar 
schlecht die RS232 bei diesem MSP mit 19200 Baud zu befeuern?

Und ist es schlecht an XT2 einen 32KHz Quarz anzuschließen, diesen aber 
nicht zu benutzen?

[EMV (Gast)]

Stefan S. schrieb:
>> if (Digit <= 2824)
>>       return (((Digit - Offset) * 1471) / 10000);
>> else if (Digit <= 2884)
>>      return (((Digit - Offset) * 1493) / 10000);
>> else if (Digit <= 2938)
>>      return (((Digit - Offset) * 1548) / 10000);
>> > Und da du mit return den restlichen Teil der Funktion überspringst, geht
>> es hier auch ohne die else.
>
> Da hast du allerdings Recht, die ganzen else's hätte ich mir sparen
> können.

Mir ging es dabei um etwas anderes. In deinem Post fragst du Intervalle 
ab. Da kann durch eine kleine Unachtsamkeit schnell ein Wert durch 
rutschen. Wenn du nur eine Schwelle auswertest, kann das nicht 
passieren.

Stefan S. schrieb:
> Die Roh- Digits vom ADC sind sehr unruhig, da dachte ich zuerst auch ein
> Problem in meiner Schaltung.

Welche Auflösung nutzt du und wieviel Bits wackeln?

Stefan S. schrieb:
> Und ist es schlecht an XT2 einen 32KHz Quarz anzuschließen, diesen aber
> nicht zu benutzen?

Wenn du den externen Takt nicht konfiguriest, ist das kein Problem. Der 
schwingt dann auch nicht.

[Rufus Τ. F. (rufus)]

Stefan S. schrieb:
> Was mir noch eingefallen ist, macht es überhaupt Sinn oder ist es sogar
> schlecht die RS232 bei diesem MSP mit 19200 Baud zu befeuern?

Die UART auch dieses steinalten MSP430-Exemplars hat einen recht 
flexiblen Baudratengenerator, so daß --eine stabile Takterzeugung 
vorausgesetzt-- diese Baudrate kein Problem ist. Sogenannte 
"Baudratenquarze" sind i.d.R. nicht erforderlich.

Um auf Nummer Sicher zu gehen, solltest Du Dir im "Family User's Guide" 
(SLAU149) den Abschnitt über die Baudratenerzeugung zu Gemüte führen, da 
wird beschrieben, wie der Baudratenfehler für verschiedene 
Taktfrequenzen zu berechnen ist.

Auf http://processors.wiki.ti.com/index.php/USART_Baud_Rate_Calculator 
ist eine Tabelle 
(http://processors.wiki.ti.com/images/8/81/MSP430_USART_Baud_Rate.pdf) 
verlinkt, bei der die Baudratenberechnung für übliche Baudraten und 
übliche Taktfrequenzen durchgeführt wurde.

Einen Online-Berechner, der das alles ausspuckt, gibt es auch noch:
http://mspgcc.sourceforge.net/baudrate.html

Allerdings ist eine stabile Takterzeugung nötig, und zwar unabhängig von 
der Baudrate. Der DCO ist nicht stabil genug, und auch die 
Stabilisierung mit einem Uhrenquarz, wie in einer TI-Appnote 
beschrieben, ist wegen des ständig schwankenden Takts auch ungeeignet.

[stef (Gast)]

Hallo,

ich arbeite auch viel mit MSP430, von alleine in den LPM habe ich noch 
nicht erlebt, dafür alles andere drumherum :)
Ich glaube auch das kein System von sich aus 100% stabil ist, alles nur 
eine Frage der Zeit.


Deine Entprellung sieht merkwürdig und sinnlos aus, Ich würde das in 
einem Timer Interrupt abfragen:
__interrupt void TimerA0_1ms(void)
{
  if ( (Taster_OK_I&Taster_OK) )Taste_OK_debounce++;
  else Taste_OK_debounce = 0;
  if (Taste_OK_debounce == DEBOUNCE ){
    Taste_OK = 1;
  }

so mach ich das, funktioniert prima, also nur soalnge Taste gedrückt ist 
wird sie gezählt und das über ein paar ms weg.

Das Rauschen auf der ADC Messung kann ich so bestätigen, ich messe mit 
12 bit bei internen oder externen Vref von 2,5 V habe ich auch bis zu 
50mV Rauschen drauf, keine Ahnung ob das an meinem PCB Layout liegt oder 
intern im MSP430 oder doch an der externen Quelle, wobei ich der schon 
vertraue. Da kommt man wohl nicht drumherum ohne sehr gute Kenntnisse 
und Layouts.

Viele Grüße,

[Max G. (l0wside)]

Rufus Τ. Firefly schrieb:
> Allerdings ist eine stabile Takterzeugung nötig, und zwar unabhängig von
> der Baudrate. Der DCO ist nicht stabil genug, und auch die
> Stabilisierung mit einem Uhrenquarz, wie in einer TI-Appnote
> beschrieben, ist wegen des ständig schwankenden Takts auch ungeeignet.

Gilt diese Aussage nur für den F167, oder für alle Derivate? Ich setze 
den MSP430F5310 ein, allerdings stets ohne Quarz. War auf der UART nie 
ein Problem. SPI und I2C sind sowieso unkritisch.

Max

[Rufus Τ. F. (rufus)]

Max G. schrieb:
> Gilt diese Aussage nur für den F167, oder für alle Derivate?

Der DCO im 'F5310 ist nicht mit dem der steinalten 'F1xx-Reihe 
vergleichbar, da er über die FLL mit dem REFO stabilisiert werden kann. 
Das ist um Größenordnungen genauer.

Mir ist sowieso unklar, warum jetzt noch Leute mit 'F1xx arbeiten. Die 
Dinger sind deutlich teurer, langsamer und können weniger als alles, was 
TI danach herausgebracht hat.

Als so eine Art "Wasserscheide" kann man das Vorhandensein von SBW 
ansehen.

> SPI und I2C sind sowieso unkritisch.

Das ist logisch, da bei synchronen seriellen Schnittstellen ein 
Taktsignal mitgeliefert wird.

[stef (Gast)]

manche MSP430 haben eine kalibrierte DCO, das ist dann im Datenblatt zu 
lesen und man kann da mit gewissen kleinen Abweichungen, die natürlich 
auch angegegeben sind, davon ausgehen, dass der Takt zB 1 MHz sehr genau 
gehalten wird.

Andere DCOs schwanken da schon stärker was sich durchaus auf BAudrate 
auswirkne kann.
Ich habe bisher immer einen externen Quarz drauf gehabt, vor allem um 
eben die hohen Freuqenzen zu haben und weil ich doch verschiedene Timer 
benutze die zB eine PWM ansteuern, und da will ich eben genau wissen was 
meine Zeiten sind.

[Max G. (l0wside)]

Rufus Τ. Firefly schrieb:
>> SPI und I2C sind sowieso unkritisch.
>
> Das ist logisch, da bei synchronen seriellen Schnittstellen ein
> Taktsignal mitgeliefert wird.

You got my point :-)


stef schrieb:
> Ich habe bisher immer einen externen Quarz drauf gehabt, vor allem um
> eben die hohen Freuqenzen zu haben und weil ich doch verschiedene Timer
> benutze die zB eine PWM ansteuern, und da will ich eben genau wissen was
> meine Zeiten sind.

Hohe Frequenzen? Ist das auch ein F1xxx-Thema? Meine F53xx laufen mit 25 
MHz ohne Quarz und ohne Probleme. Toleranz ist so 1%-2%, das tut mir 
nicht weh.

Max

[Rufus Τ. F. (rufus)]

Max G. schrieb:
> Hohe Frequenzen? Ist das auch ein F1xxx-Thema?

'F1xx können mit maximal 8 MHz betrieben werden.

Und ja, die Dinger sind im Vergleich zu allen neueren MSP430-Varianten 
ziemlich primitiv.

[Stefan S. (blacknighthawk)]

stef schrieb:
> Deine Entprellung sieht merkwürdig und sinnlos aus, Ich würde das in
> einem Timer Interrupt abfragen:
> __interrupt void TimerA0_1ms(void)
> {
>   if ( (Taster_OK_I&Taster_OK) )Taste_OK_debounce++;
>   else Taste_OK_debounce = 0;
>   if (Taste_OK_debounce == DEBOUNCE ){
>     Taste_OK = 1;
>   }

Das dachte ich mir schon als ich es geschrieben habe, aber der Winter 
stand vor der Tür und das System sollte laufen.
Ich werde deinen Vorschlag mal versuchen in die Tat umzusetzen.

Rufus Τ. Firefly schrieb:
> Mir ist sowieso unklar, warum jetzt noch Leute mit 'F1xx arbeiten. Die
> Dinger sind deutlich teurer, langsamer und können weniger als alles, was
> TI danach herausgebracht hat.

Ich weiß, aber von den Teilen lagen noch ca. 30 Stück ungenutzt auf der 
Arbeit herum. Dieser MSP ist sozusagen mein Einstiegsprozessor.

Rufus Τ. Firefly schrieb:
> 'F1xx können mit maximal 8 MHz betrieben werden.

Das habe ich auch schon gemerkt, ich habe es mal mit einem 16MHz Quarz 
versucht... Das ging 3 Tage gut, dann löste plötzlich die thermische 
Sicherung am Ofen aus weil die Steuerung komplett hängen blieb. Das war 
ein Spass und das (zum Glück) auf den Sonntag.


Ich werde mal versuchen dem Watchdog in Betrieb zu setzten, vielleicht 
rettet der mich aus den kritischen Situationen.
Oder spricht etwas dagegen?

[Stefan S. (blacknighthawk)]

Ich wünsche allen einen geruhsamen Sonntag.

Ich bin gerade meinen Code nochmals durchgegangen weil meine Anlage 
gerade eben wieder in einem undefinierten Zustand war. Ich glaube also 
nicht mehr dass sich etwas aufhängt, sondern grundlegende Probleme im 
Code sind.

Z.B. hier:

  Temperatur_1 = Temperatur (Mittelwert_11); // Temp. Puffer oben
  Temperatur_2 = Temperatur (Mittelwert_12); // Temp. Heizkreis-Rücklauf
  Temperatur_3 = Temperatur (Mittelwert_13); // Temp. Holzofen


delta_1 = Temperatur_1 - Temperatur_2;

        if (delta_1 >= 7)
        {
          A2_off;
          A1_on;
        }


        if (delta_1 <= 2)
        {
            A1_off;
             A2_on;
        }

Wenn delta_1 etwas zwischen 2 und 7 ist, passiert nach einem Reset 
nichts und auch sonst ist der Zustand undefiniert.

und dann:

delta_2 = Temperatur_3 - Temperatur_1;

if (Temperatur_3 >= 80)
  A3_on;
else
   {
      if (delta_2 >= 2)
        {
          if (Temperatur_3 >= 65)
            A3_on;

          if (Temperatur_3 <= 60)
            A3_off;
        }
      else
     A3_off;
   }

Wenn Temperatur_3 einen Wert zwischen 60 und 65 annimmt, ist auch ein 
toter Bereich.
Aber da muss noch ein Denkfehler drin sein.

[EMV (Gast)]

Stefan S. schrieb:
> weil meine Anlage
> gerade eben wieder in einem undefinierten Zustand war

Das heißt?

Stefan S. schrieb:
> Wenn delta_1 etwas zwischen 2 und 7 ist, passiert nach einem Reset
> nichts und auch sonst ist der Zustand undefiniert.

Nö, den Zustand nach Reset kannst du aus dem Datenblatt lesen. Und wenn 
keine Bedingung trifft, bleibt der Zustand wir er ist.

Stefan S. schrieb:
> Wenn Temperatur_3 einen Wert zwischen 60 und 65 annimmt, ist auch ein
> toter Bereich.

Aber nur wenn delta_2 ... Sonst bleibt es wie es ist.

Das Ganze ist aber ein wenig konfus. In der Timer ISR wird er AD-Wandler 
gestartet. Parallel wird mit den gleichen Werten gerechnet, die in der 
AD ISR gerade beschrieben werden?
Wie erfolgt die Auswahl der Datentypen? Groß und klein sind bunt 
gemischt. Der Wertebereich sollte der Grund sein. Und ich glaube es geht 
mit weniger Variablen übersichtlicher.

Das Programm ist nicht besonders groß. Da ist ein neuer Ansatz durchaus 
erlaubt.

[Stefan S. (blacknighthawk)]

EMV schrieb:
> Das Programm ist nicht besonders groß. Da ist ein neuer Ansatz durchaus
> erlaubt.

Das stimmt allerdings.
Ich werde das Programm mal grundlegend überarbeiten müssen.
Einiges kann noch einfacher und besser gemacht werden.