🛌🏾 👩🏻‍🔬 👩🏿‍🤝‍👩🏼 Stm32 + USB auf C ++

* Danke an @ grafalex für die coole Tape- Idee

Niemand mag USB

Als ich mich mit der Programmierung von Mikrocontrollern befasste, erkannte ich die Notwendigkeit, USB zu beherrschen, da dies zweifellos die Hauptschnittstelle für die Verbindung von Geräten ohne Stromkreis ist. Es stellte sich jedoch heraus, dass es in der offenen Welt nicht viele relevante Materialien gibt. Nachdem ich verschiedene Foren analysiert hatte, formulierte ich die folgenden Gründe für die Unbeliebtheit von USB in Projekten:

@jaiprakash erinnerte daran, dass der obligatorische VID-Wert für ein USB-Gerät für viel Geld gekauft werden muss.
Das Fehlen der Notwendigkeit einer Hochgeschwindigkeitsdatenübertragung in den meisten Projekten.
Die hohe Komplexität des Standards selbst und die Entwicklung im Vergleich zur bekannten UART-Schnittstelle. Es ist billiger, dem Gerät einen vorgefertigten USB <-> UART-Adapter hinzuzufügen.
Mangel an Fähigkeiten zur Entwicklung von Windows / Linux-Treibern.

Daher bevorzugen Entwickler meistens die Verwendung von UART (über einen Hardwarekonverter oder höchstens durch Erstellen eines VCP-Geräts, dessen Code erfolgreich von CubeMX generiert wird). Ich beschloss, USB zumindest auf einer grundlegenden Ebene zu verstehen, und setzte die Verwendung der C ++ - Sprachvorlagen fort. In diesem Beitrag wird die angewandte Methode zum Zuweisen von Ressourcen (nämlich Pufferspeicher und Register) zwischen Geräteendpunkten beschrieben.

Duplizierungsproblem

Das Hauptelement eines Programms, das ein USB-Gerät implementiert, ist ein Endpunkt . Der Host kommuniziert mit einem bestimmten Endpunkt. Das Gerät muss einen Endpunkt mit der Nummer 0 enthalten, über den die Steuerung erfolgt, Anforderungen für verschiedene Deskriptoren in der Aufzählungsphase, Befehle zum Zuweisen einer Adresse, Auswählen einer Konfiguration und alle anderen Steuerelemente. Weitere Details zum Konzept der Endpunkte und im Prinzip zu den Grundkenntnissen von USB finden Sie in der Übersetzung von "USB in NutShell" auf der Microsin-Ressource (vielen Dank an die Jungs für die geleistete Arbeit, sie haben sehr nützliche Arbeit geleistet). .

Stm32F0/F1 - Packet Memory Area (PMA), . USB- , , . , K, "" K+1, ... , N. ( N - ). : 100% .

, ( ) , runtime compile-time, :

. . (ADDRn_TX, COUNTn_TX, ADDRn_RX, COUNTn_RX), , runtime .
, EPnR ( , , ).

(0..16).
(Control, Interrupt, Bulk, Isochronous).
(In, Out).
.

, .

(EPnR).
.
( ).

: N . , , :

, , .
, .
"" .

template<typename... AllEndpoints,
  typename... BidirectionalAndBulkDoubleBufferedEndpoints,
  typename... RxEndpoints,
  typename... BulkDoubleBufferedTxEndpoints>
