Skip to content

Commit b915a8c

Browse files
warmonkeyfpistm
warmonkey
authored and
fpistm
committed
cdc_queue.cpp now use uint32_t length, which allows CDC_TRANSMIT_QUEUE_BUFFER_PACKET_NUMBER>512 or CDC_RECEIVE_QUEUE_BUFFER_PACKET_NUMBER>512.
1 parent ea174e6 commit b915a8c

File tree

4 files changed

+54
-49
lines changed

4 files changed

+54
-49
lines changed

Diff for: ‎libraries/USBDevice/inc/cdc_queue.h

+16-12
Original file line numberDiff line numberDiff line change
@@ -53,45 +53,49 @@ extern "C" {
5353
#else
5454
#define CDC_QUEUE_MAX_PACKET_SIZE USB_FS_MAX_PACKET_SIZE
5555
#endif
56+
57+
#define CDC_TRANSMIT_MAX_BUFFER_SIZE 65472 //STM32 USB OTG DIEPTSIZ PKTCNT maximum 0x3ff
58+
#define CDC_RECEIVE_MAX_BUFFER_SIZE CDC_QUEUE_MAX_PACKET_SIZE
59+
5660
#ifndef CDC_TRANSMIT_QUEUE_BUFFER_PACKET_NUMBER
5761
#define CDC_TRANSMIT_QUEUE_BUFFER_PACKET_NUMBER 2
5862
#endif
5963
#ifndef CDC_RECEIVE_QUEUE_BUFFER_PACKET_NUMBER
6064
#define CDC_RECEIVE_QUEUE_BUFFER_PACKET_NUMBER 3
6165
#endif
62-
#define CDC_TRANSMIT_QUEUE_BUFFER_SIZE ((uint16_t)(CDC_QUEUE_MAX_PACKET_SIZE * CDC_TRANSMIT_QUEUE_BUFFER_PACKET_NUMBER))
63-
#define CDC_RECEIVE_QUEUE_BUFFER_SIZE ((uint16_t)(CDC_QUEUE_MAX_PACKET_SIZE * CDC_RECEIVE_QUEUE_BUFFER_PACKET_NUMBER))
66+
#define CDC_TRANSMIT_QUEUE_BUFFER_SIZE (CDC_QUEUE_MAX_PACKET_SIZE * CDC_TRANSMIT_QUEUE_BUFFER_PACKET_NUMBER)
67+
#define CDC_RECEIVE_QUEUE_BUFFER_SIZE (CDC_QUEUE_MAX_PACKET_SIZE * CDC_RECEIVE_QUEUE_BUFFER_PACKET_NUMBER )
6468

6569
typedef struct {
6670
uint8_t buffer[CDC_TRANSMIT_QUEUE_BUFFER_SIZE];
67-
volatile uint16_t write;
68-
volatile uint16_t read;
69-
volatile uint16_t reserved;
71+
volatile uint32_t write;
72+
volatile uint32_t read;
73+
volatile uint32_t reserved;
7074
} CDC_TransmitQueue_TypeDef;
7175

7276
typedef struct {
7377
uint8_t buffer[CDC_RECEIVE_QUEUE_BUFFER_SIZE];
74-
volatile uint16_t write;
75-
volatile uint16_t read;
76-
volatile uint16_t length;
78+
volatile uint32_t write;
79+
volatile uint32_t read;
80+
volatile uint32_t length;
7781
} CDC_ReceiveQueue_TypeDef;
7882

7983
void CDC_TransmitQueue_Init(CDC_TransmitQueue_TypeDef *queue);
8084
int CDC_TransmitQueue_WriteSize(CDC_TransmitQueue_TypeDef *queue);
8185
int CDC_TransmitQueue_ReadSize(CDC_TransmitQueue_TypeDef *queue);
8286
void CDC_TransmitQueue_Enqueue(CDC_TransmitQueue_TypeDef *queue, const uint8_t *buffer, uint32_t size);
83-
uint8_t *CDC_TransmitQueue_ReadBlock(CDC_TransmitQueue_TypeDef *queue, uint16_t *size);
87+
uint8_t *CDC_TransmitQueue_ReadBlock(CDC_TransmitQueue_TypeDef *queue, uint32_t *size);
8488
void CDC_TransmitQueue_CommitRead(CDC_TransmitQueue_TypeDef *queue);
8589

8690
void CDC_ReceiveQueue_Init(CDC_ReceiveQueue_TypeDef *queue);
8791
int CDC_ReceiveQueue_ReadSize(CDC_ReceiveQueue_TypeDef *queue);
8892
int CDC_ReceiveQueue_Dequeue(CDC_ReceiveQueue_TypeDef *queue);
8993
int CDC_ReceiveQueue_Peek(CDC_ReceiveQueue_TypeDef *queue);
90-
uint16_t CDC_ReceiveQueue_Read(CDC_ReceiveQueue_TypeDef *queue, uint8_t *buffer, uint16_t size);
94+
uint32_t CDC_ReceiveQueue_Read(CDC_ReceiveQueue_TypeDef *queue, uint8_t *buffer, uint32_t size);
9195
bool CDC_ReceiveQueue_ReadUntil(CDC_ReceiveQueue_TypeDef *queue, uint8_t terminator, uint8_t *buffer,
92-
uint16_t size, uint16_t *fetched);
96+
uint32_t size, uint32_t *fetched);
9397
uint8_t *CDC_ReceiveQueue_ReserveBlock(CDC_ReceiveQueue_TypeDef *queue);
94-
void CDC_ReceiveQueue_CommitBlock(CDC_ReceiveQueue_TypeDef *queue, uint16_t size);
98+
void CDC_ReceiveQueue_CommitBlock(CDC_ReceiveQueue_TypeDef *queue, uint32_t size);
9599

