MSP430G2553 Startet nur nach Reset

[Smazze (Gast)]

Hallo Freunde,
ich möchte, wie der Titel schon sagt, das der MSP430, wenn er mit 
Spannung vom USB-Anschluss versorgt wird, automatisch "losrennt".
Die Pinnne Test und RST habe ich abgezogen.

Komisch ist, dass wenn ich den Resetknopf drücke, dann alles 
funktioniert.
Mein Programm sieht folgendermaßen aus:

#include <msp430.h>
#define USSensoren 4

int RXByteCtr, RPT_Flag = 0;                // enables repeated start when 1
unsigned char TXData[2];
unsigned char RXData[2];
int anzahlTXNachrichten=0;
int anzahlRXNachrichten=0;
unsigned char TXByteCtr, RX = 0;


char RS232SendeBuffer[4];

void Setup_TX(int);
void Setup_RX(int);
void Transmit(void);
void Receive(void);
void RS232init(void);

int main(void)
{


  int startadresse;
  WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT
  RS232init();
  P1SEL |= BIT6 + BIT7;                     // Assign I2C pins to USCI_B0
  P1SEL2|= BIT6 + BIT7;                     // Assign I2C pins to USCI_B0



  while(1){

          //Transmit process
          anzahlTXNachrichten=0;          //setze gesendete  Nach-richten auf 0
          anzahlRXNachrichten=0;          //setze gesendete  Nach-richten auf 0
        TXData[0]=0x00;              //Sende an Register 0
        TXData[1]=0x51;              //Schreibe "Messung in cm" auslösen
        TXByteCtr = 2;                          // Bytes die übertragen werden
      Setup_TX(0);
      Transmit();
      while (UCB0CTL1 & UCTXSTP);             // Ensure stop condition got sent
      _delay_cycles(100000);                //delay ca. 100ms

    for( startadresse=112; startadresse<112+USSensoren;startadresse++)              //Lese 4 Sensoren aus
  {
          anzahlTXNachrichten=0;          //setze gesendete  Nach-richten auf 0
          anzahlRXNachrichten=0;          //setze gesendete  Nach-richten auf 0
      //Transmit process
        TXData[0]=0x02;              //Sende an Register 2
        TXByteCtr = 1;                          // Load TX byte counter
      Setup_TX(startadresse);
      RPT_Flag = 1;
      Transmit();
      while (UCB0CTL1 & UCTXSTP);             // Ensure stop condition got sent

      //Receive process
      RXByteCtr = 2;                          // lese zwei Bytes aus
      Setup_RX(startadresse);
      Receive();


       switch(startadresse){
       case 112: RS232SendeBuffer[0] = (char)RXData[1];
                 break;
       case 113: RS232SendeBuffer[1] = (char)RXData[1];
                 break;
       case 114: RS232SendeBuffer[2] = (char)RXData[1];
                 break;
       case 115: RS232SendeBuffer[3] = (char)RXData[1];
                 break;
       }

      while (UCB0CTL1 & UCTXSTP);             // Ensure stop condition got sent
   }
   }
}

//-------------------------------------------------------------------------------
// The USCI_B0 data ISR is used to move received data from the I2C slave
// to the MSP430 memory. It is structured such that it can be used to receive
// any 2+ number of bytes by pre-loading RXByteCtr with the byte count.
//-------------------------------------------------------------------------------
#pragma vector = USCIAB0TX_VECTOR
__interrupt void USCIAB0TX_ISR(void)
{
  if(RX == 1){                                        // Master Recieve?
    RXByteCtr--;                                    // Decrement RX byte counter
    if (RXByteCtr)
    {
      RXData[anzahlRXNachrichten++] = UCB0RXBUF;  // Move RX data to address PRxData
    }
    else
    {
    if(RPT_Flag == 0)
      UCB0CTL1 |= UCTXSTP;                      // No Repeated Start: stop condition
      if(RPT_Flag == 1){                          // if Repeated Start: do nothing
      RPT_Flag = 0;
      }
      RXData[anzahlRXNachrichten++] = UCB0RXBUF;  // Move RX data to address PRxData
    __bic_SR_register_on_exit(CPUOFF);            // Exit LPM0
    }
  }

  else
  {                                     // Master Transmit
  if (TXByteCtr)                        // Check TX byte counter
    {
    UCB0TXBUF = TXData[anzahlTXNachrichten++];                   // Load TX buffer
    TXByteCtr--;                          // Decrement TX byte counter
    }
    else
    {
    if(RPT_Flag == 1){
      RPT_Flag = 0;
      __bic_SR_register_on_exit(CPUOFF);
    }
    else{
      UCB0CTL1 |= UCTXSTP;                    // I2C stop condition
      IFG2 &= ~UCB0TXIFG;                     // Clear USCI_B0 TX int flag
      __bic_SR_register_on_exit(CPUOFF);      // Exit LPM0
    }
    }
 }

}

