Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commit66c8c0a

Browse files
warmonkeyfpistm
authored andcommitted
chore(usb): cdc_queue now use uint32_t length
which allows CDC_TRANSMIT_QUEUE_BUFFER_PACKET_NUMBER>512 orCDC_RECEIVE_QUEUE_BUFFER_PACKET_NUMBER>512.Signed-off-by: warmonkey <luoshumymail@gmail.com>
1 parent021d321 commit66c8c0a

File tree

4 files changed

+55
-49
lines changed

4 files changed

+55
-49
lines changed

‎libraries/USBDevice/inc/cdc_queue.h

Lines changed: 16 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -53,45 +53,49 @@ extern "C" {
5353
#else
5454
#defineCDC_QUEUE_MAX_PACKET_SIZE USB_FS_MAX_PACKET_SIZE
5555
#endif
56+
57+
#defineCDC_TRANSMIT_MAX_BUFFER_SIZE 65472 //STM32 USB OTG DIEPTSIZ PKTCNT maximum 0x3ff
58+
#defineCDC_RECEIVE_MAX_BUFFER_SIZE CDC_QUEUE_MAX_PACKET_SIZE
59+
5660
#ifndefCDC_TRANSMIT_QUEUE_BUFFER_PACKET_NUMBER
5761
#defineCDC_TRANSMIT_QUEUE_BUFFER_PACKET_NUMBER 2
5862
#endif
5963
#ifndefCDC_RECEIVE_QUEUE_BUFFER_PACKET_NUMBER
6064
#defineCDC_RECEIVE_QUEUE_BUFFER_PACKET_NUMBER 3
6165
#endif
62-
#defineCDC_TRANSMIT_QUEUE_BUFFER_SIZE ((uint16_t)(CDC_QUEUE_MAX_PACKET_SIZE * CDC_TRANSMIT_QUEUE_BUFFER_PACKET_NUMBER))
63-
#defineCDC_RECEIVE_QUEUE_BUFFER_SIZE((uint16_t)(CDC_QUEUE_MAX_PACKET_SIZE * CDC_RECEIVE_QUEUE_BUFFER_PACKET_NUMBER))
66+
#defineCDC_TRANSMIT_QUEUE_BUFFER_SIZE (CDC_QUEUE_MAX_PACKET_SIZE * CDC_TRANSMIT_QUEUE_BUFFER_PACKET_NUMBER)
67+
#defineCDC_RECEIVE_QUEUE_BUFFER_SIZE (CDC_QUEUE_MAX_PACKET_SIZE * CDC_RECEIVE_QUEUE_BUFFER_PACKET_NUMBER)
6468

6569
typedefstruct {
6670
uint8_tbuffer[CDC_TRANSMIT_QUEUE_BUFFER_SIZE];
67-
volatileuint16_twrite;
68-
volatileuint16_tread;
69-
volatileuint16_treserved;
71+
volatileuint32_twrite;
72+
volatileuint32_tread;
73+
volatileuint32_treserved;
7074
}CDC_TransmitQueue_TypeDef;
7175

7276
typedefstruct {
7377
uint8_tbuffer[CDC_RECEIVE_QUEUE_BUFFER_SIZE];
74-
volatileuint16_twrite;
75-
volatileuint16_tread;
76-
volatileuint16_tlength;
78+
volatileuint32_twrite;
79+
volatileuint32_tread;
80+
volatileuint32_tlength;
7781
}CDC_ReceiveQueue_TypeDef;
7882

7983
voidCDC_TransmitQueue_Init(CDC_TransmitQueue_TypeDef*queue);
8084
intCDC_TransmitQueue_WriteSize(CDC_TransmitQueue_TypeDef*queue);
8185
intCDC_TransmitQueue_ReadSize(CDC_TransmitQueue_TypeDef*queue);
8286
voidCDC_TransmitQueue_Enqueue(CDC_TransmitQueue_TypeDef*queue,constuint8_t*buffer,uint32_tsize);
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
voidCDC_TransmitQueue_CommitRead(CDC_TransmitQueue_TypeDef*queue);
8589

8690
voidCDC_ReceiveQueue_Init(CDC_ReceiveQueue_TypeDef*queue);
8791
intCDC_ReceiveQueue_ReadSize(CDC_ReceiveQueue_TypeDef*queue);
8892
intCDC_ReceiveQueue_Dequeue(CDC_ReceiveQueue_TypeDef*queue);
8993
intCDC_ReceiveQueue_Peek(CDC_ReceiveQueue_TypeDef*queue);
90-
uint16_tCDC_ReceiveQueue_Read(CDC_ReceiveQueue_TypeDef*queue,uint8_t*buffer,uint16_tsize);
94+
uint32_tCDC_ReceiveQueue_Read(CDC_ReceiveQueue_TypeDef*queue,uint8_t*buffer,uint32_tsize);
9195
boolCDC_ReceiveQueue_ReadUntil(CDC_ReceiveQueue_TypeDef*queue,uint8_tterminator,uint8_t*buffer,
92-
uint16_tsize,uint16_t*fetched);
96+
uint32_tsize,uint32_t*fetched);
9397
uint8_t*CDC_ReceiveQueue_ReserveBlock(CDC_ReceiveQueue_TypeDef*queue);
94-
voidCDC_ReceiveQueue_CommitBlock(CDC_ReceiveQueue_TypeDef*queue,uint16_tsize);
98+
voidCDC_ReceiveQueue_CommitBlock(CDC_ReceiveQueue_TypeDef*queue,uint32_tsize);
9599