96100
#ifdef __cplusplus
97101
}

Diff for: ‎libraries/USBDevice/src/USBSerial.cpp

+4-4
Original file line numberDiff line numberDiff line change
@@ -107,8 +107,8 @@ int USBSerial::read(void)
107107

108108
size_t USBSerial::readBytes(char *buffer, size_t length)
109109
{
110-
uint16_t read;
111-
auto rest = static_cast<uint16_t>(length);
110+
size_t read;
111+
size_t rest = length;
112112
_startMillis = millis();
113113
do {
114114
read = CDC_ReceiveQueue_Read(&ReceiveQueue, reinterpret_cast<uint8_t *>(buffer), rest);
@@ -124,8 +124,8 @@ size_t USBSerial::readBytes(char *buffer, size_t length)
124124

125125
size_t USBSerial::readBytesUntil(char terminator, char *buffer, size_t length)
126126
{
127-
uint16_t read;
128-
auto rest = static_cast<uint16_t>(length);
127+
size_t read;
128+
size_t rest = length;
129129
_startMillis = millis();
130130
do {
131131
bool found = CDC_ReceiveQueue_ReadUntil(&ReceiveQueue, static_cast<uint8_t>(terminator),

Diff for: ‎libraries/USBDevice/src/cdc/cdc_queue.c

+32-31
Original file line numberDiff line numberDiff line change
@@ -67,32 +67,33 @@ void CDC_TransmitQueue_Enqueue(CDC_TransmitQueue_TypeDef *queue,
6767
{
6868
uint32_t sizeToEnd = CDC_TRANSMIT_QUEUE_BUFFER_SIZE - queue->write;
6969
if (sizeToEnd > size) {
70-
memcpy(&queue->buffer[queue->write], &buffer[0], size);
70+
memcpy(queue->buffer + queue->write, buffer, size);
7171
} else {
72-
memcpy(&queue->buffer[queue->write], &buffer[0], sizeToEnd);
73-
memcpy(&queue->buffer[0], &buffer[sizeToEnd], size - sizeToEnd);
72+
memcpy(queue->buffer + queue->write, buffer, sizeToEnd);
73+
memcpy(queue->buffer, buffer + sizeToEnd, size - sizeToEnd);
7474
}
75-
queue->write = (uint16_t)((queue->write + size) %
76-
CDC_TRANSMIT_QUEUE_BUFFER_SIZE);
75+
queue->write = (queue->write + size) % CDC_TRANSMIT_QUEUE_BUFFER_SIZE;
7776
}
7877

7978
// Read flat block from queue biggest as possible, but max QUEUE_MAX_PACKET_SIZE
8079
uint8_t *CDC_TransmitQueue_ReadBlock(CDC_TransmitQueue_TypeDef *queue,
81-
uint16_t *size)
80+
uint32_t *size)
8281
{
8382
if (queue->write >= queue->read) {
8483
*size = queue->write - queue->read;
8584
} else {
8685
*size = CDC_TRANSMIT_QUEUE_BUFFER_SIZE - queue->read;
8786
}
87+
if(*size > CDC_TRANSMIT_MAX_BUFFER_SIZE)
88+
*size = CDC_TRANSMIT_MAX_BUFFER_SIZE;
89+
8890
queue->reserved = *size;
8991
return &queue->buffer[queue->read];
9092
}
9193

9294
void CDC_TransmitQueue_CommitRead(CDC_TransmitQueue_TypeDef *queue)
9395
{
94-
queue->read = (queue->read + queue->reserved) %
95-
CDC_TRANSMIT_QUEUE_BUFFER_SIZE;
96+
queue->read = (queue->read + queue->reserved) % CDC_TRANSMIT_QUEUE_BUFFER_SIZE;
9697
}
9798

9899
// Initialize read and write position of queue.
@@ -106,23 +107,23 @@ void CDC_ReceiveQueue_Init(CDC_ReceiveQueue_TypeDef *queue)
106107
// Reserve block in queue and return pointer to it.
107108
uint8_t *CDC_ReceiveQueue_ReserveBlock(CDC_ReceiveQueue_TypeDef *queue)
108109
{
109-
const uint16_t limit =
110-
CDC_RECEIVE_QUEUE_BUFFER_SIZE - CDC_QUEUE_MAX_PACKET_SIZE;
111-
volatile uint16_t read = queue->read;
110+
const uint32_t limit =
111+
CDC_RECEIVE_QUEUE_BUFFER_SIZE - CDC_RECEIVE_MAX_BUFFER_SIZE;
112+
volatile uint32_t read = queue->read;
112113

113114
if (read <= queue->write) {
114115
// if write is limited only by buffer size.
115116
if (queue->write < limit || (queue->write == limit && read > 0)) {
116117
// if size in the rest of buffer is enough for full packet plus 1 byte
117118
// or if it tight enough and write position can be set to 0
118119
return queue->buffer + queue->write;
119-
} else if (read > CDC_QUEUE_MAX_PACKET_SIZE) {
120+
} else if (read > CDC_RECEIVE_MAX_BUFFER_SIZE) {
120121
// if size in the rest is not enough, but enough size in head
121122
queue->length = queue->write;
122123
queue->write = 0;
123124
return queue->buffer + queue->write;
124125
}
125-
} else if (queue->write + CDC_QUEUE_MAX_PACKET_SIZE < read) {
126+
} else if (queue->write + CDC_RECEIVE_MAX_BUFFER_SIZE < read) {
126127
// write position must be less than read position
127128
// after reading largest possible packet
128129
return queue->buffer + queue->write;
@@ -132,7 +133,7 @@ uint8_t *CDC_ReceiveQueue_ReserveBlock(CDC_ReceiveQueue_TypeDef *queue)
132133

133134
// Commits block in queue and make it available for reading
134135
void CDC_ReceiveQueue_CommitBlock(CDC_ReceiveQueue_TypeDef *queue,
135-
uint16_t size)
136+
uint32_t size)
136137
{
137138
queue->write += size;
138139
if (queue->write >= queue->length) {
@@ -148,8 +149,8 @@ int CDC_ReceiveQueue_ReadSize(CDC_ReceiveQueue_TypeDef *queue)
148149
{
149150
// reading length after write make guarantee, that length >= write
150151
// and determined reading size will be smaller or equal than real one.
151-
volatile uint16_t write = queue->write;
152-
volatile uint16_t length = queue->length;
152+
volatile uint32_t write = queue->write;
153+
volatile uint32_t length = queue->length;
153154
if (write >= queue->read) {
154155
return write - queue->read;
155156
}
@@ -159,8 +160,8 @@ int CDC_ReceiveQueue_ReadSize(CDC_ReceiveQueue_TypeDef *queue)
159160
// Read one byte from queue.
160161
int CDC_ReceiveQueue_Dequeue(CDC_ReceiveQueue_TypeDef *queue)
161162
{
162-
volatile uint16_t write = queue->write;
163-
volatile uint16_t length = queue->length;
163+
volatile uint32_t write = queue->write;
164+
volatile uint32_t length = queue->length;
164165
if (queue->read == length) {
165166
queue->read = 0;
166167
}
@@ -177,8 +178,8 @@ int CDC_ReceiveQueue_Dequeue(CDC_ReceiveQueue_TypeDef *queue)
177178
// Peek byte from queue.
178179
int CDC_ReceiveQueue_Peek(CDC_ReceiveQueue_TypeDef *queue)
179180
{
180-
volatile uint16_t write = queue->write;
181-
volatile uint16_t length = queue->length;
181+
volatile uint32_t write = queue->write;
182+
volatile uint32_t length = queue->length;
182183
if (queue->read >= length) {
183184
queue->read = 0;
184185
}
@@ -188,12 +189,12 @@ int CDC_ReceiveQueue_Peek(CDC_ReceiveQueue_TypeDef *queue)
188189
return queue->buffer[queue->read];
189190
}
190191

191-
uint16_t CDC_ReceiveQueue_Read(CDC_ReceiveQueue_TypeDef *queue,
192-
uint8_t *buffer, uint16_t size)
192+
uint32_t CDC_ReceiveQueue_Read(CDC_ReceiveQueue_TypeDef *queue,
193+
uint8_t *buffer, uint32_t size)
193194
{
194-
volatile uint16_t write = queue->write;
195-
volatile uint16_t length = queue->length;
196-
uint16_t available;
195+
volatile uint32_t write = queue->write;
196+
volatile uint32_t length = queue->length;
197+
uint32_t available;
197198

198199
if (queue->read >= length) {
199200
queue->read = 0;
@@ -216,11 +217,11 @@ uint16_t CDC_ReceiveQueue_Read(CDC_ReceiveQueue_TypeDef *queue,
216217
}
217218

218219
bool CDC_ReceiveQueue_ReadUntil(CDC_ReceiveQueue_TypeDef *queue,
219-
uint8_t terminator, uint8_t *buffer, uint16_t size, uint16_t *fetched)
220+
uint8_t terminator, uint8_t *buffer, uint32_t size, uint32_t *fetched)
220221
{
221-
volatile uint16_t write = queue->write;
222-
volatile uint16_t length = queue->length;
223-
uint16_t available;
222+
volatile uint32_t write = queue->write;
223+
volatile uint32_t length = queue->length;
224+
uint32_t available;
224225

225226
if (queue->read >= length) {
226227
queue->read = 0;
@@ -235,10 +236,10 @@ bool CDC_ReceiveQueue_ReadUntil(CDC_ReceiveQueue_TypeDef *queue,
235236
}
236237

237238
uint8_t *start = &queue->buffer[queue->read];
238-
for (uint16_t i = 0; i < size; i++) {
239+
for (uint32_t i = 0; i < size; i++) {
239240
uint8_t ch = start[i];
240241
if (ch == terminator) {
241-
queue->read += (uint16_t)(i + 1);
242+
queue->read += (uint32_t)(i + 1);
242243
if (queue->read >= length) {
243244
queue->read = 0;
244245
}

Diff for: ‎libraries/USBDevice/src/cdc/usbd_cdc_if.c

+2-2
Original file line numberDiff line numberDiff line change
@@ -238,7 +238,7 @@ static int8_t USBD_CDC_Receive(uint8_t *Buf, uint32_t *Len)
238238
UNUSED(Buf);
239239
#endif
240240
/* It always contains required amount of free space for writing */
241-
CDC_ReceiveQueue_CommitBlock(&ReceiveQueue, (uint16_t)(*Len));
241+
CDC_ReceiveQueue_CommitBlock(&ReceiveQueue, *Len);
242242
receivePended = false;
243243
/* If enough space in the queue for a full buffer then continue receive */
244244
if (!CDC_resume_receive()) {
@@ -330,7 +330,7 @@ bool CDC_connected()
330330

331331
void CDC_continue_transmit(void)
332332
{
333-
uint16_t size;
333+
uint32_t size;
334334
uint8_t *buffer;
335335
USBD_CDC_HandleTypeDef *hcdc = (USBD_CDC_HandleTypeDef *) hUSBD_Device_CDC.pClassData;
336336
/*

0 commit comments

Comments
 (0)