Stm32 + USB em modelos C ++. Continuação. Fazendo CDC

Eu continuo a desenvolver uma biblioteca de modelos completamente para microcontroladores Stm32, no último artigo eu falei sobre a implementação bem-sucedida (quase) de um dispositivo HID. Outra classe USB popular é a Porta COM Virtual (VCP) da classe CDC. A popularidade é explicada pelo fato de que a troca de dados é realizada da mesma forma que o protocolo UART serial usual e simples, porém, elimina a necessidade de instalar um conversor separado no dispositivo.

Interfaces

Um dispositivo CDC deve suportar duas interfaces: uma interface para gerenciar os parâmetros de conexão e uma interface para troca de dados.

A interface de gerenciamento é uma extensão da classe base da interface, com a diferença de que contém um ponto de extremidade (embora, pelo que eu entendo, sem ter que oferecer suporte a todos os recursos, você pode fazer sem o ponto de extremidade) e um conjunto de "funcionalidades" que determinam as capacidades do dispositivo. No âmbito da biblioteca desenvolvida, esta interface é representada pela seguinte classe:

template <uint8_t _Number, uint8_t _AlternateSetting, uint8_t _SubClass, uint8_t _Protocol, typename _Ep0, typename _Endpoint, typename... _Functionals>
class CdcCommInterface : public Interface<_Number, _AlternateSetting, DeviceAndInterfaceClass::Comm, _SubClass, _Protocol, _Ep0, _Endpoint>
{
  using Base = Interface<_Number, _AlternateSetting, DeviceAndInterfaceClass::Comm, _SubClass, _Protocol, _Ep0, _Endpoint>;
  static LineCoding _lineCoding;
  ...
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

No caso básico, a interface deve suportar três pacotes de configuração:

• SET_LINE_CODING: configuração dos parâmetros da linha: Baudrate, Stop Bits, Parity, Data bits. Alguns projetos que eu estava almejando ( este projeto foi a principal fonte de inspiração ) ignoram este pacote, porém, neste caso, alguns terminais (por exemplo, Putty ) se recusam a funcionar.

  
  
  
  
  

• GET_LINE_CODING: , .

  
  
  
  
  

• SET_CONTROL_LINE_STATE: (RTS, DTR ..).

  
  
  
  
  

setup-:

switch (static_cast<CdcRequest>(setup->Request))
{
case CdcRequest::SetLineCoding:
  if(setup->Length == 7)
  {
    // Wait line coding
    _Ep0::SetOutDataTransferCallback([]{
      memcpy(&_lineCoding, reinterpret_cast<const void*>(_Ep0::RxBuffer), 7);
      _Ep0::ResetOutDataTransferCallback();
      _Ep0::SendZLP();
    });
    _Ep0::SetRxStatus(EndpointStatus::Valid);
  }
  break;
case CdcRequest::GetLineCoding:
  _Ep0::SendData(&_lineCoding, sizeof(LineCoding));
  break;
case CdcRequest::SetControlLineState:
  _Ep0::SendZLP();
  break;
default:
  break;
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, , variadic-, :

static uint16_t FillDescriptor(InterfaceDescriptor* descriptor)
{
  uint16_t totalLength = sizeof(InterfaceDescriptor);
  
  *descriptor = InterfaceDescriptor {
    .Number = _Number,
    .AlternateSetting = _AlternateSetting,
    .EndpointsCount = Base::EndpointsCount,
    .Class = DeviceAndInterfaceClass::Comm,
    .SubClass = _SubClass,
    .Protocol = _Protocol
  };

  uint8_t* functionalDescriptors = reinterpret_cast<uint8_t*>(descriptor);

  ((totalLength += _Functionals::FillDescriptor(&functionalDescriptors[totalLength])), ...);

  EndpointDescriptor* endpointDescriptors = reinterpret_cast<EndpointDescriptor*>(&functionalDescriptors[totalLength]);
  totalLength += _Endpoint::FillDescriptor(endpointDescriptors);

  return totalLength;
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, , , , ( ). :

template <uint8_t _Number, uint8_t _AlternateSetting, uint8_t _SubClass, uint8_t _Protocol, typename _Ep0, typename _Endpoint>
class CdcDataInterface : public Interface<_Number, _AlternateSetting, DeviceAndInterfaceClass::CdcData, _SubClass, _Protocol, _Ep0, _Endpoint>
{
  using Base = Interface<_Number, _AlternateSetting, DeviceAndInterfaceClass::CdcData, _SubClass, _Protocol, _Ep0, _Endpoint>;
  ...
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

CDC- , , 4 : Header, CallManagement, ACM, Union, :

template<uint8_t _Number, typename _Ep0, typename _Endpoint>
using DefaultCdcCommInterface = CdcCommInterface<_Number, 0, 0x02, 0x01, _Ep0, _Endpoint, HeaderFunctional, CallManagementFunctional, AcmFunctional, UnionFunctional>;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

(Interrupt Bulk ), , , , :

using CdcCommEndpointBase = InEndpointBase<1, EndpointType::Interrupt, 8, 0xff>;
using CdcDataEndpointBase = BidirectionalEndpointBase<2, EndpointType::Bulk, 32, 0>;

using EpInitializer = EndpointsInitializer<DefaultEp0, CdcCommEndpointBase, CdcDataEndpointBase>;

using Ep0 = EpInitializer::ExtendEndpoint<DefaultEp0>;
using CdcCommEndpoint = EpInitializer::ExtendEndpoint<CdcCommEndpointBase>;
using CdcDataEndpoint = EpInitializer::ExtendEndpoint<CdcDataEndpointBase>;

using CdcComm = DefaultCdcCommInterface<0, Ep0, CdcCommEndpoint>;
using CdcData = CdcDataInterface<1, 0, 0, 0, Ep0, CdcDataEndpoint>;

using Config = Configuration<0, 250, false, false, CdcComm, CdcData>;
using MyDevice = Device<0x0200, DeviceAndInterfaceClass::Comm, 0, 0, 0x0483, 0x5711, 0, Ep0, Config>;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, ( ):

template<>
void CdcDataEndpoint::HandleRx()
{
  uint8_t* data = reinterpret_cast<uint8_t*>(CdcDataEndpoint::RxBuffer);
  uint8_t size = CdcDataEndpoint::RxBufferCount::Get();

  if(size > 0)
  {
    if(data[0] == '0')
    {
      Led::Clear();
      CdcDataEndpoint::SendData("LED is turn off\r\n", 17);
    }
    if(data[0] == '1')
    {
      Led::Set();
      CdcDataEndpoint::SendData("LED is turn on\r\n", 16);
    }
  }
  CdcDataEndpoint::SetRxStatus(EndpointStatus::Valid);
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, - USB-, , .

, . , , Seale Logic , . , , , .

WireShark UsbPcap , , . , - . : : "!(usb.addr == "1.1.1" || usb.addr == "1.2.1" || usb.addr == "1.1.3" || usb.addr == "1.5.1" || usb.addr == "1.5.2" || ..)" ( , ). :

. , PID, GET_DEVICE_DESCRIPTOR. : "usb.idProduct == 0x5711". .

contains. , , (, , ). : "usb.addr contains "1.19"".

, UsbPcap , , .

usbpcap

SSD, Windows 10 To Go (Windows, ). Microsoft , . , , ( ) .

Windows "inaccessible boot device". , , . . , , . , WireShark usbpcap. , / usbpcap. LiveCD Windows . 100%, : Windows , usbpcap, USB, BSOD. , .

Testei o código escrito no programa Terminal v1.9b, a imagem mostra o resultado do envio das mensagens "0" e "1" para o dispositivo.

O código de exemplo completo pode ser visualizado no repositório . Exemplo testado em STM32F072B-DISCO. Como acontece com o HID, a biblioteca volumosa (especialmente o gerenciador de endpoint) tornou muito mais fácil implementar o suporte ao CDC e levou cerca de um dia inteiro para ser concluído. Em seguida, pretendo adicionar outra classe de Dispositivo de armazenamento em massa e provavelmente posso parar por aí. Perguntas e comentários são bem vindos.