STM32F103 Sleep(WFI) & CAN

[Werner M. (snash)]

Hi!

Ich versuche derzeit (leider eher mehr schlecht als recht) den 
Sleep-Modus in mein aktuelles Programm zu integrieren. Um es 
übersichtlich zu gestalten habe ich für erste Tests derzeit nur die 
beiden wichtigsten Funktionen meines Codes in einen Testcode gepackt und 
per CubeMX mit HAL-Lib. umgesetzt - debounce von 1 Taster nach Peter 
Dannegger & darauf folgendes Versenden von Nachrichten über CAN. Der 
Sleep-Modus sollte immer nach Versenden der Nachricht aktiv, und erst 
bei Interrupt durch Tastendruck wieder deaktiviert werden.
Bei Tastendruck wird nur der Interrupt kurz aktiviert. Danach wird über 
den Systick Peter's Debounce-Routine durchlaufen. Wird ein Tastendruck 
(kurz oder lang) erkannt, wird eine entsprechende CAN-Nachricht 
verschickt, ein Flag gesetzt und der Sleep-Modus sollte wieder aktiviert 
werden.

Ohne Sleep funktioniert alles prima, jedoch springt mir das Programm bei 
integrierter Sleep-Funktion 
(HAL_PWR_EnterSLEEPMode(PWR_MAINREGULATOR_ON, PWR_SLEEPENTRY_WFI) immer 
wieder aus dem Sleep - scheint als würde nach dem Versenden der 
CAN-Nachricht noch ein Interrupt erfolgen (ACK?!), der den Sleep wieder 
deaktiviert. Ich bin hier leider etwas ratlos.
Hab hier zuletzt versucht über die HAL_CAN_TxMailbox0CompleteCallback 
(sowie für Mailbox 1 und 2) über ein Flag den Status des erledigten 
Versandes mit ins Programm zu integrieren, um erst danach den Sleep zu 
aktivieren. Klappt jedoch nicht. Ebenso, konnte ich in der IF-Abfrage 
vor dem Sleep diverse Interrupt-Flags nicht erfolgreich mit einbinden, 
bzw. habe hier eventuell das entsprechen notwendige vergessen.

Kann mir hier jemand eventuell weiterhelfen? Bin schon echt am 
verzweifeln und "doktor" hier schon seit Tagen herum.
Hier mein aktueller Code ->

#include "main.h"
#include "debounce.h"

CAN_HandleTypeDef hcan;
UART_HandleTypeDef huart2;

volatile uint8_t sleep_ok=1;

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_CAN_Init(void);

void CAN_Tx(uint8_t message[]);
void CAN_Filter_Config(void);


int main(void)
{
  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* Configure the system clock */
  SystemClock_Config();

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART2_UART_Init();
  MX_CAN_Init();

  CAN_Filter_Config();
  if(HAL_CAN_ActivateNotification(&hcan,CAN_IT_TX_MAILBOX_EMPTY|CAN_IT_RX_FIFO0_MSG_PENDING|CAN_IT_BUSOFF)!= HAL_OK)
  {
    Error_Handler();
  }

  if( HAL_CAN_Start(&hcan) != HAL_OK)
  {
    Error_Handler();
  }

  uint8_t message[3] = {'O','N','_'};
  CAN_Tx(message);


  while (1)
  {

        HAL_GPIO_WritePin(GPIOA,CH7_Pin,SET);  //Kontrolle µC on


    if(get_button_short(1<<Button1))
    {
      uint8_t message[3] = {'B','1','S'};
      CAN_Tx(message);
    }

    // Langer Tastendruck?
    if(get_button_long(1<<Button1))
    {
      uint8_t message[3] = {'B','1','L'};
      CAN_Tx(message);
    }


    if (sleep_ok == 1)
    {

      HAL_GPIO_WritePin(GPIOA,CH7_Pin,RESET);  //Kontrolle µC off

      HAL_GPIO_WritePin(GPIOA,CH6_Pin,SET);  //Kontrolle  sleep on

      HAL_SuspendTick();
      HAL_PWR_EnterSLEEPMode(PWR_MAINREGULATOR_ON, PWR_SLEEPENTRY_WFI);
      HAL_ResumeTick();

      HAL_GPIO_WritePin(GPIOA,CH6_Pin,RESET);  //Kontrolle sleep off

      sleep_ok = 0;
    }
  }
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /**Initializes the CPU, AHB and APB busses clocks 
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_BYPASS;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /**Initializes the CPU, AHB and APB busses clocks 
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @brief CAN Initialization Function
  * @param None
  * @retval None
  */
static void MX_CAN_Init(void)
{

  /* USER CODE BEGIN CAN_Init 0 */

  /* USER CODE END CAN_Init 0 */

  /* USER CODE BEGIN CAN_Init 1 */

  /* USER CODE END CAN_Init 1 */
  hcan.Instance = CAN1;
  hcan.Init.Prescaler = 18;
  hcan.Init.Mode = CAN_MODE_NORMAL;
  hcan.Init.SyncJumpWidth = CAN_SJW_1TQ;
  hcan.Init.TimeSeg1 = CAN_BS1_13TQ;
  hcan.Init.TimeSeg2 = CAN_BS2_2TQ;
  hcan.Init.TimeTriggeredMode = DISABLE;
  hcan.Init.AutoBusOff = ENABLE;
  hcan.Init.AutoWakeUp = DISABLE;
  hcan.Init.AutoRetransmission = ENABLE;
  hcan.Init.ReceiveFifoLocked = DISABLE;
  hcan.Init.TransmitFifoPriority = DISABLE;
  if (HAL_CAN_Init(&hcan) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN CAN_Init 2 */

  /* USER CODE END CAN_Init 2 */

}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOD_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOA, LD2_Pin|CH6_Pin|CH7_Pin|CH8_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin : B1_Pin */
  GPIO_InitStruct.Pin = B1_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(B1_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pins : LD2_Pin CH6_Pin CH7_Pin CH8_Pin */
  GPIO_InitStruct.Pin = LD2_Pin|CH6_Pin|CH7_Pin|CH8_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /* EXTI interrupt init*/
  HAL_NVIC_SetPriority(EXTI15_10_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);

}

void CAN_Filter_Config(void)
{
  CAN_FilterTypeDef can_filter_init;
  can_filter_init.FilterActivation = ENABLE;
  can_filter_init.FilterBank = 0;
  can_filter_init.FilterFIFOAssignment = CAN_RX_FIFO0;
  can_filter_init.FilterIdHigh = 0x0000;
  can_filter_init.FilterIdLow = 0x0000;
  can_filter_init.FilterMaskIdHigh = 0x0000;
  can_filter_init.FilterMaskIdLow = 0x0000;
  can_filter_init.FilterMode = CAN_FILTERMODE_IDMASK;
  can_filter_init.FilterScale = CAN_FILTERSCALE_32BIT;

  if( HAL_CAN_ConfigFilter(&hcan,&can_filter_init) != HAL_OK)
  {
    Error_Handler();
  }
}

void CAN_Tx(uint8_t message[])
{
  CAN_TxHeaderTypeDef TxHeader;

  uint32_t TxMailbox;

  TxHeader.DLC = 3;
  TxHeader.StdId = 0x125;
  TxHeader.IDE = CAN_ID_STD;
  TxHeader.RTR = CAN_RTR_DATA;

  if( HAL_CAN_AddTxMessage(&hcan,&TxHeader,message,&TxMailbox) != HAL_OK)
  {
    Error_Handler();
  }
}

void HAL_CAN_TxMailbox0CompleteCallback(CAN_HandleTypeDef *hcan)
{
  sleep_ok=1;
}

void HAL_CAN_TxMailbox1CompleteCallback(CAN_HandleTypeDef *hcan)
{
  sleep_ok=1;
}

void HAL_CAN_TxMailbox2CompleteCallback(CAN_HandleTypeDef *hcan)
{
  sleep_ok=1;
}


/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  
  /* USER CODE END Error_Handler_Debug */
}

[mts (Gast)]

sleep_ok = 0;
vor
HAL_SuspendTick();
ausführen?

[Dr. Sommer (Gast)]

Werner M. schrieb:
> scheint als würde nach dem Versenden der
> CAN-Nachricht noch ein Interrupt erfolgen (ACK?!), der den Sleep wieder
> deaktiviert.

Vermutlich aktiviert die HAL irgendwo den Transmit Complete Interrupt. 
WFI darf zu beliebigen Zeitpunkten beliebig aufwachen ("spurious 
wakeup"). Die Software muss damit klarkommen.

Sleep-Modi verwendet man grundsätzlich nicht "on demand" in einem 
linearen Programmablauf, sondern typischerweise direkt in einer 
Endlosschleife. In den ISRs reagiert man dann auf Ereignisse. Wenn die 
ISR zurückkehrt, wird sofort der Sleep-Modus reaktiviert. Wenn man in 
der main() selbst Ereignisse abarbeiten möchte - welche z.B. per Flag in 
der ISR gestartet werden, oder nach Abfrage von Peripherie-Bits - dann 
so:

int main () {
  // Initialisierung ...
  
  while (1) {
    if (ereignis1) behandlung1 ();
    if (ereignis2) behandlung2 ();
    // ...
    
    Sleep ();
  }
}

Wichtig ist dabei, abzufragen, ob etwas zu tun ist. Wenn nicht, wird 
Sleep direkt wieder betreten.

Man sollte sich nie darauf verlassen dass WFI nicht vor einem bestimmten 
Zeitpunkt zurückkehrt. Zwischendurch den Sleep aktivieren und wieder 
deaktivieren ist sehr untypisch. In deinem konkreten Fall würde ich es 
so machen:

* In der main() nur ein schlichtes "while (1) 
HAL_PWR_EnterSLEEPMode(...);" unterbringen, sodass der Sleep-Modus 
praktisch immer aktiv ist.
* Den SysTick immer aktiviert lassen. In dessen ISR die Entprellroutine 
laufen lassen, und abfragen ob ein Taster gedrückt wurde. Ist das der 
Fall, die gewünschte Nachricht absenden und eine Variable setzen, dass 
die Nachricht unterwegs ist. Solange das der Fall ist, weitere 
Tastendrücke ignorieren.
* Im Transmit Complete Interrupt die Variable zurücksetzen, sodass 
erneute Tastendrücke akzeptiert werden.

PS: In deinem Fall wird das Problem sein, dass die Interrupts während 
der HAL_PWR_EnterSLEEPMode kommen. Im Callback setzt du "sleep_ok=1". 
Nachdem HAL_PWR_EnterSLEEPMode zurückkehrt, setzt du direkt wieder 
"sleep_ok = 0;" und alles startet von vorne. Du hast hier praktisch Race 
Conditions. Das lässt sich zwar bestimmt irgendwie flicken - aber baue 
lieber die grundlegende Programmstruktur um (s.o.)!

Werner M. schrieb:
> Der
> Sleep-Modus sollte immer nach Versenden der Nachricht aktiv, und erst
> bei Interrupt durch Tastendruck wieder deaktiviert werden.

Das ist auch schon komisch - am Anfang willst du ohne Sleep-Modus auf 
Tastendrücke warten, aber nach dem Absenden der Nachricht dann mit 
Sleep-Modus?

[Dr. Sommer (Gast)]

PPS: Im ARMv7M Architecture Reference Manual heißt es auf S. B1-560:

Both WFI and WFE are hint instructions, that might have no effect on 
program execution. Normally, they are used in software idle loops that 
resume program execution only after an interrupt or event of interest 
occurs.
Note:
Code using WFE and WFI must handle any spurious wakeup event caused by a 
debug halt or other IMPLEMENTATION DEFINED reason. Applications must be 
aware that the architecture permits WFE, WFI, and SEV instructions to be 
implemented as NOPs.