Hello again everyone,
I managed to achieve my goals regarding speed. I believe I understand what is happening better now.
> The maximum you may easily get should be close to 64 kB/s.
This is not true. The way you get more than that is easy: just call CDC_Transmit_FS(buf, 512) for example. This way, the STM32 puts as many 64 byte "bulk transfer packets" (out of the 512) as it can in the next available frame. The limit you were describing, of 64kB/s, is if only a single 64byte bulk transfer happens per frame. As waclawek.jan said, this is not the limit, and you can keep putting the 64 byte bulk transfer packets on the frame (up until around its 1024 byte max).
Now, the key for the CDC_Transmit_FS(buf, 512) call to put as many packets in the next frame is simple: the USB CDC Tx Buffer Size parameter matters. It actually (from what my results show) tells the function when to start pushing packets to the queue. Therefore, to acheive MAXIMUM CDC SPEED, this value should be the minimum 64 bytes. Otherwise, it calling CDC_Transmit_FS(buf, 512) with USB CDC Tx Buffer Size=1024 doesn's transmit anything, only when called for the second time it would transmit.
I did a double buffering technique using a ISR to transmit and sample concurrently, at 12.5us sampling period. Here is the code:
#define USB_BUFFER_SIZE 256
volatile uint8_t bufferA[USB_BUFFER_SIZE];
volatile uint8_t bufferB[USB_BUFFER_SIZE];
volatile uint8_t* currentBuffer = bufferA;
volatile uint8_t* transmitBuffer = NULL;
volatile int bufferIndex = 0;
volatile uint8_t bufferReady = 0;
void ISR_Sampler() {
// Sample the pin
uint8_t pin_state = HAL_GPIO_ReadPin(GPIOA, GDO0_Pin);
// Store in the current buffer
currentBuffer[bufferIndex] = pin_state ? 124 : 48;
// Increment buffer index and check if full
bufferIndex++;
if (bufferIndex >= USB_BUFFER_SIZE) {
// Swap buffers
transmitBuffer = currentBuffer;
currentBuffer = (currentBuffer == bufferA) ? bufferB : bufferA;
bufferIndex = 0;
bufferReady = 1;
}
}
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim){
if(htim == &htim2){
ISR_Sampler();
}
}
int main(void)
{
(...)
else if(buffer[0] == 'c' && buffer[1] == 'o' && buffer[2] == 'n' && buffer[3] == 't'){ //init Tx values, exept modulation and bitrate
initRxContinuous();
HAL_TIM_Base_Start_IT(&htim2);
while(!(buffer[0] == 's')){
if (bufferReady == 1) {
CDC_Transmit_FS((uint8_t*)transmitBuffer, USB_BUFFER_SIZE);
bufferReady = 0;
}
}
HAL_TIM_Base_Stop_IT(&htim2);
ConfigureGDO0Pin(GDO_OUTPUT);
HAL_GPIO_WritePin(GPIOA, GDO0_Pin, 0);
clearBuffer(6);
}
(...)
}
static void MX_TIM2_Init(void)
{
/* USER CODE BEGIN TIM2_Init 0 */
/* USER CODE END TIM2_Init 0 */
TIM_ClockConfigTypeDef sClockSourceConfig = {0};
TIM_MasterConfigTypeDef sMasterConfig = {0};
/* USER CODE BEGIN TIM2_Init 1 */
/* USER CODE END TIM2_Init 1 */
htim2.Instance = TIM2;
htim2.Init.Prescaler = 0;
htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
htim2.Init.Period = 600-1.;
htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
{
Error_Handler();
}
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
{
Error_Handler();
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN TIM2_Init 2 */
/* USER CODE END TIM2_Init 2 */
}The device receiving the USB serial communication is an Andoid Phone. Here is the graph it plots, sampling a signal (this part of the signal is the preamble) with bit pulse width of 400us:
I'm very pleased with these results, as I was starting to think an Arduino Uno was faster at serial communication than a STM32F042F6P6.
The resulting baud rate is: 8*(1/12.5us)=640000 baud
Although I would be capable of transmitting (sampling) even faster. I was sending 256 bytes per frame. That is a limit of ~2Mbaud in theory, until the CDC_Transmit returns BUSY. And I could have pushed it further towards the 1MB/s limit of USB FS, that is util my 48MHz clock gives out. But my requirements were met, I surpassed the 26us resolution of the Arduino UNO.