void Setup_TX(int USSensor){
  _DINT();
  RX = 0;
  IE2 &= ~UCB0RXIE;
  while (UCB0CTL1 & UCTXSTP);               // Ensure stop condition got sent// Disable RX interrupt
  UCB0CTL1 |= UCSWRST;                      // Enable SW reset
  UCB0CTL0 = UCMST + UCMODE_3 + UCSYNC;     // I2C Master, synchronous mode
  UCB0CTL1 = UCSSEL_2 + UCSWRST;            // Use SMCLK, keep SW reset
  UCB0BR0 = 30;                             // fSCL = SMCLK/12 = ~100kHz
  UCB0BR1 = 0;
  UCB0I2CSA = USSensor;                         // Slave Address is 048h
  UCB0CTL1 &= ~UCSWRST;                     // Clear SW reset, resume operation
  IE2 |= UCB0TXIE;                          // Enable TX interrupt
}
void Setup_RX(int USSensor){
  _DINT();
  RX = 1;
  IE2 &= ~UCB0TXIE;
  UCB0CTL1 |= UCSWRST;                      // Enable SW reset
  UCB0CTL0 = UCMST + UCMODE_3 + UCSYNC;     // I2C Master, synchronous mode
  UCB0CTL1 = UCSSEL_2 + UCSWRST;            // Use SMCLK, keep SW reset
  UCB0BR0 = 30;                             // fSCL = SMCLK/12 = ~100kHz
  UCB0BR1 = 0;
  UCB0I2CSA = USSensor;                 // Slave Address is 0x70:112  0x71:113  0x72:114 0x73:115
  UCB0CTL1 &= ~UCSWRST;                     // Clear SW reset, resume operation
  IE2 |= UCB0RXIE;                          // Enable RX interrupt
}



void Transmit(void){
    while (UCB0CTL1 & UCTXSTP);             // Ensure stop condition got sent
    UCB0CTL1 |= UCTR + UCTXSTT;             // I2C TX, start condition
    __bis_SR_register(CPUOFF + GIE);        // Enter LPM0 w/ interrupts
}
void Receive(void){
    while (UCB0CTL1 & UCTXSTP);               // Ensure stop condition got sent
    UCB0CTL1 |= UCTXSTT;                    // I2C start condition
    __bis_SR_register(CPUOFF + GIE);        // Enter LPM0 w/ interrupts
}

void RS232init(void)
{
  if (CALBC1_1MHZ==0xFF)          // If calibration constant erased
  {
     while(1);                               // do not load, trap CPU!!
  }
    DCOCTL = 0;                               // Select lowest DCOx and MODx settings
    BCSCTL1 = CALBC1_1MHZ;                    // Set DCO
    DCOCTL = CALDCO_1MHZ;
    P1SEL = BIT1 + BIT2 ;                     // P1.1 = RXD, P1.2=TXD
    P1SEL2 = BIT1 + BIT2 ;                    // P1.1 = RXD, P1.2=TXD
    UCA0CTL1 |= UCSSEL_2;                     // SMCLK
    UCA0BR0 = 104;                            // 1MHz 9600
    UCA0BR1 = 0;                              // 1MHz 9600
    UCA0MCTL = UCBRS0;                        // Modulation UCBRSx = 1
    UCA0CTL1 &= ~UCSWRST;                     // **Initialize USCI state machine**
    IE2 |= UCA0RXIE;                          // Enable USCI_A0 RX interrupt

   // __bis_SR_register(LPM0_bits + GIE);       // Enter LPM0, interrupts enabled

}

#pragma vector=USCIAB0RX_VECTOR
__interrupt void USCI0RX_ISR(void)
{
   static int bufferCounter;


   while (!(IFG2&UCA0TXIFG));                // USCI_A0 TX buffer ready?
   //UCA0TXBUF = UCA0RXBUF;

   bufferCounter++;

   switch(bufferCounter){

   case 1: UCA0TXBUF = RS232SendeBuffer[0];
             break;
   case 2: UCA0TXBUF = RS232SendeBuffer[1];
             break;
   case 3: UCA0TXBUF = RS232SendeBuffer[2];
             break;
   case 4: UCA0TXBUF = RS232SendeBuffer[3];
             break;
   case 5:
       bufferCounter=0;
       IFG2 &= ~UCA0RXIFG;
             break;
   }

     //UCA0TXBUF = TX_StringRS232;                    // TX -> RXed character)

     //UCA0TXBUF = TX_StringRS232[2];                    // TX -> RXed character)
     //UCA0TXBUF = TX_StringRS232[3];                    // TX -> RXed character)

}

Vielen Dank im Vorraus!!
Smazze

--

Quelltext bitte in [ c ] [ /c ] - Tags einschließen.

-rufus

[spontan (Gast)]

Sieht doch eher nach einem Hardware-Problem aus. Gibts einen Schaltplan?

[Smazze (Gast)]

Muss dazu noch sagen..
Wenn ich im Debugmodus auf Run klicke rennt der auch los.
Nur dieses "Autolosrennen" bei Spannungsanlage funzt nicht.. :((

[Oppa (Gast)]

Mal das Errata gescheckt ? Der hier vielleicht ?

BCL12 BCS Module
Function Switching RSELx or modifying DCOCTL can cause DCO dead time or 
a complete DCO stop

http://www.ti.com/lit/er/slaz440f/slaz440f.pdf

[Rufus Τ. F. (rufus)]

Sieh Dir mal den Schaltplan des Launchpads an. Dort ist eine 
RC-Kombination am Reset-Pin angeschlossen, die kannst Du nachbilden. 
Möchtest Du per SBW in Deiner Schaltung debuggen, darf der Kondensator 
aber nicht größer als 2.2 nF werden.

Oder lässt Du Dein Programm auf dem im Launchpad steckenden Controller 
laufen?

Dein Quelltext ist übrigens ... grässlich formatiert.