Was ist der korrekte Weg, um Slave I2C mit FreeRTOS auf STM32 zu erstellen?

Question

Ich bin neu in ARM und versuche, Slave-Gerät auf STM32F103x zu erstellen. Ich brauche auch Serial Wire Debugging und FreeRTOS Tasking.

Ich erstelle ein neues Projekt von STM32CubeMX. Es gibt Optionen für "FreeRTOS-Funktionen verwenden" in der NVIC-Konfiguration. Aber ich habe keine Dokumentation, Referenzen oder Demos darüber gefunden, wie man das benutzt.

EDIT 1: Also mache ich in einer solchen Art und Weise für jetzt:

#include <string.h> 

#define MASTER_REQ_READ 0x44 
#define MASTER_REQ_EXEC 0x34 

#define CONN_Pin GPIO_PIN_13 
#define CONN_GPIO_Port GPIOC 

/* Recieve protocol struct from Main controller */ 
struct saatProtoExec { 
    uint8_t target; 
    uint8_t command; 
} execCommand; 

uint8_t execBufferSize = sizeof(execCommand); 


int main(void) 
{ 
    /*******************************/ 

    /* definition and creation of i2cWait */ 
    osThreadDef(i2cWait, i2cWaitForData, osPriorityRealtime, 0, 128); 
    i2cWaitHandle = osThreadCreate(osThread(i2cWait), NULL); 

    osKernelStart(); 
    /* We should never get here as control is now taken by the scheduler */ 

    /* Infinite loop */ 
    while (1) 
    { 
    } 

} 

/* i2cWaitForData function */ 
void i2cWaitForData(void const * argument) 
{ 
    /* Infinite loop */ 
    for(;;) 
    { 
     while(HAL_I2C_Slave_Receive_IT(&hi2c1, (uint8_t*)&bTransferRequest, 1)!= HAL_OK) 
     { 
      vTaskDelay(1); 
     } 

     /* Wait for I2C to get ready */ 
     while (HAL_I2C_GetState(&hi2c1) != HAL_I2C_STATE_READY) 
     { 
      vTaskDelay(1); 
     } 

     /* Got command from main controller */ 
     if (bTransferRequest == MASTER_REQ_EXEC) 
     { 
      /* Recieve buffer */ 
      uint8_t execRxBuffer[execBufferSize]; 
      printf("EXEC BUFFER SIZE %d\n", execBufferSize); 

      /* Got data */ 
      while(HAL_I2C_Slave_Receive_IT(&hi2c1, (uint8_t*)execRxBuffer, execBufferSize)!= HAL_OK); 

      /* Wait for I2C to get ready */ 
      while (HAL_I2C_GetState(&hi2c1) != HAL_I2C_STATE_READY) 
      { 
       vTaskDelay(1); 
      } 

      /* Lets print recieved RAW data */ 
      for (uint8_t k = 0; k < sizeof(execRxBuffer); k++){ 
       printf("0x%X\n", execRxBuffer[k]); 
      } 

      /* Lets combine recieved data to owr struct */ 
      memcpy(&execCommand, execRxBuffer, execBufferSize); 

      /* Lets print data from struct */ 
      printf("TARGET: 0x%X\n", execCommand.target); 
      printf("COMMAND: %u\n", execCommand.command); 

      /* Flush Rx buffers */ 
      Flush_Buffer((uint8_t*)execRxBuffer, execBufferSize); 

      /* Toggle LED2 */ 
      HAL_GPIO_TogglePin(CONN_GPIO_Port, CONN_Pin); 

     } 

     osDelay(1); 
    } 
} 

Es funktioniert gut in nicht-blockierenden Modus, aber trotzdem: ist es richtig, dies zu tun? Oder wäre es richtig, Semaphoren zu verwenden?

Answer 1

Ich kann dieses Benutzerhandbuch empfehlen: Developing Applications on STM32Cube with RTOS.

Es hat eine Beschreibung über FreeRTOS folgenden Punkten zu:

• Freie RTOS Source-Organisationen
• Portierungs FreeRTOS auf STM32
• FreeRTOS API
• FreeRTOS Speicherverwaltung
• FreeRTOS Low-Power-
• FreeRTOS-Konfiguration

Auch hat es Anwendungsbeispiele der Hauptbetriebssystemfunktionen:

• Thread-Erzeugung Beispiel
• Semaphores Beispiel (zwischen Threads, von ISR)
• Mutexes Beispiel
• Queues Beispiel
• Timer Beispiel
• Beispiel für eine niedrige Leistung

Es ist ein Beispiel Projekt über Thread-Erzeugung in dem unter STM32CubeF1 Paket bereitgestellt:

\STM32Cube_FW_F1_V1.4.0\Projects\STM32F103RB-Nucleo\Applications\FreeRTOS\FreeRTOS_ThreadCreation 

Dieses Beispiel verwendet eine STM32F103RB.