X-CUBE-SPN11 for X-NUCLEO-IHM11M1: UART_UI.c Source File

X-CUBE-SPN11 for X-NUCLEO-IHM11M1

 /**
  ******************************************************************************
  * @file UART_UI.c
  * @author IPC
  * @version V0
  * @date 10/07/2016
  * @brief This file provides a set of functions needed to manage the UART com.
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
  * 1. Redistributions of source code must retain the above copyright notice,
  * this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright notice,
  * this list of conditions and the following disclaimer in the documentation
  * and/or other materials provided with the distribution.
  * 3. Neither the name of STMicroelectronics nor the names of its contributors
  * may be used to endorse or promote products derived from this software
  * without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  ******************************************************************************
  */
 
 /* Includes ------------------------------------------------------------------*/
 #include "UART_UI.h"
 
 #ifdef UART_COMM 
 
 extern SIXSTEP_Base_InitTypeDef SIXSTEP_parameters; /*!< Main SixStep structure*/ 
 extern SIXSTEP_PI_PARAM_InitTypeDef_t PI_parameters; /*!< SixStep PI regulator structure*/ 
 extern uint8_t Enable_start_button;
 extern void CMD_Parser(char* pCommandString);
 extern void MC_Set_PI_param(SIXSTEP_PI_PARAM_InitTypeDef_t *);
 
 static uint16_t Uart_cmd_flag = 0;
 const CMD_T CmdTable[] = {
  {"STARTM", CMD_STARTM},
  {"STOPMT", CMD_STOPMT}, 
  {"DIRECT", CMD_DIRECTION}, 
  {"SETSPD", CMD_SETSPD}, 
  {"STATUS", CMD_STATUS}, 
  {"GETSPD", CMD_GETSPD}, 
  {"POTENZ", CMD_POTENZ}, 
  {"INIREF", CMD_INIREF}, 
  {"POLESP", CMD_POLESP}, 
  {"ACCELE", CMD_ACCELE}, 
  {"KP-PRM", CMD_KP_PRM}, 
  {"KI-PRM", CMD_KI_PRM}, 
  {"HELP", CMD_HELP}, 
  {"", NULL}
 };
 
 uint8_t BUFF_RCV = RXBUFFERSIZE;
 uint8_t aRxBuffer[8] = {'0'}; /*!< Buffer used for reception */
 uint8_t row0TxBuffer[] = "\033[2J"; /*!< Buffer used for transmission */
 uint8_t row1TxBuffer[] = "*******************************************************************************\n\r";
 uint8_t row2TxBuffer[] = "* X-NUCLEO-IHM11M1 - 6-Step Motor Control Expansion board *\n\r";
 uint8_t row3TxBuffer[] = "*******************************************************************************\n\r";
 uint8_t row4TxBuffer[] = " List of commands:\n\r\n\r";
 uint8_t row5TxBuffer[] = " <STARTM> -- Start Motor\n\r";
 uint8_t row6TxBuffer[] = " <STOPMT> -- Stop Motor\n\r";
 uint8_t row7aTxBuffer[] = " <DIRECT> -- Set the Motor direction CW or CCW \n\r";
 uint8_t row7TxBuffer[] = " <SETSPD> -- Set the Motor Speed\n\r";
 uint8_t row7bTxBuffer[] = " <GETSPD> -- Get the Motor Speed\n\r";
 uint8_t row7cTxBuffer[] = " <STATUS> -- Get the Status of system \n\r";
 uint8_t row71TxBuffer[] = " <POTENZ> -- Enable/Disable the potentiometer\n\r";
 uint8_t row71bTxBuffer[] = " <HELP> -- Show the help menu \n\r";
 uint8_t rowVTxBuffer[] = " >>> Insert the value: ";
 uint8_t rowVTBxBuffer[] = " >>> ENABLE <1> DISABLE <0>: ";
 uint8_t rowV1TBxBuffer[] = " >>> CW <0> CCW <1>: ";
 uint8_t rowMxBuffer[] = " >>> START MOTOR COMMAND RECEIVED ! <<< \n\r >";
 uint8_t rowSxBuffer[] = " >>> STOP MOTOR COMMAND RECEIVED ! <<< \n\r >";
 uint8_t rowETxBuffer[] = " >>> ERROR - PLEASE TYPE AGAIN ! <<< \n\r >";
 uint8_t row8TxBuffer[] = " ************* MAIN MOTOR PARAMETERS *************** \n\r";
 uint8_t row9TxBuffer[] = " <INIREF> -- Start-up current reference (0-4095) \n\r";
 uint8_t row10TxBuffer[] = " <ACCELE> -- Motor acceleration value during startup \n\r";
 uint8_t row11TxBuffer[] = " <POLESP> -- Set the Motor pole pairs \n\r";
 uint8_t row14TxBuffer[] = " ****** PI REGULATOR PARAMETERS - SPEED LOOP ******\n\r";
 uint8_t row15TxBuffer[] = " <KP-PRM> -- Set the PI proportional term \n\r";
 uint8_t row16TxBuffer[] = " <KI-PRM> -- Set the PI integral term \n\r\n\r >";
 uint8_t rowLxBuffer[] = " --- OK ---\n\r >";
 extern uint8_t UART_FLAG_RECEIVE;
 extern uint8_t UART_FLAG_POTENZ;
 
 
 /** @addtogroup MIDDLEWARES MIDDLEWARES 
  * @brief Middlewares Layer
  * @{ 
  */
 
 
 /** @addtogroup UART_UI UART_UI
  * @brief Serial communication through PC serial terminal
  * @{ 
  */
 
 
 /** @defgroup UART_Communication_Task UART_Communication_Task
  * @{
  * @brief UART start receive function
 */
 void UART_Communication_Task()
 { 
  if(HAL_UART_Receive_IT(&huart2, (uint8_t *)aRxBuffer, 10) != HAL_OK) 
  { huart2.State = HAL_UART_STATE_READY; }
  else UART_FLAG_RECEIVE = FALSE;
 }
 /**
  * @} 
  */
 
 /** @defgroup MC_UI_INIT MC_UI_INIT
  * @{
  * @brief UART User Interface init
 */
  void MC_UI_INIT()
  {
  HAL_UART_Transmit(&huart2, (uint8_t *)row0TxBuffer, (COUNTOF(row0TxBuffer) - 1),5000);
  while (HAL_UART_GetState(&huart2) != HAL_UART_STATE_READY)
  {
  } 
  HAL_UART_Transmit(&huart2, (uint8_t *)row1TxBuffer, (COUNTOF(row1TxBuffer) - 1),5000);
  while (HAL_UART_GetState(&huart2) != HAL_UART_STATE_READY)
  {
  } 
  HAL_UART_Transmit(&huart2, (uint8_t *)row2TxBuffer, (COUNTOF(row2TxBuffer) - 1),5000); 
  while (HAL_UART_GetState(&huart2) != HAL_UART_STATE_READY)
  {
  } 
  HAL_UART_Transmit(&huart2, (uint8_t *)row3TxBuffer, (COUNTOF(row3TxBuffer) - 1),5000);
  while (HAL_UART_GetState(&huart2) != HAL_UART_STATE_READY)
  {
  } 
  HAL_UART_Transmit(&huart2, (uint8_t *)row4TxBuffer, (COUNTOF(row4TxBuffer) - 1),5000); 
  while (HAL_UART_GetState(&huart2) != HAL_UART_STATE_READY)
  {
  } 
  HAL_UART_Transmit(&huart2, (uint8_t *)row5TxBuffer, (COUNTOF(row5TxBuffer) - 1),5000); 
  while (HAL_UART_GetState(&huart2) != HAL_UART_STATE_READY)
  {
  } 
  HAL_UART_Transmit(&huart2, (uint8_t *)row6TxBuffer, (COUNTOF(row6TxBuffer) - 1),5000); 
  while (HAL_UART_GetState(&huart2) != HAL_UART_STATE_READY)
  {
  } 
  HAL_UART_Transmit(&huart2, (uint8_t *)row7aTxBuffer, (COUNTOF(row7aTxBuffer) - 1),5000); 
  while (HAL_UART_GetState(&huart2) != HAL_UART_STATE_READY)
  {
  } 
  HAL_UART_Transmit(&huart2, (uint8_t *)row7TxBuffer, (COUNTOF(row7TxBuffer) - 1),5000); 
  while (HAL_UART_GetState(&huart2) != HAL_UART_STATE_READY)
  {
  }
  HAL_UART_Transmit(&huart2, (uint8_t *)row7bTxBuffer, (COUNTOF(row7bTxBuffer) - 1),5000); 
  while (HAL_UART_GetState(&huart2) != HAL_UART_STATE_READY)
  {
  } 
  HAL_UART_Transmit(&huart2, (uint8_t *)row7cTxBuffer, (COUNTOF(row7cTxBuffer) - 1),5000); 
  while (HAL_UART_GetState(&huart2) != HAL_UART_STATE_READY)
  {
  } 
  HAL_UART_Transmit(&huart2, (uint8_t *)row71TxBuffer, (COUNTOF(row71TxBuffer) - 1),5000);
  while (HAL_UART_GetState(&huart2) != HAL_UART_STATE_READY)
  {
  } 
  HAL_UART_Transmit(&huart2, (uint8_t *)row71bTxBuffer, (COUNTOF(row71bTxBuffer) - 1),5000);
  while (HAL_UART_GetState(&huart2) != HAL_UART_STATE_READY)
  {
  } 
  HAL_UART_Transmit(&huart2, (uint8_t *)row8TxBuffer, (COUNTOF(row8TxBuffer) - 1),5000); 
  while (HAL_UART_GetState(&huart2) != HAL_UART_STATE_READY)
  {
  } 
  HAL_UART_Transmit(&huart2, (uint8_t *)row9TxBuffer, (COUNTOF(row9TxBuffer) - 1),5000); 
  while (HAL_UART_GetState(&huart2) != HAL_UART_STATE_READY)
  {
  } 
  HAL_UART_Transmit(&huart2, (uint8_t *)row10TxBuffer, (COUNTOF(row10TxBuffer) - 1),5000); 
  while (HAL_UART_GetState(&huart2) != HAL_UART_STATE_READY)
  {
  } 
  HAL_UART_Transmit(&huart2, (uint8_t *)row11TxBuffer, (COUNTOF(row11TxBuffer) - 1),5000); 
  while (HAL_UART_GetState(&huart2) != HAL_UART_STATE_READY)
  {
  } 
  HAL_UART_Transmit(&huart2, (uint8_t *)row14TxBuffer, (COUNTOF(row14TxBuffer) - 1),5000); 
  while (HAL_UART_GetState(&huart2) != HAL_UART_STATE_READY)
  {
  }
  HAL_UART_Transmit(&huart2, (uint8_t *)row15TxBuffer, (COUNTOF(row15TxBuffer) - 1),5000); 
  while (HAL_UART_GetState(&huart2) != HAL_UART_STATE_READY)
  {
  } 
  HAL_UART_Transmit(&huart2, (uint8_t *)row16TxBuffer, (COUNTOF(row16TxBuffer) - 1),5000); 
  while (HAL_UART_GetState(&huart2) != HAL_UART_STATE_READY)
  {
  } 
  UART_Communication_Task();
  SIXSTEP_parameters.Button_ready = TRUE;
  }
 /**
  * @} 
  */
 
 
 /** @defgroup UART_num_decode UART_num_decode
  * @{
  * @brief UART Value decoding function
 */
 uint32_t UART_num_decode()
 {
  static char Value_Buffer[RXBUFFERSIZE];
  
  for(uint8_t i=0;i<BUFF_RCV;i++)
  {
  Value_Buffer[i] = aRxBuffer[i];
  }
 return(atoi(Value_Buffer));
 }
 /**
  * @} 
  */
 
 /** @defgroup UART_Set_Value UART_Set_Value
  * @{
  * @brief UART Main function
 */
 void UART_Set_Value()
 {
  if(Get_UART_Data() == 266 && (huart2.State != HAL_UART_STATE_BUSY_TX && huart2.State != HAL_UART_STATE_BUSY_TX_RX)) 
  {
  if(Uart_cmd_flag == 0)
  { 
  CMD_Parser((char*)aRxBuffer);
  }
  else 
  {
  SIXSTEP_parameters.Uart_value_to_set = UART_num_decode();
  
  switch(SIXSTEP_parameters.Uart_cmd_to_set) 
  {
  case SETSPD_CMD: /*!< Set the new speed value command received */
  PI_parameters.Reference = SIXSTEP_parameters.Uart_value_to_set;
  SIXSTEP_parameters.Ramp_Start = 1;
  BUFF_RCV = RXBUFFERSIZE; 
  Uart_cmd_flag = 0; 
  HAL_UART_Transmit(&huart2, (uint8_t *)rowLxBuffer, (COUNTOF(rowLxBuffer) - 1),5000); 
  UART_FLAG_RECEIVE = TRUE;
  huart2.State = HAL_UART_STATE_READY; 
  break;
  case INIREF_CMD: /*!< Set the new STARUP_CURRENT_REFERENCE value command received */ 
  SIXSTEP_parameters.Ireference = SIXSTEP_parameters.Uart_value_to_set; 
  SIXSTEP_parameters.pulse_value= SIXSTEP_parameters.Uart_value_to_set; 
  BUFF_RCV = RXBUFFERSIZE; 
  Uart_cmd_flag = 0; 
  huart2.State = HAL_UART_STATE_READY;
  HAL_UART_Transmit(&huart2, (uint8_t *)rowLxBuffer, (COUNTOF(rowLxBuffer) - 1),5000); 
  UART_FLAG_RECEIVE = TRUE; 
  break; 
  case POLESP_CMD: /*!< Set the Pole Pairs value command received */
  SIXSTEP_parameters.NUMPOLESPAIRS = SIXSTEP_parameters.Uart_value_to_set; 
  BUFF_RCV = RXBUFFERSIZE; 
  Uart_cmd_flag = 0; 
  huart2.State = HAL_UART_STATE_READY;
  HAL_UART_Transmit(&huart2, (uint8_t *)rowLxBuffer, (COUNTOF(rowLxBuffer) - 1),5000); 
  UART_FLAG_RECEIVE = TRUE;
  break; 
  case ACCELE_CMD: /*!< Set the Accelleration for Start-up of the motor command received */
  SIXSTEP_parameters.ACCEL = SIXSTEP_parameters.Uart_value_to_set; 
  BUFF_RCV = RXBUFFERSIZE; 
  Uart_cmd_flag = 0; 
  huart2.State = HAL_UART_STATE_READY;
  HAL_UART_Transmit(&huart2, (uint8_t *)rowLxBuffer, (COUNTOF(rowLxBuffer) - 1),5000); 
  UART_FLAG_RECEIVE = TRUE;
  break; 
  case DIRECT_CMD: /*!< Set the motor direction */
  SIXSTEP_parameters.CW_CCW = SIXSTEP_parameters.Uart_value_to_set; 
  MC_Set_PI_param(&PI_parameters); 
  BUFF_RCV = RXBUFFERSIZE; 
  Uart_cmd_flag = 0; 
  huart2.State = HAL_UART_STATE_READY;
  HAL_UART_Transmit(&huart2, (uint8_t *)rowLxBuffer, (COUNTOF(rowLxBuffer) - 1),5000); 
  UART_FLAG_RECEIVE = TRUE;
  break; 
  case KP_PRM_CMD: /*!< Set the KP PI param command received */
  PI_parameters.Kp_Gain = SIXSTEP_parameters.Uart_value_to_set; 
  BUFF_RCV = RXBUFFERSIZE; 
  Uart_cmd_flag = 0; 
  huart2.State = HAL_UART_STATE_READY;
  HAL_UART_Transmit(&huart2, (uint8_t *)rowLxBuffer, (COUNTOF(rowLxBuffer) - 1),5000); 
  UART_FLAG_RECEIVE = TRUE;
  break; 
  case KI_PRM_CMD: /*!< Set the KI PI param command received */
  PI_parameters.Ki_Gain = SIXSTEP_parameters.Uart_value_to_set; 
  BUFF_RCV = RXBUFFERSIZE; 
  Uart_cmd_flag = 0; 
  huart2.State = HAL_UART_STATE_READY;
  HAL_UART_Transmit(&huart2, (uint8_t *)rowLxBuffer, (COUNTOF(rowLxBuffer) - 1),5000); 
  UART_FLAG_RECEIVE = TRUE;
  break; 
  case POTENZ_CMD: /*!< Enable Potentiometer command received */
  BUFF_RCV = RXBUFFERSIZE; 
  Uart_cmd_flag = 0; 
  huart2.State = HAL_UART_STATE_READY;
  HAL_UART_Transmit(&huart2, (uint8_t *)rowLxBuffer, (COUNTOF(rowLxBuffer) - 1),5000); 
  UART_FLAG_RECEIVE = TRUE;
  SIXSTEP_parameters.Potentiometer = SIXSTEP_parameters.Uart_value_to_set; 
  break;
  } /* switch case */
  } /* else */
  } /* if */ 
 }
 /**
  * @} 
  */
 
  
 /** @defgroup CMD_MSG CMD_MSG
  * @{
  * @brief UART Transmit standard message
 */
 void CMD_MSG()
 {
  HAL_UART_Transmit(&huart2, (uint8_t *)rowVTxBuffer, (COUNTOF(rowVTxBuffer) - 1),5000);
  BUFF_RCV = RXBUFFERSIZE - 1;
  Uart_cmd_flag = 1;
  UART_FLAG_RECEIVE = TRUE; 
  huart2.State = HAL_UART_STATE_READY; 
 }
 /**
  * @} 
  */
 
 /** @defgroup CMD_MSG_BOOL CMD_MSG_BOOL
  * @{
  * @brief UART Transmit standard message for input data
 */
 void CMD_MSG_BOOL()
 {
  huart2.State = HAL_UART_STATE_READY;
  HAL_UART_Transmit(&huart2, (uint8_t *)rowVTBxBuffer, (COUNTOF(rowVTBxBuffer) - 1),5000);
  BUFF_RCV = RXBUFFERSIZE - 1; 
  Uart_cmd_flag = 1;
  UART_FLAG_RECEIVE = TRUE; 
 }
 /**
  * @} 
  */
 
 /** @defgroup CMD_MSG_BOOL_DIRECT CMD_MSG_BOOL_DIRECT
  * @{
  * @brief UART Transmit CW or CCW message for input data
 */ 
 void CMD_MSG_BOOL_DIRECT()
 {
  huart2.State = HAL_UART_STATE_READY;
  HAL_UART_Transmit(&huart2, (uint8_t *)rowV1TBxBuffer, (COUNTOF(rowV1TBxBuffer) - 1),5000);
  BUFF_RCV = RXBUFFERSIZE - 1; 
  Uart_cmd_flag = 1;
  UART_FLAG_RECEIVE = TRUE; 
 }
 /**
  * @} 
  */
 
 /** @defgroup CMD_STARTM CMD_STARTM
  * @{
  * @brief UART Transmit Start motor message 
 */ 
 void CMD_STARTM()
 { 
  /*!< Start Motor command received */
  huart2.State = HAL_UART_STATE_READY; 
  HAL_UART_Transmit(&huart2, (uint8_t *)rowMxBuffer, (COUNTOF(rowMxBuffer) - 1),5000); 
  MC_StartMotor();
  Enable_start_button = FALSE; 
  UART_FLAG_RECEIVE = TRUE; 
 }
 /**
  * @} 
  */
 
 /** @defgroup CMD_STOPMT CMD_STOPMT
  * @{
  * @brief UART Transmit Stop motor message 
 */
 void CMD_STOPMT()
 { 
  /*!< Stop Motor command received */
  huart2.State = HAL_UART_STATE_READY; 
  HAL_UART_Transmit(&huart2, (uint8_t *)rowSxBuffer, (COUNTOF(rowSxBuffer) - 1),5000); 
  MC_StopMotor();
  Enable_start_button = FALSE; 
  UART_FLAG_RECEIVE = TRUE; 
 }
 /**
  * @} 
  */
 
 /** @defgroup CMD_SETSPD CMD_SETSPD
  * @{
  * @brief UART Change the motor speed 
 */ 
 void CMD_SETSPD()
 { 
  /*!< Set the new speed value command received */
  CMD_MSG();
  SIXSTEP_parameters.Uart_cmd_to_set = SETSPD_CMD;
 }
 /**
  * @} 
  */
 
 /** @defgroup CMD_GETSPD CMD_GETSPD
  * @{
  * @brief UART Get the motor speed 
 */
 void CMD_GETSPD()
 { 
  /*!< Get Mechanical Motor Speed command received */ 
  static char strLineMessage[40];
 
  huart2.State = HAL_UART_STATE_READY; 
  sprintf(strLineMessage, "-- The Motor Speed is: %d RPM -- \r\n >", SIXSTEP_parameters.speed_fdbk_filtered); 
  HAL_UART_Transmit(&huart2, (uint8_t*) strLineMessage,sizeof(strLineMessage),5000); 
  UART_FLAG_RECEIVE = TRUE; 
 }
 /**
  * @} 
  */
 
 /** @defgroup CMD_POTENZ CMD_POTENZ
  * @{
  * @brief UART Enable the potentiometer
 */ 
 void CMD_POTENZ()
 { 
  /*!< Enable Potentiometer command received */
  CMD_MSG_BOOL();
  SIXSTEP_parameters.Uart_cmd_to_set = POTENZ_CMD;
 }
 /**
  * @} 
  */
 
 /** @defgroup CMD_HELP CMD_HELP
  * @{
  * @brief UART Help command
 */ 
 void CMD_HELP()
 {
  /*!< Help command received */
  huart2.State = HAL_UART_STATE_READY; 
  MC_UI_INIT(); 
  UART_FLAG_RECEIVE = TRUE; 
 } 
 /**
  * @} 
  */
 
 
 /** @defgroup CMD_INIREF CMD_INIREF
  * @{
  * @brief UART Set the current reference
 */
 void CMD_INIREF()
 {
  /*!< Set the new STARUP_CURRENT_REFERENCE value command received */
  CMD_MSG();
  SIXSTEP_parameters.Uart_cmd_to_set = INIREF_CMD;
 }
 /**
  * @} 
  */
 
 
 /** @defgroup CMD_POLESP CMD_POLESP
  * @{
  * @brief UART Set the motor poles pairs
 */
 void CMD_POLESP()
 {
  /*!< Set the Pole Pairs value command received */
  CMD_MSG();
  SIXSTEP_parameters.Uart_cmd_to_set = POLESP_CMD; 
 }
 /**
  * @} 
  */
 
 /** @defgroup CMD_ACCELE CMD_ACCELE
  * @{
  * @brief UART Set the accelleration of the motor at start-up
 */
 void CMD_ACCELE()
 {
  /*!< Set the Accelleration for Start-up of the motor command received */ 
  CMD_MSG();
  SIXSTEP_parameters.Uart_cmd_to_set = ACCELE_CMD; 
 }
 /**
  * @} 
  */
 
 /** @defgroup CMD_DIRECTION CMD_DIRECTION
  * @{
  * @brief UART Set the motor direction
 */
 void CMD_DIRECTION()
 { 
  /*!< Enable the DEMAG dynamic control command received */
  CMD_MSG_BOOL_DIRECT();
  SIXSTEP_parameters.Uart_cmd_to_set = DIRECT_CMD; 
 }
 /**
  * @} 
  */
 
 /** @defgroup CMD_KP_PRM CMD_KP_PRM
  * @{
  * @brief UART Set the KP PI param
 */
 void CMD_KP_PRM()
 { 
  /*!< Set the KP PI param command received */ 
  CMD_MSG();
  SIXSTEP_parameters.Uart_cmd_to_set = KP_PRM_CMD; 
 }
 /**
  * @} 
  */
 
 /** @defgroup CMD_KI_PRM CMD_KI_PRM
  * @{
  * @brief UART Set the KI PI param
 */
 void CMD_KI_PRM()
 { 
  /*!< Set the KI PI param command received */ 
  CMD_MSG();
  SIXSTEP_parameters.Uart_cmd_to_set = KI_PRM_CMD; 
 }
 /**
  * @} 
  */
 
 /** @defgroup CMD_STATUS CMD_STATUS
  * @{
  * @brief UART View the STATUS
 */
 void CMD_STATUS()
 {
  static char strLineMessage1[30];
  static char strLineMessage2[30];
  static char strLineMessage3[30];
  static char strLineMessage4[30];
  static char strLineMessage5[30];
  static char strLineMessage6[30]; 
  static char strLineMessage7[30];
  static char strLineMessage8[30]; 
  
  huart2.State = HAL_UART_STATE_READY; 
  switch (SIXSTEP_parameters.STATUS)
  {
  case STARTUP:
  sprintf(strLineMessage1, " -- The status is: STARTUP --\r\n >");
  HAL_UART_Transmit(&huart2, (uint8_t*) strLineMessage1,sizeof(strLineMessage1),5000); 
  break; 
  case VALIDATION:
  sprintf(strLineMessage2, " -- The status is: VALIDATION --\r\n >");
  HAL_UART_Transmit(&huart2, (uint8_t*) strLineMessage2,sizeof(strLineMessage2),5000); 
  break;
  case START:
  sprintf(strLineMessage3, " -- The status is: START --\r\n >");
  HAL_UART_Transmit(&huart2, (uint8_t*) strLineMessage3,sizeof(strLineMessage3),5000); 
  break;
  case STOP: 
  sprintf(strLineMessage4, " -- The status is: STOP --\r\n >");
  HAL_UART_Transmit(&huart2, (uint8_t*) strLineMessage4,sizeof(strLineMessage4),5000); 
  break; 
  case RUN: 
  sprintf(strLineMessage5, " -- The status is: RUN --\r\n >");
  HAL_UART_Transmit(&huart2, (uint8_t*) strLineMessage5,sizeof(strLineMessage5),5000); 
  break; 
  case ALIGNMENT: 
  sprintf(strLineMessage6, " -- The status is: ALIGNMENT --\r\n >");
  HAL_UART_Transmit(&huart2, (uint8_t*) strLineMessage6,sizeof(strLineMessage6),5000); 
  break; 
  case SPEEDFBKERROR: 
  sprintf(strLineMessage7, " -- The status is: SPEEDFBKERROR --\r\n >");
  HAL_UART_Transmit(&huart2, (uint8_t*) strLineMessage7,sizeof(strLineMessage7),5000); 
  break; 
  default:
  sprintf(strLineMessage8, " -- The status is: IDLE --\r\n >");
  HAL_UART_Transmit(&huart2, (uint8_t*) strLineMessage8,sizeof(strLineMessage8),5000); 
  break; 
  }
  UART_FLAG_RECEIVE = TRUE; 
 }
 /**
  * @} 
  */
 
 /** @defgroup CMD_Parser CMD_Parser
  * @{
  * @brief UART String parser 
 */
 void CMD_Parser(char* pCommandString)
 {
  static uint8_t CmdListIndex;
  char sCmd[16];
  #define TOKEN2 "\n"
  
  strcpy(sCmd, pCommandString);
  strtok (sCmd, TOKEN);
  strtok (sCmd, TOKEN2);
  
  /* Command Callback identification */
  for(CmdListIndex=0;CmdTable[CmdListIndex].pCmdFunc!=NULL; CmdListIndex++) {
  if (strcmp(CmdTable[CmdListIndex].name, sCmd) == 0 )
  {
  break;
  }
  }
  if ( CmdListIndex < CMD_NUM ){
  // CMD OK --> extract parameters
  /* Check for valid callback */
  if(CmdTable[CmdListIndex].pCmdFunc!=NULL) {
  CmdTable[CmdListIndex].pCmdFunc();
  }
  }
  else{
  huart2.State = HAL_UART_STATE_READY;
  HAL_UART_Transmit(&huart2, (uint8_t *)rowETxBuffer, (COUNTOF(rowETxBuffer) - 1),5000); 
  BUFF_RCV = RXBUFFERSIZE; 
  Uart_cmd_flag = 0; 
  UART_FLAG_RECEIVE = TRUE; 
  return;
  }
 }
 
 /**
  * @} 
  */
 
 
 /**
  * @} end UART_UI 
  */
 
 /**
  * @} end MIDDLEWARES
  */
 #endif
Generated by
1.8.11
previous page start next page