96100
#ifdef__cplusplus
97101
}

‎libraries/USBDevice/src/USBSerial.cpp

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

108108
size_tUSBSerial::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_tUSBSerial::readBytesUntil(char terminator,char *buffer,size_t length)
126126
{
127-
uint16_t read;
128-
auto rest =static_cast<uint16_t>(length);
127+
uint32_t read;
128+
size_t rest = length;
129129
_startMillis =millis();
130130
do {
131131
bool found =CDC_ReceiveQueue_ReadUntil(&ReceiveQueue,static_cast<uint8_t>(terminator),

‎libraries/USBDevice/src/cdc/cdc_queue.c

Lines changed: 33 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -67,32 +67,34 @@ void CDC_TransmitQueue_Enqueue(CDC_TransmitQueue_TypeDef *queue,
6767
{
6868
uint32_tsizeToEnd=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+
}
90+
8891
queue->reserved=*size;
8992
return&queue->buffer[queue->read];
9093
}
9194

9295
voidCDC_TransmitQueue_CommitRead(CDC_TransmitQueue_TypeDef*queue)
9396
{
94-
queue->read= (queue->read+queue->reserved) %
95-
CDC_TRANSMIT_QUEUE_BUFFER_SIZE;
97+
queue->read= (queue->read+queue->reserved) %CDC_TRANSMIT_QUEUE_BUFFER_SIZE;
9698
}
9799

98100
// Initialize read and write position of queue.
@@ -106,23 +108,23 @@ void CDC_ReceiveQueue_Init(CDC_ReceiveQueue_TypeDef *queue)
106108
// Reserve block in queue and return pointer to it.
107109
uint8_t*CDC_ReceiveQueue_ReserveBlock(CDC_ReceiveQueue_TypeDef*queue)
108110
{
109-
constuint16_tlimit=
110-
CDC_RECEIVE_QUEUE_BUFFER_SIZE-CDC_QUEUE_MAX_PACKET_SIZE;
111-
volatileuint16_tread=queue->read;
111+
constuint32_tlimit=
112+
CDC_RECEIVE_QUEUE_BUFFER_SIZE-CDC_RECEIVE_MAX_BUFFER_SIZE;
113+
volatileuint32_tread=queue->read;
112114

113115
if (read <=queue->write) {
114116
// if write is limited only by buffer size.
115117
if (queue->write<limit|| (queue->write==limit&&read>0)) {
116118
// if size in the rest of buffer is enough for full packet plus 1 byte
117119
// or if it tight enough and write position can be set to 0
118120
returnqueue->buffer+queue->write;
119-
}elseif (read>CDC_QUEUE_MAX_PACKET_SIZE) {
121+
}elseif (read>CDC_RECEIVE_MAX_BUFFER_SIZE) {
120122
// if size in the rest is not enough, but enough size in head
121123
queue->length=queue->write;
122124
queue->write=0;
123125
returnqueue->buffer+queue->write;
124126
}
125-
}elseif (queue->write+CDC_QUEUE_MAX_PACKET_SIZE<read) {
127+
}elseif (queue->write+CDC_RECEIVE_MAX_BUFFER_SIZE<read) {
126128
// write position must be less than read position
127129
// after reading largest possible packet
128130
returnqueue->buffer+queue->write;
@@ -132,7 +134,7 @@ uint8_t *CDC_ReceiveQueue_ReserveBlock(CDC_ReceiveQueue_TypeDef *queue)
132134

133135
// Commits block in queue and make it available for reading
134136
voidCDC_ReceiveQueue_CommitBlock(CDC_ReceiveQueue_TypeDef*queue,
135-
uint16_tsize)
137+
uint32_tsize)
136138
{
137139
queue->write+=size;
138140
if (queue->write >=queue->length) {
@@ -148,8 +150,8 @@ int CDC_ReceiveQueue_ReadSize(CDC_ReceiveQueue_TypeDef *queue)
148150
{
149151
// reading length after write make guarantee, that length >= write
150152
// and determined reading size will be smaller or equal than real one.
151-
volatileuint16_twrite=queue->write;
152-
volatileuint16_tlength=queue->length;
153+
volatileuint32_twrite=queue->write;
154+
volatileuint32_tlength=queue->length;
153155
if (write >=queue->read) {
154156
returnwrite-queue->read;
155157
}
@@ -159,8 +161,8 @@ int CDC_ReceiveQueue_ReadSize(CDC_ReceiveQueue_TypeDef *queue)
159161
// Read one byte from queue.
160162
intCDC_ReceiveQueue_Dequeue(CDC_ReceiveQueue_TypeDef*queue)
161163
{
162-
volatileuint16_twrite=queue->write;
163-
volatileuint16_tlength=queue->length;
164+
volatileuint32_twrite=queue->write;
165+
volatileuint32_tlength=queue->length;
164166
if (queue->read==length) {
165167
queue->read=0;
166168
}
@@ -177,8 +179,8 @@ int CDC_ReceiveQueue_Dequeue(CDC_ReceiveQueue_TypeDef *queue)
177179
// Peek byte from queue.
178180
intCDC_ReceiveQueue_Peek(CDC_ReceiveQueue_TypeDef*queue)
179181
{
180-
volatileuint16_twrite=queue->write;
181-
volatileuint16_tlength=queue->length;
182+
volatileuint32_twrite=queue->write;
183+
volatileuint32_tlength=queue->length;
182184
if (queue->read >=length) {
183185
queue->read=0;
184186
}
@@ -188,12 +190,12 @@ int CDC_ReceiveQueue_Peek(CDC_ReceiveQueue_TypeDef *queue)
188190
returnqueue->buffer[queue->read];
189191
}
190192

191-
uint16_tCDC_ReceiveQueue_Read(CDC_ReceiveQueue_TypeDef*queue,
192-
uint8_t*buffer,uint16_tsize)
193+
uint32_tCDC_ReceiveQueue_Read(CDC_ReceiveQueue_TypeDef*queue,
194+
uint8_t*buffer,uint32_tsize)
193195
{
194-
volatileuint16_twrite=queue->write;
195-
volatileuint16_tlength=queue->length;
196-
uint16_tavailable;
196+
volatileuint32_twrite=queue->write;
197+
volatileuint32_tlength=queue->length;
198+
uint32_tavailable;
197199

198200
if (queue->read >=length) {
199201
queue->read=0;
@@ -216,11 +218,11 @@ uint16_t CDC_ReceiveQueue_Read(CDC_ReceiveQueue_TypeDef *queue,
216218
}
217219

218220
boolCDC_ReceiveQueue_ReadUntil(CDC_ReceiveQueue_TypeDef*queue,
219-
uint8_tterminator,uint8_t*buffer,uint16_tsize,uint16_t*fetched)
221+
uint8_tterminator,uint8_t*buffer,uint32_tsize,uint32_t*fetched)
220222
{
221-
volatileuint16_twrite=queue->write;
222-
volatileuint16_tlength=queue->length;
223-
uint16_tavailable;
223+
volatileuint32_twrite=queue->write;
224+
volatileuint32_tlength=queue->length;
225+
uint32_tavailable;
224226

225227
if (queue->read >=length) {
226228
queue->read=0;
@@ -235,10 +237,10 @@ bool CDC_ReceiveQueue_ReadUntil(CDC_ReceiveQueue_TypeDef *queue,
235237
}
236238

237239
uint8_t*start=&queue->buffer[queue->read];
238-
for (uint16_ti=0;i<size;i++) {
240+
for (uint32_ti=0;i<size;i++) {
239241
uint8_tch=start[i];
240242
if (ch==terminator) {
241-
queue->read+= (uint16_t)(i+1);
243+
queue->read+= (uint32_t)(i+1);
242244
if (queue->read >=length) {
243245
queue->read=0;
244246
}

‎libraries/USBDevice/src/cdc/usbd_cdc_if.c

Lines changed: 2 additions & 2 deletions
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
voidCDC_continue_transmit(void)
332332
{
333-
uint16_tsize;
333+
uint32_tsize;
334334
uint8_t*buffer;
335335
USBD_CDC_HandleTypeDef*hcdc= (USBD_CDC_HandleTypeDef*)hUSBD_Device_CDC.pClassData;
336336
/*

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp