| ►Nble | Entry namespace for all BLE API definitions |
| Caddress_t | MAC address data type |
| Cadv_data_appearance_t | Enumeration of values for the adv_data_type_t::APPEARANCE |
| Cadv_data_flags_t | Set of advertising flags |
| Cadv_data_type_t | |
| Cadvertising_data_status_t | Used to indicate if the packet is complete and if it's truncated |
| Cadvertising_event_t | Properties of an advertising event |
| Cadvertising_filter_policy_t | Advertising policy filter modes |
| Cadvertising_type_t | Encapsulates the peripheral advertising modes |
| CAdvertisingDataBuilder | Build advertising data |
| ►CAdvertisingDataParser | Parse and iterate over advertising data |
| Celement_t | Representation of an Advertising Data element |
| CAdvertisingDataSimpleBuilder | Build advertising data |
| CAdvertisingEndEvent | Event produced when advertising ends |
| CAdvertisingParameters | Parameters defining the advertising process |
| CAdvertisingReportEvent | Event generated when an advertising packet is seen during passive scanning or a scan response is received during active scanning |
| Catt_security_requirement_t | Security requirement that can be attached to an attribute operation |
| Cattribute_handle_range_t | Inclusive range of GATT attributes handles |
| CBounded | Restrict values of an integer type to a defined range |
| Cbyte_array_t | Model fixed size array values |
| Ccentral_privay_configuration_t | Privacy configuration of the central role |
| Cclock_accuracy_t | Accuracy of the master clock |
| Ccoded_symbol_per_bit_t | Type describing the number of symbols per bit in le coded PHY |
| Cconnection_role_t | Enumeration of GAP roles |
| CConnectionCompleteEvent | Event generated when a connection initiation ends (successfully or not) |
| CConnectionParameters | Parameters defining the connection initiation process |
| CConnectionParametersUpdateCompleteEvent | Event received when connection parameters have been updated |
| Ccontroller_supported_features_t | Features supported by the controller |
| Cdisconnection_reason_t | Enumeration of disconnection reasons received in a disconnection event |
| CDisconnectionCompleteEvent | Event produced when a disconnection is complete |
| Cduplicates_filter_t | Scanning policy filter mode |
| CDuration | Model BLE durations |
| ►CGap | Define device discovery, connection and link management procedures |
| CEventHandler | Definition of the general handler of Gap related events |
| Cinitiator_filter_policy_t | Filter policy that you can use during connection initiation |
| Cio_capability_t | Type that describe the IO capability of a device; it is used during Pairing Feature exchange |
| Clink_encryption_t | Type that describes link's encryption state |
| Clocal_disconnection_reason_t | Enumeration of disconnection reasons that should be transmited to the peer |
| Cown_address_type_t | Type used to model the own address used during the following GAP operations: advertising, scanning and initiating |
| Cpairing_failure_t | Type that describe a pairing failure |
| CPasskeyAscii | Passkey stored as a string of digits |
| Cpeer_address_type_t | Type that describes a peer device address type |
| CPeriodicAdvertisingReportEvent | Event generated when periodic advertising packet is received |
| CPeriodicAdvertisingSyncEstablishedEvent | Event generated when you first receive a periodic advertisement |
| CPeriodicAdvertisingSyncLoss | Event generated when periodic advertising sync is lost |
| Cperipheral_privacy_configuration_t | Privacy Configuration of the peripheral role |
| Cphy_set_t | Type that describe a set of PHY(sical) transports |
| Cphy_t | Type that describes a bluetooth PHY(sical) transport |
| Crandom_address_type_t | Type that describes a random device address type |
| CSafeEnum | Helper class used to define safe enumerations |
| Cscanning_filter_policy_t | Scanning policy filter mode |
| ►CScanParameters | Parameters defining the scan process |
| Cphy_configuration_t | Scan configuration of a physical channel |
| CScanRequestEvent | Event produced when a peer requests a scan response from the advertiser |
| CScanTimeoutEvent | Event generated when scan times out |
| CStaticInterface | Static Interface helper class |
| Ctarget_peer_address_type_t | Type of an address to connect to |
| CUpdateConnectionParametersRequestEvent | Event received when a peer wants to change the connection parameters |
| ►NBLEProtocol | Common namespace for types and constants used everywhere in BLE API |
| CAddress_t | BLE address representation |
| CAddressType | Container for the enumeration of BLE address types |
| ►Nevents | |
| ►CAllArgs | |
| COperations | |
| COperations< T *, R(U::*)(B2, B3, B4, B5)> | |
| COperations< T, R(U::*)(B2, B3, B4, B5) const > | |
| COperations< T, R(U::*)(B2, B3, B4, B5) const volatile > | |
| COperations< T, R(U::*)(B2, B3, B4, B5) volatile > | |
| ►CAllArgs< B0 > | |
| COperations | |
| ►CAllArgs< B0, B1 > | |
| COperations | |
| COperations< T *, R(U::*)()> | |
| COperations< T, R(U::*)() const > | |
| COperations< T, R(U::*)() const volatile > | |
| COperations< T, R(U::*)() volatile > | |
| ►CAllArgs< B0, B1, B2 > | |
| COperations | |
| COperations< T *, R(U::*)(B2)> | |
| COperations< T, R(U::*)(B2) const > | |
| COperations< T, R(U::*)(B2) const volatile > | |
| COperations< T, R(U::*)(B2) volatile > | |
| ►CAllArgs< B0, B1, B2, B3 > | |
| COperations | |
| COperations< T *, R(U::*)(B2, B3)> | |
| COperations< T, R(U::*)(B2, B3) const > | |
| COperations< T, R(U::*)(B2, B3) const volatile > | |
| COperations< T, R(U::*)(B2, B3) volatile > | |
| ►CAllArgs< B0, B1, B2, B3, B4 > | |
| COperations | |
| COperations< T *, R(U::*)(B2, B3, B4)> | |
| COperations< T, R(U::*)(B2, B3, B4) const > | |
| COperations< T, R(U::*)(B2, B3, B4) const volatile > | |
| COperations< T, R(U::*)(B2, B3, B4) volatile > | |
| CEvent | Event |
| CEvent< void(ArgTs...)> | Event |
| CEventQueue | EventQueue |
| CPolledQueue | PolledQueue |
| CTask | |
| CTask< R()> | |
| CTask< R(A0)> | |
| CTask< R(A0, A1)> | Task |
| CTaskBase | TaskBase |
| CTaskQueue | TaskQueue |
| CUserAllocatedEvent | |
| CUserAllocatedEvent< F, void(ArgTs...)> | UserAllocatedEvent |
| ►Nmbed | |
| ►Ndetail | |
| Cenable_if | |
| Cenable_if< false, R > | |
| Cis_type | |
| Cnil | |
| ►Ninternal | |
| Cis_unsigned | |
| Cis_unsigned< unsigned char > | |
| Cis_unsigned< unsigned int > | |
| Cis_unsigned< unsigned long > | |
| Cis_unsigned< unsigned long long > | |
| Cis_unsigned< unsigned short > | |
| CSysTimer | The SysTimer class is used to provide timing for system suspension, and the idle loop in TICKLESS mode |
| ►Nnfc | |
| ►Nndef | |
| ►Ncommon | |
| CMime | Represent a mime object |
| CMimeParser | Parse a Mime payload |
| ►CSimpleMessageParser | Basic message parser that aggregates URIParser, TextParser and MimeParser |
| CDelegate | Delegate invoked when the parser raise an event |
| CText | Represent the well known type text |
| CTextParser | Parse a Text |
| CURI | Model the well known type URI |
| CURIParser | Parser of a URI |
| ►CGenericRecordParser | GenericRecordParser |
| CDelegate | Handle that receives parsed values |
| CHeader | Set of constants of a record header |
| ►CMessageBuilder | Construct a NDEF Message |
| CPayloadBuilder | Build a record payload |
| ►CMessageParser | Event driven NDEF Message parser |
| CDelegate | Report parsing event to the application |
| CRecord | Represent a record |
| CRecordParser | Parse a record |
| CRecordParserChain | Record parser chain |
| CRecordType | Encode a record type |
| Cnfc_rf_protocols_bitmask_t | |
| ►CNFCController | This class represents a NFC Controller |
| CDelegate | The NFCController delegate |
| ►CNFCControllerDriver | The abstraction for a NFC controller driver |
| CDelegate | The NFCControllerDriver delegate |
| ►CNFCEEPROM | The NFC EEPROM class represents a NFC target device connected using a wired link (I2C, SPI, etc) |
| CDelegate | The NFCEEPROM delegate |
| ►CNFCEEPROMDriver | The abstraction for a NFC EEPROM driver |
| CDelegate | The NFCEEPROMDriver delegate |
| ►CNFCNDEFCapable | The base class for all endpoints that can support NDEF content |
| CDelegate | |
| ►CNFCRemoteEndpoint | This is the base class for all remote endpoints (initiators and targets) addressable over the air interface |
| CDelegate | The NFCRemoteEndpoint base delegate |
| ►CNFCRemoteInitiator | This class represents a remote NFC initiator (the local controller being in target mode) |
| CDelegate | The NFCRemoteInitiator delegate |
| ►CNFCTarget | This class represents a NFC target (either a remote target when the local controller in in initiator mode, or a target connected through a wired connection) |
| CDelegate | |
| CPN512Driver | |
| CPN512SPITransportDriver | |
| ►CPN512TransportDriver | The PN512 supports multiple transport mechanisms (SPI, I2C, UART): this class provides a unified API across these transports |
| CDelegate | The PN512TransportDriver delegate |
| CType4RemoteInitiator | This class is an implementation of the Type 4 tag application |
| ►Nspan_detail | |
| Cis_convertible | |
| CAnalogIn | An analog input, used for reading the voltage on a pin |
| CAnalogOut | An analog output, used for setting the voltage on a pin |
| CAT_CellularBase | Class AT_CellularBase |
| CAT_CellularContext | |
| CAT_CellularDevice | Class AT_CellularDevice |
| CAT_CellularInformation | Class AT_CellularInformation |
| CAT_CellularNetwork | Class AT_CellularNetwork |
| CAT_CellularSMS | Class AT_CellularSMS |
| ►CAT_CellularStack | Class AT_CellularStack |
| CCellularSocket | |
| CAT_ControlPlane_netif | |
| CATCmdParser | Parser class for parsing AT commands |
| CATHandler | Class for sending AT commands and parsing AT responses |
| CBlockDevice | A hardware device capable of writing and reading blocks |
| CBufferedBlockDevice | Block device for allowing minimal read and program sizes (of 1) for the underlying BD, using a buffer on the heap |
| CBusIn | A digital input bus, used for reading the state of a collection of pins |
| CBusInOut | A digital input output bus, used for setting the state of a collection of pins |
| CBusOut | A digital output bus, used for setting the state of a collection of pins |
| CCallback | Callback class based on template specialization |
| CCallback< R(ArgTs...)> | Callback class based on template specialization |
| CCallChain | Group one or more functions in an instance of a CallChain, then call them in sequence using CallChain::call() |
| CCAN | A can bus client, used for communicating with can devices |
| CCANMessage | CANMessage class |
| ►CCellularContext | CellularContext is CellularInterface/NetworkInterface with extensions for cellular connectivity |
| Cpdpcontext_params_t | PDP Context information |
| CCellularDevice | Class CellularDevice |
| CCellularInformation | Class CellularInformation |
| CCellularList | Class CellularList |
| ►CCellularNetwork | An abstract interface for connecting to a network and getting information from it |
| Coperator_names_t | Cellular operator names in numeric and alpha format |
| Coperator_t | 3GPP TS 27.007 - 7.3 PLMN selection +COPS |
| Cregistration_params_t | Network registration information |
| CCellularNonIPSocket | Socket implementation for cellular Non-IP data delivery(NIDD) |
| CCellularSMS | Class CellularSMS |
| CCellularStateMachine | CellularStateMachine class |
| CChainingBlockDevice | Block device for chaining multiple block devices with the similar block sizes at sequential addresses |
| CCircularBuffer | Templated Circular buffer class |
| CControlPlane_netif | Implements support for data transfer using Control Plane CIoT EPS optimization specified in 3GPP 23.401(4.10), 3GPP 23.682(4.5.14) |
| CCriticalSectionLock | RAII object for disabling, then restoring, interrupt state Usage: |
| CDeepSleepLock | RAII object for disabling, then restoring the deep sleep mode Usage: |
| Cdevice_err_t | AT response error with error code and type |
| CDeviceKey | |
| CDigitalIn | A digital input, used for reading the state of a pin |
| CDigitalInOut | A digital input/output, used for setting or reading a bi-directional pin |
| CDigitalOut | A digital output, used for setting the state of a pin |
| CDir | Dir class |
| CDirHandle | Represents a directory stream |
| CEthernet | An ethernet interface, to use with the ethernet pins |
| CExhaustibleBlockDevice | Heap backed block device which simulates failures |
| CFATFileSystem | FAT file system based on ChaN's FAT file system library v0.8 |
| CFile | File class |
| CFileBase | Class FileBase |
| CFileHandle | Class FileHandle |
| CFileLike | Class FileLike |
| CFilePath | Class FilePath |
| CFileSystem | A file system object |
| CFileSystemHandle | A filesystem-like object is one that can be used to open file-like objects though it by fopen("/name/filename", mode) |
| CFileSystemLike | A filesystem-like object is one that can be used to open file-like objects though it by fopen("/name/filename", mode) |
| CFileSystemStore | FileSystemStore for Secure Store |
| CFlashIAP | Flash IAP driver |
| CFlashSimBlockDevice | Flash simulating block device |
| CFunctionPointerArg1 | |
| CFunctionPointerArg1< R, void > | |
| CHeapBlockDevice | Lazily allocated heap-backed block device |
| CI2C | An I2C Master, used for communicating with I2C slave devices |
| CI2CSlave | An I2C Slave, used for communicating with an I2C Master device |
| CInterruptIn | A digital interrupt input, used to call a function on a rising or falling edge |
| CInterruptManager | Use this singleton if you need to chain interrupt handlers |
| Ckv_map_entry_t | This structure maps between a string name and a partition configuration |
| CKVMap | KVMap class |
| ►CKVStore | KVStore class |
| Cinfo | Holds key information |
| Ckvstore_config_t | This structure represent a KVStore partition configuration |
| CLittleFileSystem | LittleFileSystem, a little file system |
| CLowPowerTicker | Low Power Ticker |
| CLowPowerTimeout | Low Power Timout |
| CLowPowerTimer | Low power timer |
| CMbedCRC | CRC object provides CRC generation through hardware or software |
| CMBRBlockDevice | Block device for managing a Master Boot Record https://en.wikipedia.org/wiki/Master_boot_record |
| CNonCopyable | Prevents generation of copy constructor and copy assignment operator in derived classes |
| CObservingBlockDevice | |
| Cpollfh | |
| CPortIn | A multiple pin digital input |
| CPortInOut | A multiple pin digital in/out used to set/read multiple bi-directional pins |
| CPortOut | A multiple pin digital output |
| CProfilingBlockDevice | Block device for measuring storage operations of another block device |
| CPwmOut | A pulse-width modulation digital output |
| CQSPI | A QSPI Driver, used for communicating with QSPI slave devices |
| CRawSerial | A serial port (UART) for communication with other serial devices This is a variation of the Serial class that doesn't use streams, thus making it safe to use in interrupt handlers with the RTOS |
| CReadOnlyBlockDevice | |
| CResetReason | A platform-independent method of checking the cause of the last system reset |
| CScopedLock | RAII-style mechanism for owning a lock of Lockable object for the duration of a scoped block |
| CScopedRamExecutionLock | RAII object for disabling, then restoring RAM execute never mode Usage: |
| CScopedRomWriteLock | RAII object for disabling, then restoring ROM write never mode Usage: |
| CSecureStore | TDBStore class |
| CSerial | A serial port (UART) for communication with other serial devices |
| CSerialBase | A base class for serial port implementations Can't be instantiated directly (use Serial or RawSerial) |
| CSerialWireOutput | |
| CSharedPtr | Shared pointer class |
| CSlicingBlockDevice | Block device for mapping to a slice of another block device |
| CSpan | Nonowning view to a sequence of contiguous elements |
| CSpan< ElementType, SPAN_DYNAMIC_EXTENT > | Span specialization that handle dynamic size |
| CSPI | A SPI Master, used for communicating with SPI slave devices |
| CSPISlave | A SPI slave, used for communicating with a SPI master device |
| CSTModCellular | |
| CStream | File stream |
| CTDBStore | TDBStore class |
| CTicker | A Ticker is used to call a function at a recurring interval |
| CTimeout | A Timeout is used to call a function at a point in the future |
| CTimerEvent | Base abstraction for timer interrupts |
| CTransaction | Transaction class defines a transaction |
| Ctransaction_t | Transaction structure |
| CUARTSerial | Class providing buffered UART communication functionality using separate circular buffer for send and receive channels |
| Cuse_gpio_ssel_t | |
| CWatchdog | A hardware watchdog timer that resets the system in the case of system failures or malfunctions |
| ►Nrtos | |
| ►Ninternal | |
| Cflags_check_capture | |
| CConditionVariable | Synchronization primitive that allows threads to wait until a particular condition occurs |
| CEventFlags | Used to control event flags or wait for event flags other threads control |
| CMail | The Mail class allows you to control, send, receive or wait for mail |
| CMemoryPool | Define and manage fixed-size memory pools of objects of a given type |
| CMutex | Used to synchronize the execution of threads |
| CQueue | The Queue class represents a collection of objects that are stored first by order of priority, and then in first-in, first-out (FIFO) order |
| CRtosTimer | Allow creating and and controlling of timer functions in the system |
| CSemaphore | Used to manage and protect access to a set of shared resources |
| CThread | Allow defining, creating, and controlling thread functions in the system |
| ►NSafeBool_ | Private namespace used to host details of the SafeBool implementation |
| Cbase | Base class of all SafeBool instances |
| ►Nstd | |
| Cremove_reference | |
| Cremove_reference< T & > | |
| Cremove_reference< T && > | |
| ►Nutest | |
| ►Nv1 | |
| Cbase_control_t | POD version of the class control_t |
| CCase | Test case wrapper class |
| Ccase_t | POD data structure of the Case class |
| Ccontrol_t | Control class for specifying test case attributes |
| Cfailure_t | Contains the reason and location of the failure |
| Chandlers_t | A table of handlers |
| CHarness | Test Harness |
| CSpecification | Test specification containing the setup and teardown handlers and test cases |
| C__ac_buffer | |
| C__ac_buffer_builder | |
| C__ac_istream | |
| C__ac_ostream | |
| C__QCBORDecodeNesting | |
| C__QCBORTrackNesting | |
| C_ARM_DRIVER_STORAGE | This is the set of operations constituting the Storage driver |
| C_ARM_DRIVER_VERSION | Driver Version |
| C_ARM_STORAGE_BLOCK | A storage block is a range of memory with uniform attributes |
| C_ARM_STORAGE_BLOCK_ATTRIBUTES | Attributes of the storage range within a storage block |
| C_ARM_STORAGE_CAPABILITIES | Storage Driver API Capabilities |
| C_ARM_STORAGE_INFO | Storage information |
| C_ARM_STORAGE_SECURITY_FEATURES | Device Data Security Protection Features |
| C_ARM_STORAGE_STATUS | Operating status of the storage controller |
| C_CFG_HDR_TYPE_ | |
| C_mbed_error_ctx | Mbed_error_ctx struct |
| C_MEM_INFO_DESC_ | Memory Information |
| C_MEM_REGION_ | |
| C_MISCELLANEOUS_INFO_DESC_ | |
| C_MISCELLANEOUS_INFO_HDR_ | System Miscellaneous Information |
| C_QCBORDecodeContext | |
| C_QCBOREncodeContext | |
| C_QCBORItem | QCBORItem holds the type, value and other info for a decoded item returned by GetNextItem() |
| C_SOC_PER_INFO_DESC_ | |
| C_SOC_PER_INFO_NUM_ | |
| C_TARGET_CFG_HDR_ | Target Configuration Header |
| C_Unity | |
| Caddr_table_t | |
| Cadr_req_params_t | This structure contains parameters for ADR request coming from network server |
| CAnaloginMaps | |
| CAnalogoutMaps | |
| Cargs_t | Flash algo argument structure Contains all registers that should be preserved |
| CAsyncOp | |
| CAttachTester | |
| CAttachUSTester | |
| Cattest_token_ctx | The context for creating an attestation token |
| Cband_t | Default user application maximum data size for transmission |
| CBatteryService | BLE Battery service |
| ►CBLE | Abstract away BLE-capable radio transceivers or SOCs |
| CInitializationCompleteCallbackContext | Initialization complete event |
| COnEventsToProcessCallbackContext | Events to process event |
| CBLEInstanceBase | Private interface used to implement the BLE class |
| Cboot_t | |
| Cbuffer_s | Generic buffer structure |
| CByteBuffer | |
| CCallChainOfFunctionPointersWithContext | Function like object hosting a list of FunctionPointerWithContext |
| CCAN_Message | Holder for single CAN message |
| Ccell_callback_data_t | |
| Ccell_signal_quality_t | |
| CCellular_driver_L3IP | |
| CCellularInterface | Common interface that is shared between cellular interfaces |
| Cchannel_params_t | DO NOT MODIFY, WILL BREAK THE API! |
| Cchannel_selection_params_s | The parameter structure for the function RegionNextChannel |
| ►CCharacteristicDescriptorDiscovery | Definitions of events and event handlers that the characteristic descriptor discovery procedure uses |
| CDiscoveryCallbackParams_t | Characteristic descriptor discovered event |
| CTerminationCallbackParams_t | Characteristic descriptor discovery ended event |
| Ccontinuous_wave_mode_params_s | |
| Ccore_util_atomic_flag | A lock-free, primitive atomic flag |
| Ccrc_mbed_config | |
| CCThunk | Class for created a pointer with data bound to it |
| CCThunkBase | |
| Ccy_ip_addr_t | |
| Ccy_ip_addr_v4_t | |
| Ccy_ip_addr_v6_t | |
| Ccy_mac_addr_t | Structure for storing a MAC address (Wi-Fi Media Access Control address) |
| CCyDhcpServer | Implementation of a DHCP sever |
| CDataFlashBlockDevice | BlockDevice for DataFlash flash devices |
| CDefaultFormFactor | This is a convenience class for use with the above templates |
| CDeviceInformationService | BLE Device Information Service Service: https://developer.bluetooth.org/gatt/services/Pages/ServiceViewer.aspx?u=org.bluetooth.service.device_information.xml Manufacturer Name String Char: https://developer.bluetooth.org/gatt/characteristics/Pages/CharacteristicViewer.aspx?u=org.bluetooth.characteristic.manufacturer_name_string.xml |
| Cdhcp_packet_t | |
| Cdirent | |
| ►CDiscoveredCharacteristic | Representation of a characteristic discovered |
| CProperties_t | Properties of a discovered characteristic |
| CDiscoveredCharacteristicDescriptor | Representation of a characteristic descriptor discovered |
| CDiscoveredService | Representation of a GATT service discovered |
| CDNS | Base class for DNS provider |
| Cdns_application_data | |
| ►Cdr_range_t | DO NOT MODIFY, WILL BREAK THE API! |
| Cfields_s | The structure to store the minimum and the maximum datarate |
| CDTLSSocket | DTLSSocket implement DTLS stream over UDP Socket |
| CDTLSSocketWrapper | DTLSSocketWrapper implement DTLS stream over the existing Socket transport |
| CDynamicPinList | |
| Cecc_key_t | Structure definition to carry pointer and size information about an Elliptic curve key which is stored in a buffer(key_buf) in raw format (without encoding): |
| CEddystone | Eddystone Configuration Service |
| ►CEddystoneConfigService | Eddystone Configuration Service |
| CParams_t | |
| CEddystoneService | |
| CEMAC | This interface should be used to abstract low level access to networking hardware All operations receive a void * hardware pointer which an EMAC device provides when it is registered with a stack |
| CEMAC_CFG_Type | EMAC configuration structure definition |
| Cemac_memory | |
| CEMAC_PACKETBUF_Type | TX Data Buffer structure definition |
| CEMACInterface | EMACInterface class Implementation of the NetworkInterface for an EMAC-based driver |
| CEMACMemoryManager | |
| CEmacTestMemoryManager | |
| ►CEmacTestNetworkStack | |
| CInterface | |
| CEndpointResolver | Utility class for resolving endpoints |
| CEnvironmentalService | BLE Environmental Service |
| ►Cequeue | |
| Cequeue_background | |
| Cequeue_slab | |
| Cequeue_event | |
| Ceth_descriptor | |
| CEthernetInterface | Implementation of the NetworkStack for an EMAC-based Ethernet driver |
| CEthInterface | Common interface between Ethernet hardware |
| Cfactorial_data | |
| CFATFS | |
| CFATFS_DIR | |
| CFFOBJID | |
| CFIL | |
| CFILINFO | |
| Cfirmware_info | |
| Cflash_algo_t | Target flash algorithm structure |
| Cflash_s | Target flash configuration For targets not supporting TrustZone, its flash_set_target_config must define target_config |
| Cflash_target_config_t | Flash configuration structure |
| CFlashIAPBlockDevice | BlockDevice using the FlashIAP API |
| Cfsfat_kv_data_t | |
| Cfslittle_kv_data_t | |
| CFunctionCaller | |
| CFunctionCaller< PortType, TF1, f > | |
| CFunctionCaller< PortType, TF2, f > | |
| CFunctionCaller< PortType, TF3, f > | |
| CFunctionCaller< PortType, TF4, f > | |
| CFunctionCaller< PortType, TF5, f > | |
| CFunctionPointerWithContext | Function like object adapter over freestanding and member functions |
| Cfvp_EMAC | |
| ►CGap | Define device discovery, connection and link management procedures. |
| CAdvertisementCallbackParams_t | Representation of a scanned advertising packet |
| CConnectionCallbackParams_t | Connection events |
| CConnectionParams_t | Parameters of a BLE connection |
| CDisconnectionCallbackParams_t | Disconnection event |
| CGapState_t | Description of the states of the device |
| CWhitelist_t | Representation of a whitelist of addresses |
| CGapAdvertisingData | GAP advertising data builder |
| CGapAdvertisingParams | Parameters defining the advertising process |
| CGapScanningParams | Parameters defining the scan process |
| CGattAttribute | Representation of a GattServer attribute |
| ►CGattCharacteristic | Representation of a GattServer characteristic |
| CPresentationFormat_t | Value of a Characteristic Presentation Format descriptor |
| ►CGattClient | Define procedures required for interacting with a distant GATT server |
| CEventHandler | Definition of the general handler of GattClient related events |
| CGattHVXCallbackParams | Handle Value Notification/Indication event |
| CGattReadAuthCallbackParams | GATT read authorization request event |
| CGattReadCallbackParams | GATT Read event definition |
| ►CGattServer | Construct and operates a GATT server |
| CEventHandler | Definition of the general handler of GattServer related events |
| CGattServerEvents | Abstract events generated by a GattServer vendor port |
| CGattService | Representation of a GattServer service |
| CGattWriteAuthCallbackParams | GATT write authorization request event |
| CGattWriteCallbackParams | GATT Write event definition |
| CGD32_EMAC | |
| CGPIOIRQMaps | |
| CGPIOMaps | |
| CGreenteaSerial | |
| CHandleTestCommand | HandleTestCommand turns all the typed-in/serial commands into function calls sent via a eventqueue to the driver shim/wrapper class |
| CHealthThermometerService | BLE Health Thermometer Service |
| ►CHeartRateService | BLE Heart Rate Service |
| CHeartRateValueBytes | |
| CHID_REPORT | |
| Ci2c | I2C HAL structure |
| Ci2c_async_event | Structure describing the status of async transfer |
| Ci2c_capabilities_t | |
| CI2CEEBlockDevice | BlockDevice for I2C based flash device such as Microchip's 24LC or ATMEL's AT24C ranges |
| CI2CMaps | |
| CI2CTester | |
| CICMPSocket | ICMP socket implementation |
| CIEEE754_union | |
| Cinfo | The key size |
| CInterfaceNanostack | |
| CInternetDatagramSocket | InternetDatagramSocket socket implementation |
| CInternetSocket | Socket implementation that uses IP network stack |
| Ciovec_args_t | Holds the iovec parameters that are passed to a service |
| Cipc_consumer_queue_t | |
| Cipc_producer_queue_t | |
| Citems_to_get_t | |
| CKinetis_EMAC | |
| CL3IP | This interface should be used to abstract low level access to networking hardware All operations receive a void * hardware pointer which an l3ip device provides when it is registered with a stack |
| CL3IPInterface | L3IPInterface class Implementation of the NetworkInterface for an IP-based driver |
| Clan8742_IOCtx_t | |
| Clan8742_Object_t | |
| Clfs | |
| Clfs_cache | |
| Clfs_config | |
| ►Clfs_dir | |
| Clfs_disk_dir | |
| Clfs_emubd | |
| ►Clfs_entry | Littlefs data structures /// |
| Clfs_disk_entry | |
| Clfs_file | |
| Clfs_file_config | |
| Clfs_free | |
| Clfs_info | |
| ►Clfs_superblock | |
| Clfs_disk_superblock | |
| Clink_adr_params_s | Structure containing data for local ADR settings |
| CLinkedList | |
| CLinkedListBase | |
| CLinkEntry | |
| CLinkLossService | This service defines behavior when a link is lost between two devices |
| CLockGuard | RAII mutex locker |
| Clora_channelplan | DO NOT MODIFY, WILL BREAK THE API! |
| Clora_channels_s | DO NOT MODIFY, WILL BREAK THE API! |
| Clora_mac_system_params_t | |
| CLoRaMac | LoRaMac Class Implementation of LoRaWAN MAC layer |
| ►Cloramac_frame_ctrl_t | |
| Cctrl_bits_s | |
| Cloramac_keys | |
| Cloramac_mcps_confirm_t | |
| Cloramac_mcps_indication_t | |
| ►Cloramac_mhdr_t | |
| Chdr_bits_s | |
| Cloramac_mlme_confirm_t | |
| Cloramac_mlme_indication_t | |
| Cloramac_protocol_params | |
| Cloramac_rx_message_t | Loramac_rx_message_t |
| Cloramac_tx_message_t | Stack level TX message structure |
| CLoRaMacChannelPlan | |
| CLoRaMacCommand | LoRaMacCommand Class Helper class for LoRaMac layer to handle any MAC commands |
| CLoRaMacCrypto | |
| CLoRaPHY | LoRaPHY Class Parent class for LoRa regional PHY implementations |
| Cloraphy_channels_t | |
| Cloraphy_params_t | |
| Cloraphy_table_t | |
| CLoRaRadio | Interface for the radios, containing the main functions that a radio needs, and five callback functions |
| Clorawan_app_callbacks_t | Stack level callback functions |
| Clorawan_connect | Lorawan_connect_t structure |
| Clorawan_connect_abp_t | The lorawan_connect_abp structure |
| Clorawan_connect_otaa_t | The lorawan_connect_otaa structure |
| Clorawan_rx_metadata | Meta-data collection for the received packet |
| Clorawan_session | LoRaWAN session |
| Clorawan_timers | |
| Clorawan_tx_metadata | Meta-data collection for a transmission |
| CLoRaWANInterface | LoRaWANInterface Class A network interface for LoRaWAN |
| CLoRaWANStack | LoRaWANStack Class A controller layer for LoRaWAN MAC and PHY |
| CLoRaWANTimeHandler | / _____) _ | | ( (____ _____ ____ _| |_ _____ ____| |__ ____ | ___ | (_ _) ___ |/ ___) _ \ _____) ) ____| | | || |_| ____( (___| | | | (______/|_____)_|_|_| __)_____)____)_| |_| (C)2013 Semtech |
| CLoWPANNDInterface | 6LoWPAN-ND mesh network interface class |
| CLowPowerTickerWrapper | |
| CLPC17_EMAC | |
| CLPC546XX_EMAC | |
| Cmaclib_buf_t | |
| Cmaclib_func_t | |
| Cmaclib_import_func_t | |
| Cmaclib_msg_t | Structures |
| Cmbed_fault_context_t | |
| Cmbed_stats_cpu_t | Struct mbed_stats_cpu_t definition |
| Cmbed_stats_heap_t | Struct mbed_stats_heap_t definition |
| Cmbed_stats_socket_t | Structure to parse socket statistics |
| Cmbed_stats_stack_t | Struct mbed_stats_stack_t definition |
| Cmbed_stats_sys_t | Struct mbed_stats_sys_t definition |
| Cmbed_stats_thread_t | Struct mbed_stats_thread_t definition |
| CMbedTester | The base class for controlling the FPGA CI Test Shield |
| Cmd5_context | / |
| Cmem_region | |
| CMeshInterface | Common interface that is shared between mesh hardware |
| CMeshInterfaceNanostack | |
| CMIDIMessage | A MIDI message container |
| Cmlme_cw_tx_mode_t | |
| Cmlme_join_req_t | |
| Cmulticast_params_s | |
| ►CNanostack | |
| CEthernetInterface | |
| CInterface | |
| CMeshInterface | |
| CPPPInterface | |
| CNanostackEMACInterface | |
| CNanostackEthernetInterface | Ethernet interface for Nanostack |
| CNanostackEthernetPhy | Ethernet PHY driver class for Nanostack |
| CNanostackLockGuard | RAII style Nanostack mutex acquisition |
| CNanostackMACPhy | MAC PHY driver class for Nanostack |
| CNanostackMemoryManager | |
| CNanostackPhy | PHY driver class for Nanostack |
| CNanostackPPPPhy | PPP PHY driver class for Nanostack |
| CNanostackRfInterface | |
| CNanostackRfPhy | Radio PHY driver class for Nanostack |
| Cnetif | |
| CNetStackMemoryManager | |
| CNetworkInterface | Common interface that is shared between network devices |
| CNetworkStack | NetworkStack class |
| CNFCProcessController | Wrapper class handles calls and callbacks for NFC controller drivers |
| CNFCTestShim | Test app driver wrapper |
| CNOOS_IP | |
| CNOOS_PACKET_POOL | |
| Cnsapi_addr | IP address structure for passing IP addresses by value |
| Cnsapi_ip_mreq | Nsapi_ip_mreq structure |
| Cnsapi_stack | Nsapi_stack structure |
| Cnsapi_stack_api | Nsapi_stack_api structure |
| Cnsapi_wifi_ap | Nsapi_wifi_ap structure |
| CNUMAKER_EMAC | |
| Cnvmem_param_t | |
| CNVStore | NVStore class |
| COdinWiFiEMAC | |
| ►COnboardNetworkStack | Mbed OS API for onboard IP stack abstraction |
| CInterface | Representation of a stack's view of an interface |
| COperationList | |
| COperationListBase | |
| Cos_mailQ_def | Definition structure for mail queue |
| Cos_messageQ_def | Definition structure for message queue |
| Cos_pool_def | Definition structure for memory block allocation |
| Cos_thread_def | Thread Definition structure contains startup information of a thread |
| Cos_timer_def | Timer Definition structure contains timer parameters |
| CosEvent | Event structure contains detailed information about an event |
| CosEventFlagsAttr_t | Attributes structure for event flags |
| CosMemoryPoolAttr_t | Attributes structure for memory pool |
| CosMessageQueueAttr_t | Attributes structure for message queue |
| CosMutexAttr_t | Attributes structure for mutex |
| CosRtxConfig_t | OS Configuration structure |
| CosRtxEventFlags_t | Event Flags Control Block |
| CosRtxInfo_t | OS Runtime Information structure |
| CosRtxMemoryPool_t | Memory Pool Control Block |
| CosRtxMessage_s | Message Control Block |
| CosRtxMessageQueue_t | Message Queue Control Block |
| CosRtxMpInfo_t | Memory Pool Information |
| CosRtxMutex_s | Mutex Control Block |
| CosRtxObject_t | Generic Object Control Block |
| CosRtxObjectMemUsage_t | OS Runtime Object Memory Usage structure |
| CosRtxSemaphore_t | Semaphore Control Block |
| CosRtxThread_s | Thread Control Block |
| CosRtxTimer_s | Timer Control Block |
| CosRtxTimerFinfo_t | Timer Function Information |
| CosSemaphoreAttr_t | Attributes structure for semaphore |
| CosThreadAttr_t | Attributes structure for thread |
| CosTimerAttr_t | Attributes structure for timer |
| CosVersion_t | Version information |
| Cpbuf | |
| CPeripheralList | |
| CPinList | |
| CPinMap | |
| CPlatformMutex | Used to synchronize the execution of threads |
| Cpollfd | |
| CPort | |
| CPPP | |
| Cppp_service | This interface should be used to abstract low level access to networking hardware All operations receive a void * hardware pointer which an ppp device provides when it is registered with a stack |
| CPPPInterface | PPPInterface class Implementation of the NetworkInterface for an PPP-service |
| Cpsa_aead_operation_s | |
| Cpsa_api_t | |
| Cpsa_cipher_operation_s | |
| Cpsa_core_key_attributes_t | |
| Cpsa_crypto_derivation_ipc_s | Psa_crypto_derivation_ipc_s struct used for some of the PSA Crypto APIs that need psa_key_handle_t and psa_algorithm_t arguments and in order to use the existing infrastructure of the SPM-IPC we provide a struct to pack them together |
| Cpsa_crypto_ipc_aead_s | |
| Cpsa_crypto_ipc_asymmetric_s | Psa_crypto_ipc_asymmetric_s struct used for asymmetric PSA Crypto APIs that need psa_key_handle_t and psa_algorithm_t arguments and in order to use the existing infrastructure of the SPM-IPC we provide a struct to pack them together |
| Cpsa_crypto_ipc_s | Psa_crypto_ipc_s struct used for some of the PSA Crypto APIs that need psa_key_handle_t and psa_algorithm_t arguments and in order to use the existing infrastructure of the SPM-IPC we provide a struct to pack them together |
| Cpsa_handle_item_t | |
| Cpsa_handle_manager_t | |
| Cpsa_hash_operation_s | |
| Cpsa_invec | Structure that describes a scatter-gather input buffer |
| Cpsa_key_attributes_s | |
| Cpsa_key_derivation_s | |
| Cpsa_key_mng_ipc_s | Psa_key_mng_ipc_s struct used for some of the PSA Crypto APIs that need psa_key_handle_t and psa_algorithm_t arguments and in order to use the existing infrastructure of the SPM-IPC we provide a struct to pack them together |
| Cpsa_key_policy_s | |
| Cpsa_mac_operation_s | |
| Cpsa_msg | Structure containing the PSA IPC message sent from a client partition to an RoT Service |
| Cpsa_msg_t | Describe a message received by an RoT Service after calling psa_get() |
| Cpsa_outvec | Structure which describes a scatter-gather output buffer |
| Cpsa_storage_info_t | A container for metadata associated with a specific uid |
| Cpsa_storage_version_t | |
| CPWMMaps | |
| CQCBORStringAllocator | This is a set of functions and pointer context (in object-oriented parlance, an "object") used to allocate memory for coalescing the segments of an indefinite length string into one |
| CQCBORTagListIn | This is used to tell the decoder about tags that it should record in uTagBits in QCBORItem beyond the built-in tags |
| CQCBORTagListOut | This is for QCBORDecode_GetNextWithTags() to be able to return the full list of tags on an item |
| CQspi | |
| Cqspi_command | QSPI command |
| CQspiCommand | |
| CQSPIFBlockDevice | BlockDevice for SFDP based flash devices over QSPI bus |
| Cradio_events | Reporting functions for upper layers |
| Cradio_fsk_packet_handler | FSK packet handle |
| Cradio_fsk_settings | FSK modem parameters |
| Cradio_lora_packet_handler | LoRa packet Contains information about a LoRa packet |
| Cradio_lora_settings | LoRa modem parameters |
| Cradio_settings | Global radio settings |
| Crda5981_apsta_info | |
| Crda5981_scan_result | |
| CRDA5981x_EMAC | |
| Crda5991h_user_data | |
| Crda_enetdata_t | |
| Crda_msg | |
| CRDAWiFiInterface | RDAWiFiInterface class Implementation of the NetworkStack for an EMAC-based Ethernet driver |
| CReadOnlyArrayGattCharacteristic | Helper class that represents a read-only GattCharacteristic with an array value |
| CReadOnlyGattCharacteristic | Helper class that represents a read only GattCharacteristic |
| CReadWriteArrayGattCharacteristic | Helper class that represents a readable and writable GattCharacteristic with an array value |
| CReadWriteGattCharacteristic | Helper class that represents a readable and writable GattCharacteristic |
| Crf_ctrls | Structure to hold RF controls for LoRa Radio |
| Crx2_channel_params | |
| Crx_config_params_t | |
| CRX_Desc | RX Descriptor structure type definition |
| Crx_message_u | Lora_mac_rx_message_by_type_t union |
| Crx_param_setup_req_s | Contains rx parameter setup request coming from network server |
| CRX_Stat | RX Status structure type definition |
| CRZ_A1_EMAC | |
| CSafeBool | Safe conversion of objects in boolean context |
| CSDBlockDevice | SDBlockDevice class |
| Csector_info_t | Sector information structure |
| ►CSecurityManager | Overview |
| CEventHandler | The stack will use these functions to signal events to the application, subclass to override handlers |
| Cserial_t | Asynch serial HAL structure |
| CServiceDiscovery | Host callback types needed by the service discovery procedure |
| Cshared_data_tlv_entry | Shared data TLV entry header format |
| Cshared_data_tlv_header | Shared data TLV header |
| CSingletonPtr | Utility class for creating and using a singleton |
| CSL_EMAC | |
| CSmartPoster | Smart poster object |
| CSMSC9220_EMAC | |
| CSocket | Socket interface |
| CSocketAddress | SocketAddress class |
| CSocketStats | SocketStats class |
| Cspi_t | Asynch SPI HAL structure |
| CSPIFBlockDevice | BlockDevice for SFDP based flash devices over SPI bus |
| CSPIFReducedBlockDevice | Reduced BlockDevice for SPI based flash devices Should only be used by Boot Loader |
| CSPIMaps | |
| CSPIMasterTester | |
| CSPINoCSMaps | |
| CSPISlaveMaps | |
| CSPISlaveTester | |
| CSPITester | |
| Cspm_active_msg | |
| Cspm_channel_linked_list | |
| Cspm_db | |
| Cspm_iovec | |
| Cspm_ipc_channel | |
| Cspm_partition | |
| Cspm_partition_db_t | |
| Cspm_partition_desc_t | Holds the fields that define a partition for SPM |
| Cspm_partition_runtime_data_t | Runtime context information of a partition |
| Cspm_partition_static_data_t | Holds the fields of the partition DB used by the SPM code |
| Cspm_rot_service | |
| Cstat | |
| Cstatvfs | |
| CSTM32_EMAC | |
| CSynchronizedIntegral | Thread safe wrapper for integral types |
| Ct_cose_crypto_hash | The context for use with the hash adaptation layer here |
| Ct_cose_sign1_ctx | This is the context for creating a COSE_Sign1 structure |
| CTCPServer | TCP socket server |
| CTCPSocket | TCP socket connection |
| Ctest_count_t | |
| Ctest_data | |
| Ctest_info_t | |
| Ctest_status_buffer_t | |
| CTestFile | |
| CTestUSBMSD | |
| Ctfm_boot_data | Store the data for the runtime SW |
| Ctfm_conn_handle_t | |
| Ctfm_event_t | |
| Ctfm_exc_stack_t | |
| Ctfm_list_node_t | |
| Ctfm_msg_body_t | |
| Ctfm_msg_queue_t | |
| Ctfm_pool_chunk_t | |
| Ctfm_pool_instance_t | |
| Ctfm_sfn_req_s | |
| Ctfm_spm_ipc_partition_t | |
| Ctfm_spm_service_db_t | |
| Ctfm_spm_service_t | |
| Ctfm_state_context | |
| Ctfm_state_context_base | |
| Ctfm_state_context_ext | |
| Ctfm_thrd_ctx | |
| CThreadInterface | Thread mesh network interface class |
| Cticker_data_t | Ticker's data structure |
| Cticker_event_queue_t | Ticker's event queue structure |
| Cticker_event_s | Ticker's event structure |
| Cticker_info_t | Information about the ticker implementation |
| Cticker_interface_t | Ticker's interface structure - required API for a ticker |
| CTimeoutDriftTester | |
| Ctimer_event_t | Timer object description |
| Ctimeval | |
| CTLSSocket | TLSSocket is a wrapper around TCPSocket for interacting with TLS servers |
| CTLSSocketWrapper | TLSSocket is a wrapper around Socket for interacting with TLS servers |
| Ctx_config_params_t | TX configuration parameters |
| CTX_Desc | TX Descriptor structure type definition |
| CTX_Stat | TX Status structure type definition |
| CUARTMaps | |
| CUARTNoFCMaps | |
| CUARTService | BLE Service to enable UART over BLE |
| CUARTTester | |
| CUDPSocket | UDP socket implementation |
| ►CURIBeaconConfigService | UriBeacon Configuration Service |
| CParams_t | |
| Cusb_ep_entry_t | |
| Cusb_ep_table_t | |
| CUSBAudio | USBAudio example |
| CUSBCDC | |
| CUSBCDC_ECM | |
| ►CUSBDevice | Core USB Device driver |
| Csetup_packet_t | |
| ►CUSBEndpointTester | |
| Cep_config_t | |
| CUSBHID | USBHID example |
| CUSBKeyboard | USBKeyboard example |
| CUSBMIDI | USBMIDI example |
| CUSBMouse | USBMouse example |
| CUSBMouseKeyboard | USBMouseKeyboard example |
| CUSBMSD | USBMSD class: generic class in order to use all kinds of blocks storage chip |
| CUSBPhy | Abstract interface to physical USB hardware |
| CUSBPhyEvents | Event handler for USBPhy |
| CUSBPhyHw | |
| CUSBSerial | USBSerial example |
| CUSBTester | |
| Cuseful_buf | The non-const UsefulBuf typically used for some allocated memory that is to be filled in |
| Cuseful_buf_c | UsefulBufC and UsefulBuf are simple data structures to hold a pointer and length for a binary data |
| Cuseful_input_buf | |
| Cuseful_out_buf | UsefulOutBuf is a structure and functions (an object) that are good for serializing data into a buffer such as is often done with network protocols or data written to files |
| Cutest_v1_scheduler_t | The scheduler interface consists out of the post and cancel functions, which you must implement to use utest |
| CUUID | Representation of a Universally Unique Identifier (UUID) |
| Cval_api_t | |
| Cval_test_info_t | |
| Cverify_adr_params_s | Structure used to store ADR values received from network for verification (legality) purposes |
| Cwatchdog_config_t | Watchdog configuration |
| Cwatchdog_features_t | Watchdog features |
| Cwd_param_t | |
| Cwhd_custom_ie_info_t | Vendor IE details |
| CWHD_EMAC | |
| Cwhd_interface_shared_info_t | |
| CWhdAccessPoint | WhdAccessPoint class |
| CWhdSoftAPInterface | WhdSoftAPInterface class Implementation of the SoftAPInterface for the Whd |
| ►CWhdSTAInterface | WhdSTAInterface class Implementation of the NetworkStack for the WHD |
| COlmInterface | |
| Cwiced_packet_t | |
| Cwiced_tcp_server_t | |
| Cwiced_tcp_socket_struct | |
| Cwiced_udp_socket_struct | |
| CWiFiAccessPoint | WiFiAccessPoint class |
| CWiFiInterface | Common interface between Wi-Fi devices |
| CWisunInterface | Wi-SUN mesh network interface class |
| Cwland_ap_data_t | This struct contains ap data, include ssid key and channel |
| Cwland_ap_net_data_t | This struct contains ap net data |
| Cwland_dhcp_t | |
| Cwland_phy_channels_t | |
| Cwland_phy_t | |
| Cwland_rf_channels_t | |
| Cwland_rf_t | |
| Cwland_sta_data_t | This struct contains all smartconfig mbed flash parameter |
| Cwland_tx_power_t | This struct contains tx power parameter |
| CWriteOnlyArrayGattCharacteristic | Helper class that represents a write-only GattCharacteristic with an array value |
| CWriteOnlyGattCharacteristic | Helper class that represents a write only GattCharacteristic |
