comms_uart.c

MSP430 examples or customized

         digitval = Digit1(bcd[(10-i)/2]);  // Even: high digit
      }
      else
      {
         digitval = Digit0(bcd[(10-i)/2]);  // Odd: low digit
      }

      if (digitval > '0')
         {LZSflag = 0;}         // Clear LZS flag when non-zero character seen

      if (  (digitval != '0')
         ||(LZSflag == 0)
         ||(i == after+1) )
      {
         SendChar(digitval);
      }
   }
   if(after > 0)
   {
      SendChar('.');
      for (i=after; i>0; i--)
      {
         if ((i&1) == 0)      // Test for odd or even
         {
            digitval = Digit1(bcd[(10-i)/2]);  // Even: high digit
         }
         else
         {
            digitval = Digit0(bcd[(10-i)/2]);  // Odd: low digit
         }

         SendChar(digitval);
      }
   }
}

void SendChar(char ch)
{
   while ((U0IFG&UTXIFG0)==0);            // wait till TX buf empty
   TXBUF0=ch;                        // transmit ch
}

int Digit0(unsigned char Register)         // return LSB nibble (digit 0)
{  int result;

   result = Hex2ASCII(0x0F & Register);
   return result;
}

int Digit1(unsigned char Register)         // return nibble (digit 1)
{  int result;

   result = Register >> 4;
   result = Hex2ASCII(0x0F & result);
   return result;
}

int Hex2ASCII(int hex)        // hexadecimal to ASCII conversion
{  int result;

   if (hex<=9)
   {  result=hex+'0'; }       // convert number
   else
   {  result=hex+('A'-10); }  // convert letter

   return result;
}


//;--------------------------------------------------------------
//; This routine processes a received UART Command
void Process_UART(void)
{
  int   temp;         // Temporary variable
  unsigned int   parm;   //

  if (UART_Status & LineReceived)
  {
     //UARTSet
     switch (UART_RX_Buffer[0])
     {
       case 'S':
       //SetClock
         switch (UART_RX_Buffer[1])
         {
           case 'H':
               HOUR = GetBCDNumber(&UART_RX_Buffer[2]);
             break;
           case 'M':
               MIN = GetBCDNumber(&UART_RX_Buffer[2]);
             break;
           case 'S':
               SEC = GetBCDNumber(&UART_RX_Buffer[2]);
             break;
            case 'Y':
               YEAR = GetBCDNumber(&UART_RX_Buffer[2]);
             break;
           case 'O':
               MONTH = GetBCDNumber(&UART_RX_Buffer[2]);
             break;
           case 'D':
               DAY = GetBCDNumber(&UART_RX_Buffer[2]);
             break;

         case   'V':
            calVoltage = GetNumber(&UART_RX_Buffer[2]);
         case   'I':
            calCurrent = GetNumber(&UART_RX_Buffer[2]);

         case   'P':
            {
                unsigned int param = 0;
                unsigned int data = 0;
                unsigned int num = 2;
                param = GetNumberPos(&UART_RX_Buffer[num], &num);
                if (UART_RX_Buffer[num] == 0)
                {
                   data = read_parameter(param);
                   SendString("0x");
                   SendResult((unsigned char*) &data, 2);
                }
                else
                {
                   data = GetNumberPos(&UART_RX_Buffer[num], &num);
                   set_parameter(param, data);
                   _EINT();
                }
                SendString("\r");
            }

          default:
             break;
         }
         break;
#ifdef withDisplay
       case 'D':
           //SetDisplay_Mode
             LCDtext ((unsigned char *) "       ", LCD_SIZE, LCD_SIZE);  // Clear the display
        Display_Mode = GetNumber(&UART_RX_Buffer[1]);
        ModeSwitchDelay = 60;   // Stay in commanded display mode for 1 minute before auto-updating display mode
        Display_Hold = 2;   // Display units for 2 seconds before showing values
           break;

       case 'W':
      // Write to LCD display
        Display_Mode = display_msgin;
        strcpy(msgin, (char *)&UART_RX_Buffer[1]);
        ModeSwitchDelay = 60;   // Stay in commanded display mode for 1 minute before auto-updating display mode
           break;

#endif // withDisplay
       case 'H':
       //send help text
           SendString(txt_help);
         break;

       case 'T':
       //SetTX_Mode
           TX_Mode = GetNumber(&UART_RX_Buffer[1]);
         break;

       case 'Q':
       //Query
      temp= TX_Mode;         // Temporarily save TX_Mode
           TX_Mode = GetNumber(&UART_RX_Buffer[1]);
           SendData();
      TX_Mode = temp;         // Restore TX_Mode
         break;

       case 'V':
      //Value
           parm = GetNumber(&UART_RX_Buffer[1]);
           SendValue(parm);
         break;

       case 'R':
           WDTCTL =0;  // Generate WDT violation Reset
         break;

       case 'M':
       //SetMeasureMode
            TX_Mode = 0; //                  ; Clear running TX_Mode
            OP_Mode = request_cal;
            CalCyclCnt = defCalFreq*GetNumber(&UART_RX_Buffer[1]);    // Set Cycles
         break;

       case 'I':
       //Init
            _DINT(); // Disable Interrupts
            WDTCTL = WDTPW + WDTHOLD;             // Stop WDT
            // Init Digital Hardware
            init_system();
            // Init. FLL and clocks
            init_fll(10, defSystemFreq, 32);
           // Init. analog front-end (sigma-delta ADC)
            init_analog_front_end();
            // Init. Embedded Signal Processing parameters
            init_esp(1);
            // Init. event generation and start measurement
            start_measurement();
            _EINT(); // Enable Interrupts
         break;

#ifdef withCalibration
       case '+':
            CalPlus(Cal_Mode,GetBCDNumber(&UART_RX_Buffer[1]));
         break;

       case '-':
            CalMinus(Cal_Mode, GetBCDNumber(&UART_RX_Buffer[1]));
         break;

       case 'C':
       //Set Calibration mode
         {

            static char strbuf[20];

            _DINT(); // Disable Interrupts
         Cal_Mode = GetNumber(&UART_RX_Buffer[1]);
         SendString("Cal_Mode = ");
         SendFloat(Cal_Mode,0);
         SendString("\r");

         if (Cal_Mode == 0)
            {
            SendString("Start Calibration : expecting ");
            SendFloat(calVoltage,0); SendString("V / ");
            SendFloat(calCurrent,0); SendString("A / cosPhi = ");
            SendFloat(defCalCosPhi*1000,3); SendString("\r");

               SendString("Old Data : \r ");
               sprintf(strbuf, ldfs,(long) (s_parameters.VRatio*1000)); SendString(strbuf); SendChar('\r');
               sprintf(strbuf, ldfs,(long) (s_parameters.IRatio*1000)); SendString(strbuf); SendChar('\r');
               sprintf(strbuf, ldfs,(long) (s_parameters.EnergyRatio*1000)); SendString(strbuf); SendChar('\r');
               sprintf(strbuf, ldfs,(long) s_parameters.pSET_PHASECORR1); SendString(strbuf); SendChar('\r');
               sprintf(strbuf, ldfs,(long) s_parameters.pSET_PHASECORR2); SendString(strbuf); SendChar('\r');
         }

         UART_Status &= ~LineReceived;
         UART_RX_Bytes = 0;
         _EINT(); // Enable Interrupts

            CalMode(Cal_Mode);

            _DINT(); // Disable Interrupts

            if (Cal_Mode == 0)
            {
               SendString("Calibration Done\r");
               SendString("New Data : \r ");
               sprintf(strbuf, ldfs,(long) (s_parameters.VRatio*1000)); SendString(strbuf); SendChar('\r');
               sprintf(strbuf, ldfs,(long) (s_parameters.IRatio*1000)); SendString(strbuf); SendChar('\r');
               sprintf(strbuf, ldfs,(long) (s_parameters.EnergyRatio*1000)); SendString(strbuf); SendChar('\r');
               sprintf(strbuf, ldfs,(long) s_parameters.pSET_PHASECORR1); SendString(strbuf); SendChar('\r');
               sprintf(strbuf, ldfs,(long) s_parameters.pSET_PHASECORR2); SendString(strbuf); SendChar('\r');
            }
            if (Cal_Mode == 9) { SendString("Parameters saved\r"); }
         _EINT(); // Enable Interrupts
         }
         break;
#endif // withCalibration

     }

    UART_Status &= ~LineReceived;
    UART_RX_Bytes = 0;

  }
}
//No_Process_Uart
//        ret

#endif // withUARTComm