class EndpointsManagerBase<TypeList<AllEndpoints...>,
  TypeList<BidirectionalAndBulkDoubleBufferedEndpoints...>,
  TypeList<RxEndpoints...>,
  TypeList<BulkDoubleBufferedTxEndpoints...>>
{
  //   
  using AllEndpointsList = TypeList<AllEndpoints...>;
  ///      
  static const auto BdtSize = 8 * (EndpointEPRn<GetType_t<sizeof...(AllEndpoints) - 1, AllEndpointsList>, AllEndpointsList>::RegisterNumber + 1);
  ///      
  template<typename Endpoint>
  static constexpr uint32_t BufferOffset = BdtSize + OffsetOfBuffer<TypeIndex<Endpoint, AllEndpointsList>::value, AllEndpointsList>::value;
  ///      
  template<typename Endpoint>
  static constexpr uint32_t BdtCellOffset =
    EndpointEPRn<Endpoint, AllEndpointsList>::RegisterNumber * 8
      + (Endpoint::Type == EndpointType::Control
      || Endpoint::Type == EndpointType::ControlStatusOut
      || Endpoint::Type == EndpointType::BulkDoubleBuffered
      || Endpoint::Direction == EndpointDirection::Out
      || Endpoint::Direction == EndpointDirection::Bidirectional
        ? 0
        : 4);
  ///    USB
  static const uint32_t BdtBase = PmaBufferBase;
public:
  /// ""  
  template<typename Endpoint>
  using ExtendEndpoint = 
    typename Select<Endpoint::Type == EndpointType::Control || Endpoint::Type == EndpointType::ControlStatusOut,
    ControlEndpoint<Endpoint,
      typename EndpointEPRn<Endpoint, TypeList<AllEndpoints...>>::type,
      PmaBufferBase + BufferOffset<Endpoint>, // TxBuffer
      PmaBufferBase + BdtCellOffset<Endpoint> + 2, // TxCount
      PmaBufferBase + BufferOffset<Endpoint> + Endpoint::MaxPacketSize, // RxBuffer
      PmaBufferBase + BdtCellOffset<Endpoint> + 6>, //RxCount
    typename Select<Endpoint::Direction == EndpointDirection::Bidirectional,
    BidirectionalEndpoint<Endpoint,
      typename EndpointEPRn<Endpoint, TypeList<AllEndpoints...>>::type,
      PmaBufferBase + BufferOffset<Endpoint>, // TxBuffer
      PmaBufferBase + BdtCellOffset<Endpoint> + 2, // TxCount
      PmaBufferBase + BufferOffset<Endpoint> + Endpoint::MaxPacketSize, // RxBuffer
      PmaBufferBase + BdtCellOffset<Endpoint> + 6>, //RxCount
    ... //       
    void>::value>::value;

  static void Init()
  {
    memset(reinterpret_cast<void*>(BdtBase), 0x00, BdtSize);
    //     
    ((*(reinterpret_cast<uint16_t*>(BdtBase + BdtCellOffset<AllEndpoints>)) = BufferOffset<AllEndpoints>), ...);
    //           
    ((*(reinterpret_cast<uint16_t*>(BdtBase + BdtCellOffset<BidirectionalAndBulkDoubleBufferedEndpoints> + 4)) = (BufferOffset<BidirectionalAndBulkDoubleBufferedEndpoints> + BidirectionalAndBulkDoubleBufferedEndpoints::MaxPacketSize)), ...);
    //  COUNTn_RX   (Rx, Out) 
    ((*(reinterpret_cast<uint16_t*>(BdtBase + BdtCellOffset<RxEndpoints> + 2)) = (RxEndpoints::MaxPacketSize <= 62
      ? (RxEndpoints::MaxPacketSize / 2) << 10
      : 0x8000 | (RxEndpoints::MaxPacketSize / 32) << 10)), ...);
    //  COUNTn_RX        
    ((*(reinterpret_cast<uint16_t*>(BdtBase + BdtCellOffset<BidirectionalAndBulkDoubleBufferedEndpoints> + 6)) = (BidirectionalAndBulkDoubleBufferedEndpoints::MaxPacketSize <= 62
      ? (BidirectionalAndBulkDoubleBufferedEndpoints::MaxPacketSize / 2) << 10
      : 0x8000 | (BidirectionalAndBulkDoubleBufferedEndpoints::MaxPacketSize / 32) << 10)), ...);

    //    COUNTn_RX  Tx     (,    ,     )
    ((*(reinterpret_cast<uint16_t*>(BdtBase + BdtCellOffset<BulkDoubleBufferedTxEndpoints> + 2)) = 0), ...);
    ((*(reinterpret_cast<uint16_t*>(BdtBase + BdtCellOffset<BulkDoubleBufferedTxEndpoints> + 6)) = 0), ...);
  }
};

template<typename Endpoints>
using EndpointsManager = EndpointsManagerBase<SortedUniqueEndpoints<Endpoints>,
  typename Sample<IsBidirectionalOrBulkDoubleBufferedEndpoint, SortedUniqueEndpoints<Endpoints>>::type,
  typename Sample<IsOutEndpoint, SortedUniqueEndpoints<Endpoints>>::type,
  typename Sample<IsBulkDoubleBufferedTxEndpoint, SortedUniqueEndpoints<Endpoints>>::type>;

template<typename... Endpoints>
using EndpointsInitializer = EndpointsManagerBase<SortedUniqueEndpoints<TypeList<Endpoints...>>,
  TypeList<>,
  TypeList<>,
  TypeList<>>;

, :

EndpointEPRn - , EPnR . : . , .
BufferOffset - , . , N 0, ..., N-1.
SortedUniqueEndpoints - , + . USB /, Device.
IsBidirectionalOrBulkDoubleBufferedEndpoint, IsOutEndpoint, IsBulkDoubleBufferedTxEndpoint - .

using DefaultEp0 = ZeroEndpointBase<64>;
using LedsControlEpBase = OutEndpointBase<1, EndpointType::Interrupt, 64, 32>;
//         
using EpInitializer = EndpointsInitializer<DefaultEp0, LedsControlEpBase>;

// EpInitializer    .
//  ,   ,          
using Ep0 = EpInitializer::ExtendEndpoint<DefaultEp0>;
using LedsControlEp = EpInitializer::ExtendEndpoint<LedsControlEpBase>;
//  ,   .
using Hid = HidInterface<0, 0, 0, 0, HidDesc, LedsControlEp>;
using Config = HidConfiguration<0, 250, false, false, Report, Hid>;
using MyDevice = Device<0x0200, DeviceClass::InterfaceSpecified, 0, 0, 0x0483, 0x5711, 0, Ep0, Config>;

Device , :

template<
  ...
  typename _Ep0,
  typename... _Configurations>
  class DeviceBase : public _Ep0
{
  using This = DeviceBase<_Regs, _IRQNumber, _ClockCtrl, _UsbVersion, _Class, _SubClass, _Protocol, _VendorId, _ProductId, _DeviceReleaseNumber, _Ep0, _Configurations...>;
  using Endpoints = Append_t<typename _Configurations::Endpoints...>;
  using Configurations = TypeList<_Configurations...>;

  using EpBufferManager = EndpointsManager<Append_t<_Ep0, Endpoints>>;
  //  Device     
  using EpHandlers = EndpointHandlers<Append_t<This, Endpoints>>;
public:
  static void Enable()
  {
    _ClockCtrl::Enable();
    //        
    EpBufferManager::Init();

C++ :

, , , ( HID-, , 2400 ).
, .
, , . "" USB.
* . C++, , .

USB . , - - , USB, , - . , . , USB , , "" , .

Dieser Beitrag war nicht dem Teil der Bibliothek gewidmet, der sich allgemein auf USB bezieht, sondern einem kleinen, aber wichtigen Modul zum Verteilen von Ressourcen zwischen Endpunkten. Ich würde mich über Fragen und Kommentare freuen.

Sie können den gesamten Code (ich teste USB bisher nur auf F072RBT6, da es eine Disco mit einem gelöteten Miniusb gibt) hier anzeigen . Ich hoffe, USB bis zum Sommer zumindest für die MK-Serien F0 und F1 zu besiegen. Ich habe mir F4 angesehen - dort ist alles kühler (es gibt OTG-Unterstützung) und schwierig.

Stm32 + USB auf C ++ - Vorlagen

Niemand mag USB

Duplizierungsproblem

More articles: