Change C code to C++ in an embedded project

The following C code is in the main.c file of an embedded project on STM32CubeIDE.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <stdbool.h>
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
#define PRIMES_LEN 62
/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
UART_HandleTypeDef huart2;

/* USER CODE BEGIN PV */
uint16_t primes[PRIMES_LEN] = {0};
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART2_UART_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

bool is_prime(uint16_t v) {
	for(uint16_t i=2; i<(v/2+1); i++)
		if(v%i == 0) return false;
	return true;
}

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

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

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

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

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART2_UART_Init();
  /* USER CODE BEGIN 2 */

  uint16_t prime_index = 0;

  for(uint16_t i=2; i<300; ++i)
	  if(is_prime(i)) {
		  primes[prime_index] = i;
		  prime_index++;
	  }
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */

  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
    //Here's my new code that I've added to toggle the Green LED (LD2)
	  HAL_GPIO_TogglePin(LD2_GPIO_Port, LD2_Pin);
	  HAL_Delay(2000;
  }
  /* USER CODE END 3 */
}

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

  /** Configure the main internal regulator output voltage
  */
  __HAL_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  RCC_OscInitStruct.PLL.PLLM = 16;
  RCC_OscInitStruct.PLL.PLLN = 336;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV4;
  RCC_OscInitStruct.PLL.PLLQ = 4;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB buses 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 USART2 Initialization Function
  * @param None
  * @retval None
  */
static void MX_USART2_UART_Init(void)
{

  /* USER CODE BEGIN USART2_Init 0 */

  /* USER CODE END USART2_Init 0 */

  /* USER CODE BEGIN USART2_Init 1 */

  /* USER CODE END USART2_Init 1 */
  huart2.Instance = USART2;
  huart2.Init.BaudRate = 115200;
  huart2.Init.WordLength = UART_WORDLENGTH_8B;
  huart2.Init.StopBits = UART_STOPBITS_1;
  huart2.Init.Parity = UART_PARITY_NONE;
  huart2.Init.Mode = UART_MODE_TX_RX;
  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART2_Init 2 */

  /* USER CODE END USART2_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_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin, GPIO_PIN_RESET);

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

  /*Configure GPIO pin : LD2_Pin */
  GPIO_InitStruct.Pin = LD2_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(LD2_GPIO_Port, &GPIO_InitStruct);

}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @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 */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */ 

The lines below are added to the default state of this code to make the LED blink and it works on my board.

line 7: #include <stdbool.h>

line 12: #define PRIMES_LEN 62

line 28: uint16_t primes[PRIMES_LEN] = {0};

line 42:
1
2
3
4
5
bool is_prime(uint16_t v) {
	for(uint16_t i=2; i<(v/2+1); i++)
		if(v%i == 0) return false;
	return true;
}


line 81: uint16_t prime_index = 0;

line 83:
1
2
3
4
5
for(uint16_t i=2; i<300; ++i)
	  if(is_prime(i)) {
		  primes[prime_index] = i;
		  prime_index++;
	  }


line 99:
1
2
 HAL_GPIO_TogglePin(LD2_GPIO_Port, LD2_Pin);
	  HAL_Delay(2000);

I went for creating a similar project but this time using C++ as the language. Ergo, step forward to replace C code by C++ and then run the code on the board to see if that works or not. I started this way:
line 7: removed, since C++ doesn't need this header
line 12: const int PRIMES_LEN = 62

(Up to here, OK)
line 28: uint16_t primes[PRIME_LEN] = {0};
Here I get the following error for that line that I'm not sure I understand well.
error: variably modified 'primes' at file scope
28 | uint16_t primes[PRIME_LEN] = {0};


Any idea, please?
Last edited on
Check the spelling of the of the array size constant?

You mean PRIMES_LEN in const int PRIMES_LEN = 62; and uint16_t primes[PRIMES_LEN] = {0}; ? Are they not spelled right? Why, please?
I was looking a your last post, look at "line 28:". Even the error message says "[PRIME_LEN]".
for(uint16_t i=2; i<(v/2+1); i++)

The limit should be sqrt(v)

Consider v =1'000'000

The limit would be 1'000 not 500'000
@jib:
I might have used both PRIMES_LEN and PRIME_LEN, but both express the same error on that line as this:
../Core/Src/main.c:28:10: error: variably modified 'primes' at file scope
28 | uint16_t primes[PRIMES_LEN] = {0};


@TheIdeasMan,
I will take that into account when stepping through the current issue, thanks.
Last edited on
I should have said earlier, this method finding primes is horribly inefficient. Look up Sieves of Eratosthenes. Basically one needs to remove multiples of the primes that come before.

Here is some code by JLBorges:

http://coliru.stacked-crooked.com/a/bfbda98320d65f50
> ../Core/Src/main.c:28:10: error: variably modified 'primes' at file scope
You might be converting the code to C++, but the compiler still sees it as being C code.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
$ cat foo.c
const int SIZE = 10;
int array[SIZE];

int main()
{
    return 0;
}
$ # as C code
$ gcc foo.c
foo.c:2:5: error: variably modified ‘array’ at file scope
    2 | int array[SIZE];
      |     ^~~~~

$ # as C++ code
$ g++ foo.c

$ # Telling the C compiler that it's C++ code
$ gcc -x c++ foo.c

Either use the C++ compiler, or tell the C compiler (with -x c++) that this is C++ code.
Or change the file name to be main.cpp so the heuristic for figuring out the implied language works.

Last edited on
What is the purpose of the primes array, it doesn't seem to be used anywhere?
Thank you very much salem c. Your remark is right and worked.
Firstly I created a new C++ STM32 project using this tut: https://shawnhymel.com/1941/how-to-use-c-with-stm32cubeide/
Then added the lines this way this time:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <cmath>
//...
const int PRIMES_LEN = 62;
//...
uint16_t primes[PRIMES_LEN] = {0};
//...
bool is_prime(uint16_t v) {
	for(uint16_t i=2; i<=std::sqrt(v); i++)
		if(v%i == 0) return false;
	return true;
}
//...
uint16_t prime_index = 0;
for(uint16_t i=2; i<300; ++i) {
  if(is_prime(i)) {
   primes[prime_index] = i;
   prime_index++;
 }
}


And then the project ran successfully showing all prime numbers existing within that range.
Topic archived. No new replies allowed.