| 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 | |
| CAddress_t | BLE address representation |
| CAddressType | Container for the enumeration of BLE address types |
| Cadr_req_params_t | This structure contains parameters for ADR request coming from network server |
| Cadv_data_flags_t | Set of advertising flags |
| CGap::AdvertisementCallbackParams_t | Representation of a scanned advertising packet |
| Cadvertising_event_t | Properties of an advertising event |
| CAdvertisingDataBuilder | Build advertising data |
| CAdvertisingDataParser | Parse and iterate over advertising data |
| CAdvertisingDataSimpleBuilder< DataSize > | 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 |
| CAllArgs< B0, B1, B2, B3, B4, B5 > | |
| CAllArgs< B0 > | |
| CAllArgs< B0, B1 > | |
| CAllArgs< B0, B1, B2 > | |
| CAllArgs< B0, B1, B2, B3 > | |
| CAllArgs< B0, B1, B2, B3, B4 > | |
| CAllArgs< mbed::Callback< R()> > | |
| CAllArgs< mbed::Callback< R(A0)>, A0 > | |
| CAllArgs< mbed::Callback< R(A0, A1)>, A0, A1 > | |
| CAnalogIn | An analog input, used for reading the voltage on a pin |
| CAnaloginMaps | |
| CAnalogOut | An analog output, used for setting the voltage on a pin |
| CAnalogoutMaps | |
| Cargs_t | Flash algo argument structure Contains all registers that should be preserved |
| ►CAT_CellularBase | Class AT_CellularBase |
| CAT_CellularContext | |
| CAT_CellularInformation | Class AT_CellularInformation |
| CAT_CellularNetwork | Class AT_CellularNetwork |
| CAT_CellularStack | Class AT_CellularStack |
| CAT_ControlPlane_netif | |
| CATHandler | Class for sending AT commands and parsing AT responses |
| Cattest_token_ctx | The context for creating an attestation token |
| Cattribute_handle_range_t | Inclusive range of GATT attributes handles |
| Cband_t | Default user application maximum data size for transmission |
| ►Cbase | Base class of all SafeBool instances |
| CSafeBool< T > | Safe conversion of objects in boolean context |
| ►CSafeBool< CallChainOfFunctionPointersWithContext< const ConnectionCallbackParams_t * > > | |
| CCallChainOfFunctionPointersWithContext< const ConnectionCallbackParams_t * > | |
| ►CSafeBool< CallChainOfFunctionPointersWithContext< const DisconnectionCallbackParams_t * > > | |
| CCallChainOfFunctionPointersWithContext< const DisconnectionCallbackParams_t * > | |
| ►CSafeBool< CallChainOfFunctionPointersWithContext< const GattClient * > > | |
| CCallChainOfFunctionPointersWithContext< const GattClient * > | |
| ►CSafeBool< CallChainOfFunctionPointersWithContext< const GattHVXCallbackParams * > > | |
| CCallChainOfFunctionPointersWithContext< const GattHVXCallbackParams * > | |
| ►CSafeBool< CallChainOfFunctionPointersWithContext< const GattReadCallbackParams * > > | |
| CCallChainOfFunctionPointersWithContext< const GattReadCallbackParams * > | |
| ►CSafeBool< CallChainOfFunctionPointersWithContext< const GattServer * > > | |
| CCallChainOfFunctionPointersWithContext< const GattServer * > | |
| ►CSafeBool< CallChainOfFunctionPointersWithContext< const GattWriteCallbackParams * > > | |
| CCallChainOfFunctionPointersWithContext< const GattWriteCallbackParams * > | |
| ►CSafeBool< CallChainOfFunctionPointersWithContext< const LegacyGap * > > | |
| CCallChainOfFunctionPointersWithContext< const LegacyGap * > | |
| ►CSafeBool< CallChainOfFunctionPointersWithContext< const SecurityManager * > > | |
| CCallChainOfFunctionPointersWithContext< const SecurityManager * > | |
| ►CSafeBool< CallChainOfFunctionPointersWithContext< ContextType > > | |
| CCallChainOfFunctionPointersWithContext< ContextType > | Function like object hosting a list of FunctionPointerWithContext |
| ►CSafeBool< CallChainOfFunctionPointersWithContext< TimeoutSource_t > > | |
| CCallChainOfFunctionPointersWithContext< TimeoutSource_t > | |
| ►CSafeBool< CallChainOfFunctionPointersWithContext< unsigned > > | |
| CCallChainOfFunctionPointersWithContext< unsigned > | |
| ►CSafeBool< FunctionPointerWithContext< bool > > | |
| CFunctionPointerWithContext< bool > | |
| ►CSafeBool< FunctionPointerWithContext< const AdvertisementCallbackParams_t * > > | |
| CFunctionPointerWithContext< const AdvertisementCallbackParams_t * > | |
| ►CSafeBool< FunctionPointerWithContext< const ConnectionCallbackParams_t * > > | |
| CFunctionPointerWithContext< const ConnectionCallbackParams_t * > | |
| ►CSafeBool< FunctionPointerWithContext< const DisconnectionCallbackParams_t * > > | |
| CFunctionPointerWithContext< const DisconnectionCallbackParams_t * > | |
| ►CSafeBool< FunctionPointerWithContext< const DiscoveredCharacteristic * > > | |
| CFunctionPointerWithContext< const DiscoveredCharacteristic * > | |
| ►CSafeBool< FunctionPointerWithContext< const DiscoveredService * > > | |
| CFunctionPointerWithContext< const DiscoveredService * > | |
| ►CSafeBool< FunctionPointerWithContext< const GattClient * > > | |
| CFunctionPointerWithContext< const GattClient * > | |
| ►CSafeBool< FunctionPointerWithContext< const GattHVXCallbackParams * > > | |
| CFunctionPointerWithContext< const GattHVXCallbackParams * > | |
| ►CSafeBool< FunctionPointerWithContext< const GattReadCallbackParams * > > | |
| CFunctionPointerWithContext< const GattReadCallbackParams * > | |
| ►CSafeBool< FunctionPointerWithContext< const GattServer * > > | |
| CFunctionPointerWithContext< const GattServer * > | |
| ►CSafeBool< FunctionPointerWithContext< const GattWriteCallbackParams * > > | |
| CFunctionPointerWithContext< const GattWriteCallbackParams * > | |
| ►CSafeBool< FunctionPointerWithContext< const LegacyGap * > > | |
| CFunctionPointerWithContext< const LegacyGap * > | |
| ►CSafeBool< FunctionPointerWithContext< const SecurityManager * > > | |
| CFunctionPointerWithContext< const SecurityManager * > | |
| ►CSafeBool< FunctionPointerWithContext< ContextType > > | |
| CFunctionPointerWithContext< ContextType > | Function like object adapter over freestanding and member functions |
| ►CSafeBool< FunctionPointerWithContext< GattAttribute::Handle_t > > | |
| CFunctionPointerWithContext< GattAttribute::Handle_t > | |
| ►CSafeBool< FunctionPointerWithContext< GattReadAuthCallbackParams * > > | |
| CFunctionPointerWithContext< GattReadAuthCallbackParams * > | |
| ►CSafeBool< FunctionPointerWithContext< GattWriteAuthCallbackParams * > > | |
| CFunctionPointerWithContext< GattWriteAuthCallbackParams * > | |
| ►CSafeBool< FunctionPointerWithContext< OnEventsToProcessCallbackContext * > > | |
| CFunctionPointerWithContext< OnEventsToProcessCallbackContext * > | |
| ►CSafeBool< FunctionPointerWithContext< TimeoutSource_t > > | |
| CFunctionPointerWithContext< TimeoutSource_t > | |
| ►CSafeBool< FunctionPointerWithContext< unsigned > > | |
| CFunctionPointerWithContext< unsigned > | |
| ►Cbase_control_t | POD version of the class control_t |
| Ccontrol_t | Control class for specifying test case attributes |
| CBatteryService | BLE Battery service |
| CBLE | Abstract away BLE-capable radio transceivers or SOCs |
| CBLEInstanceBase | Private interface used to implement the BLE class |
| ►CBlockDevice | A hardware device capable of writing and reading blocks |
| CDataFlashBlockDevice | BlockDevice for DataFlash flash devices |
| CFlashIAPBlockDevice | BlockDevice using the FlashIAP API |
| CI2CEEBlockDevice | BlockDevice for I2C based flash device such as Microchip's 24LC or ATMEL's AT24C ranges |
| CBufferedBlockDevice | Block device for allowing minimal read and program sizes (of 1) for the underlying BD, using a buffer on the heap |
| CChainingBlockDevice | Block device for chaining multiple block devices with the similar block sizes at sequential addresses |
| CExhaustibleBlockDevice | Heap backed block device which simulates failures |
| CFlashSimBlockDevice | Flash simulating block device |
| CHeapBlockDevice | Lazily allocated heap-backed block device |
| CMBRBlockDevice | Block device for managing a Master Boot Record https://en.wikipedia.org/wiki/Master_boot_record |
| CObservingBlockDevice | |
| CProfilingBlockDevice | Block device for measuring storage operations of another block device |
| CReadOnlyBlockDevice | |
| CSlicingBlockDevice | Block device for mapping to a slice of another block device |
| CQSPIFBlockDevice | BlockDevice for SFDP based flash devices over QSPI bus |
| CSDBlockDevice | SDBlockDevice class |
| 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 |
| Cboot_t | |
| CBounded< Rep, Min, Max > | Restrict values of an integer type to a defined range |
| CBounded< uint16_t, 0, 0x01F3 > | |
| Cbuffer_s | Generic buffer structure |
| Cbyte_array_t< array_size > | Model fixed size array values |
| ►Cbyte_array_t< 6 > | |
| Caddress_t | MAC address data type |
| CByteBuffer | |
| CCallback< F > | Callback class based on template specialization |
| ►CCallback< R()> | |
| CFunctionPointerArg1< R, void > | |
| CCallback< R(A0)> | |
| CCallback< R(A0, A1)> | |
| ►CCallback< R(A1)> | |
| CFunctionPointerArg1< R, A1 > | |
| CCallback< R(ArgTs...)> | Callback class based on template specialization |
| CCallback< uint8_t(void)> | |
| CCallback< void()> | |
| CCallback< void(AudioEvent)> | |
| CCallback< void(bool channel_busy)> | |
| CCallback< void(bool up)> | |
| CCallback< void(bool)> | |
| CCallback< void(CIoT_Supported_Opt)> | |
| CCallback< void(const uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr)> | |
| CCallback< void(int)> | |
| CCallback< void(lorawan_event_t)> | |
| CCallback< void(mbed::BlockDevice *)> | |
| CCallback< void(net_stack_mem_buf_t *buf)> | |
| CCallback< void(nsapi_event_t, intptr_t)> | |
| CCallback< void(uint8_t current_channel)> | |
| CCallback< void(uint8_t up, int8_t device_id)> | |
| CCallback< void(uint8_t, uint8_t)> | |
| CCallback< void(void)> | |
| ►CCAN_Message | Holder for single CAN message |
| CCANMessage | CANMessage class |
| Ccan_pinmap_t | |
| ►Ccase_t | POD data structure of the Case class |
| CCase | Test case wrapper class |
| Ccell_callback_data_t | |
| Ccell_signal_quality_t | |
| ►CCellularDevice | Class CellularDevice |
| CAT_CellularDevice | Class AT_CellularDevice |
| ►CCellularInformation | Class CellularInformation |
| CAT_CellularInformation | Class AT_CellularInformation |
| CCellularList< T > | Class CellularList |
| ►CCellularNetwork | An abstract interface for connecting to a network and getting information from it |
| CAT_CellularNetwork | Class AT_CellularNetwork |
| CAT_CellularStack::CellularSocket | |
| CCellularStateMachine | CellularStateMachine class |
| Ccentral_privay_configuration_t | Privacy configuration of the central role |
| 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 |
| CCircularBuffer< T, BufferSize, CounterType > | Templated Circular buffer class |
| CCircularBuffer< char, 256 > | |
| CCircularBuffer< FrameTypes, 3 > | |
| CGap::ConnectionCallbackParams_t | Connection events |
| 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 |
| CGap::ConnectionParams_t | Parameters of a BLE connection |
| Ccontinuous_wave_mode_params_s | |
| ►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) |
| CAT_ControlPlane_netif | |
| Ccore_util_atomic_flag | A lock-free, primitive atomic flag |
| Ccrc_mbed_config | |
| CCriticalSectionLock | RAII object for disabling, then restoring, interrupt state Usage: |
| ►CCThunkBase | |
| CCThunk< T > | Class for created a pointer with data bound to it |
| Cloramac_frame_ctrl_t::ctrl_bits_s | |
| 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 |
| CDeepSleepLock | RAII object for disabling, then restoring the deep sleep mode Usage: |
| CDefaultFormFactor | This is a convenience class for use with the above templates |
| ►CDelegate | |
| CSimpleMessageParser | Basic message parser that aggregates URIParser, TextParser and MimeParser |
| ►CDelegate | |
| CSimpleMessageParser | Basic message parser that aggregates URIParser, TextParser and MimeParser |
| ►CPN512TransportDriver::Delegate | The PN512TransportDriver delegate |
| CPN512Driver | |
| CSimpleMessageParser::Delegate | Delegate invoked when the parser raise an event |
| ►CMessageParser::Delegate | Report parsing event to the application |
| CSimpleMessageParser | Basic message parser that aggregates URIParser, TextParser and MimeParser |
| CGenericRecordParser< ParserImplementation, ParsingResult >::Delegate | Handle that receives parsed values |
| ►CNFCController::Delegate | The NFCController delegate |
| CNFCProcessController | Wrapper class handles calls and callbacks for NFC controller drivers |
| ►CNFCControllerDriver::Delegate | The NFCControllerDriver delegate |
| CNFCController | This class represents a NFC Controller |
| ►CNFCEEPROMDriver::Delegate | The NFCEEPROMDriver delegate |
| CNFCEEPROM | The NFC EEPROM class represents a NFC target device connected using a wired link (I2C, SPI, etc) |
| ►CNFCNDEFCapable::Delegate | |
| ►CNFCRemoteInitiator::Delegate | The NFCRemoteInitiator delegate |
| CNFCProcessController | Wrapper class handles calls and callbacks for NFC controller drivers |
| ►CNFCTarget::Delegate | |
| CNFCEEPROM::Delegate | The NFCEEPROM delegate |
| ►CNFCRemoteEndpoint::Delegate | The NFCRemoteEndpoint base delegate |
| CNFCRemoteInitiator::Delegate | The NFCRemoteInitiator delegate |
| ►CDelegate | |
| CSimpleMessageParser | Basic message parser that aggregates URIParser, TextParser and MimeParser |
| Cdevice_err_t | AT response error with error code and type |
| 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 | |
| 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 |
| Cdirent | |
| CGap::DisconnectionCallbackParams_t | Disconnection event |
| CDisconnectionCompleteEvent | Event produced when a disconnection is complete |
| CDiscoveredCharacteristic | Representation of a characteristic discovered |
| CDiscoveredCharacteristicDescriptor | Representation of a characteristic descriptor discovered |
| CDiscoveredService | Representation of a GATT service discovered |
| CCharacteristicDescriptorDiscovery::DiscoveryCallbackParams_t | Characteristic descriptor discovered event |
| ►CDNS | Base class for DNS provider |
| ►CNetworkInterface | Common interface that is shared between network devices |
| ►CCellularInterface | Common interface that is shared between cellular interfaces |
| ►CCellularContext | CellularContext is CellularInterface/NetworkInterface with extensions for cellular connectivity |
| CAT_CellularContext | |
| ►CEMACInterface | EMACInterface class Implementation of the NetworkInterface for an EMAC-based driver |
| CEthernetInterface | Implementation of the NetworkStack for an EMAC-based Ethernet driver |
| CRDAWiFiInterface | RDAWiFiInterface class Implementation of the NetworkStack for an EMAC-based Ethernet driver |
| CWhdSoftAPInterface | WhdSoftAPInterface class Implementation of the SoftAPInterface for the Whd |
| CWhdSTAInterface | WhdSTAInterface class Implementation of the NetworkStack for the WHD |
| ►CEthInterface | Common interface between Ethernet hardware |
| CEthernetInterface | Implementation of the NetworkStack for an EMAC-based Ethernet driver |
| CNanostackEthernetInterface | Ethernet interface for Nanostack |
| ►CInterfaceNanostack | |
| ►CMeshInterfaceNanostack | |
| CLoWPANNDInterface | 6LoWPAN-ND mesh network interface class |
| CThreadInterface | Thread mesh network interface class |
| CWisunInterface | Wi-SUN mesh network interface class |
| CNanostackEthernetInterface | Ethernet interface for Nanostack |
| CL3IPInterface | L3IPInterface class Implementation of the NetworkInterface for an IP-based driver |
| ►CMeshInterface | Common interface that is shared between mesh hardware |
| CMeshInterfaceNanostack | |
| CPPPInterface | PPPInterface class Implementation of the NetworkInterface for an PPP-service |
| ►CWiFiInterface | Common interface between Wi-Fi devices |
| CRDAWiFiInterface | RDAWiFiInterface class Implementation of the NetworkStack for an EMAC-based Ethernet driver |
| CWhdSTAInterface | WhdSTAInterface class Implementation of the NetworkStack for the WHD |
| ►CNetworkStack | NetworkStack class |
| CAT_CellularStack | Class AT_CellularStack |
| ►COnboardNetworkStack | Mbed OS API for onboard IP stack abstraction |
| CEmacTestNetworkStack | |
| CNanostack | |
| Cdns_application_data | |
| Cdr_range_t | DO NOT MODIFY, WILL BREAK THE API! |
| CDuration< Rep, TB, Range, Forever > | Model BLE durations |
| CDuration< uint16_t, 10000, Range< 0x0A, 0x0C80 > > | |
| CDuration< uint16_t, 1250, Range< 0x06, 0x0C80 > > | |
| CDuration< uint16_t, 625, Range< 0x04, 0xFFFF > > | |
| CDuration< uint32_t, 625, Range< 0x20, 0xFFFFFF > > | |
| 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 |
| CEddystoneService | |
| CAdvertisingDataParser::element_t | Representation of an Advertising Data element |
| ►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 |
| Cfvp_EMAC | |
| CGD32_EMAC | |
| CKinetis_EMAC | |
| CKinetis_EMAC | |
| CLPC17_EMAC | |
| CLPC546XX_EMAC | |
| CNUMAKER_EMAC | |
| COdinWiFiEMAC | |
| CRDA5981x_EMAC | |
| CRZ_A1_EMAC | |
| CSL_EMAC | |
| CSMSC9220_EMAC | |
| CSTM32_EMAC | |
| CWHD_EMAC | |
| CEMAC_CFG_Type | EMAC configuration structure definition |
| Cemac_memory | |
| CEMAC_PACKETBUF_Type | TX Data Buffer structure definition |
| Cenable_if< B, R > | |
| Cenable_if< false, R > | |
| CEndpointResolver | Utility class for resolving endpoints |
| CEnvironmentalService | BLE Environmental Service |
| CUSBEndpointTester::ep_config_t | |
| Cequeue | |
| Cequeue::equeue_background | |
| Cequeue_event | |
| Cequeue::equeue_slab | |
| Ceth_descriptor | |
| CEvent< F > | Event |
| CEvent< void(ArgTs...)> | Event |
| CGap::EventHandler | Definition of the general handler of Gap related events |
| CGattClient::EventHandler | Definition of the general handler of GattClient related events |
| CGattServer::EventHandler | Definition of the general handler of GattServer related events |
| CSecurityManager::EventHandler | The stack will use these functions to signal events to the application, subclass to override handlers |
| Cfactorial_data | |
| Cfailure_t | Contains the reason and location of the failure |
| CFATFS | |
| CFATFS_DIR | |
| CFFOBJID | |
| Cdr_range_t::fields_s | The structure to store the minimum and the maximum datarate |
| CFIL | |
| CFilePath | Class FilePath |
| CFILINFO | |
| Cfirmware_info | |
| Cflags_check_capture | |
| 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 |
| Cfsfat_kv_data_t | |
| Cfslittle_kv_data_t | |
| CFunctionCaller< PortType, FunctionType, f > | |
| CFunctionCaller< PortType, TF1, f > | |
| CFunctionCaller< PortType, TF2, f > | |
| CFunctionCaller< PortType, TF3, f > | |
| CFunctionCaller< PortType, TF4, f > | |
| CFunctionCaller< PortType, TF5, f > | |
| ►CGap | Define device discovery, connection and link management procedures |
| CGap | Define device discovery, connection and link management procedures. |
| CGapAdvertisingData | GAP advertising data builder |
| CGapAdvertisingParams | Parameters defining the advertising process |
| CGapScanningParams | Parameters defining the scan process |
| CGap::GapState_t | Description of the states of the device |
| CGattAttribute | Representation of a GattServer attribute |
| ►CGattCharacteristic | Representation of a GattServer characteristic |
| CReadOnlyArrayGattCharacteristic< T, NUM_ELEMENTS > | Helper class that represents a read-only GattCharacteristic with an array value |
| CReadOnlyGattCharacteristic< T > | Helper class that represents a read only GattCharacteristic |
| CReadOnlyGattCharacteristic< HumidityType_t > | |
| CReadOnlyGattCharacteristic< PressureType_t > | |
| CReadOnlyGattCharacteristic< TemperatureType_t > | |
| CReadOnlyGattCharacteristic< TemperatureValueBytes > | |
| CReadOnlyGattCharacteristic< uint8_t > | |
| CReadWriteArrayGattCharacteristic< T, NUM_ELEMENTS > | Helper class that represents a readable and writable GattCharacteristic with an array value |
| CReadWriteGattCharacteristic< T > | Helper class that represents a readable and writable GattCharacteristic |
| CReadWriteGattCharacteristic< PowerLevels_t > | |
| CReadWriteGattCharacteristic< uint16_t > | |
| CReadWriteGattCharacteristic< uint8_t > | |
| CWriteOnlyArrayGattCharacteristic< T, NUM_ELEMENTS > | Helper class that represents a write-only GattCharacteristic with an array value |
| CWriteOnlyGattCharacteristic< T > | Helper class that represents a write only GattCharacteristic |
| CWriteOnlyGattCharacteristic< Lock_t > | |
| CWriteOnlyGattCharacteristic< uint8_t > | |
| CGattClient | Define procedures required for interacting with a distant GATT server |
| CGattHVXCallbackParams | Handle Value Notification/Indication event |
| CGattReadAuthCallbackParams | GATT read authorization request event |
| CGattReadCallbackParams | GATT Read event definition |
| CGattServer | Construct and operates a GATT server |
| 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 |
| CGPIOIRQMaps | |
| CGPIOMaps | |
| Chandlers_t | A table of handlers |
| CHandleTestCommand | HandleTestCommand turns all the typed-in/serial commands into function calls sent via a eventqueue to the driver shim/wrapper class |
| CHarness | Test Harness |
| Cloramac_mhdr_t::hdr_bits_s | |
| CHeader | Set of constants of a record header |
| CHealthThermometerService | BLE Health Thermometer Service |
| CHeartRateService | BLE Heart Rate Service |
| CHeartRateService::HeartRateValueBytes | |
| CHID_REPORT | |
| Ci2c_pinmap_t | |
| Ci2c_t | Asynch I2C HAL structure |
| CI2CMaps | |
| CI2CSlave | An I2C Slave, used for communicating with an I2C Master device |
| CIEEE754_union | |
| Cinfo | The key size |
| CKVStore::info | Holds key information |
| CBLE::InitializationCompleteCallbackContext | Initialization complete event |
| ►COnboardNetworkStack::Interface | Representation of a stack's view of an interface |
| CEmacTestNetworkStack::Interface | |
| ►CNanostack::Interface | |
| CNanostack::EthernetInterface | |
| CNanostack::MeshInterface | |
| CNanostack::PPPInterface | |
| CNanostackEMACInterface | |
| CNanostackRfInterface | |
| Ciovec_args_t | Holds the iovec parameters that are passed to a service |
| Cipc_consumer_queue_t | |
| Cipc_producer_queue_t | |
| Cis_convertible< From, To > | |
| Cis_type< M, M > | |
| Cis_unsigned< T > | |
| Cis_unsigned< unsigned char > | |
| Cis_unsigned< unsigned int > | |
| Cis_unsigned< unsigned long > | |
| Cis_unsigned< unsigned long long > | |
| Cis_unsigned< unsigned short > | |
| Citems_to_get_t | |
| Ckv_map_entry_t | This structure maps between a string name and a partition configuration |
| ►CKVStore | KVStore class |
| CFileSystemStore | FileSystemStore for Secure Store |
| CSecureStore | TDBStore class |
| CTDBStore | TDBStore class |
| Ckvstore_config_t | This structure represent a KVStore partition configuration |
| ►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 |
| CCellular_driver_L3IP | |
| Clan8742_IOCtx_t | |
| Clan8742_Object_t | |
| Clfs | |
| Clfs_cache | |
| Clfs_config | |
| Clfs_dir | |
| Clfs_dir::lfs_disk_dir | |
| Clfs_entry::lfs_disk_entry | |
| Clfs_superblock::lfs_disk_superblock | |
| Clfs_emubd | |
| Clfs_entry | Littlefs data structures /// |
| Clfs_file | |
| Clfs_file_config | |
| Clfs_free | |
| Clfs_info | |
| Clfs_superblock | |
| Clink_adr_params_s | Structure containing data for local ADR settings |
| ►CLinkedListBase | |
| CLinkedList< T > | |
| CLinkedList< events::TaskBase > | |
| ►CLinkEntry | |
| CAsyncOp | |
| ►CTaskBase | TaskBase |
| CTask< R()> | |
| CTask< R(A0)> | |
| CTask< R(A0, A1)> | Task |
| 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 | |
| Cloramac_keys | |
| Cloramac_mcps_confirm_t | |
| Cloramac_mcps_indication_t | |
| Cloramac_mhdr_t | |
| 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_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 |
| CLoRaWANTimeHandler | / _____) _ | | ( (____ _____ ____ _| |_ _____ ____| |__ ____ | ___ | (_ _) ___ |/ ___) _ \ _____) ) ____| | | || |_| ____( (___| | | | (______/|_____)_|_|_| __)_____)____)_| |_| (C)2013 Semtech |
| CLowPowerTickerWrapper | |
| 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 |
| CMbedCRC< polynomial, width > | CRC object provides CRC generation through hardware or software |
| ►CMbedTester | The base class for controlling the FPGA CI Test Shield |
| CI2CTester | |
| ►CSPITester | |
| CSPIMasterTester | |
| CSPISlaveTester | |
| CUARTTester | |
| Cmd5_context | / |
| Cmem_region | |
| Cmesh_mac_statistics_t | Mesh physical layer statistics |
| Cmesh_nw_statistics_t | Mesh network statistics |
| CMessageBuilder | Construct a NDEF Message |
| CMessageParser | Event driven NDEF Message parser |
| CMIDIMessage | A MIDI message container |
| CMime | Represent a mime object |
| Cmlme_cw_tx_mode_t | |
| Cmlme_join_req_t | |
| Cmulticast_params_s | |
| CNanostackLockGuard | RAII style Nanostack mutex acquisition |
| ►CNanostackPhy | PHY driver class for Nanostack |
| ►CNanostackMACPhy | MAC PHY driver class for Nanostack |
| CNanostackEthernetPhy | Ethernet PHY driver class for Nanostack |
| CNanostackRfPhy | Radio PHY driver class for Nanostack |
| CNanostackPPPPhy | PPP PHY driver class for Nanostack |
| Cnetif | |
| ►CNetStackMemoryManager | |
| ►CEMACMemoryManager | |
| CEmacTestMemoryManager | |
| CNanostackMemoryManager | |
| Cnfc_rf_protocols_bitmask_t | |
| ►CNFCControllerDriver | The abstraction for a NFC controller driver |
| CPN512Driver | |
| CNFCEEPROMDriver | The abstraction for a NFC EEPROM driver |
| ►CNFCNDEFCapable | The base class for all endpoints that can support NDEF content |
| ►CNFCRemoteInitiator | This class represents a remote NFC initiator (the local controller being in target mode) |
| CType4RemoteInitiator | This class is an implementation of the Type 4 tag application |
| ►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) |
| CNFCEEPROM | The NFC EEPROM class represents a NFC target device connected using a wired link (I2C, SPI, etc) |
| ►CNFCRemoteEndpoint | This is the base class for all remote endpoints (initiators and targets) addressable over the air interface |
| CNFCRemoteInitiator | This class represents a remote NFC initiator (the local controller being in target mode) |
| ►CNFCTestShim | Test app driver wrapper |
| CNFCProcessController | Wrapper class handles calls and callbacks for NFC controller drivers |
| Cnil | |
| CNonCopyable< T > | Prevents generation of copy constructor and copy assignment operator in derived classes |
| ►CNonCopyable< ATCmdParser > | |
| CATCmdParser | Parser class for parsing AT commands |
| ►CNonCopyable< BusIn > | |
| CBusIn | A digital input bus, used for reading the state of a collection of pins |
| ►CNonCopyable< BusInOut > | |
| CBusInOut | A digital input output bus, used for setting the state of a collection of pins |
| ►CNonCopyable< BusOut > | |
| CBusOut | A digital output bus, used for setting the state of a collection of pins |
| ►CNonCopyable< CallChain > | |
| CCallChain | Group one or more functions in an instance of a CallChain, then call them in sequence using CallChain::call() |
| ►CNonCopyable< CAN > | |
| CCAN | A can bus client, used for communicating with can devices |
| ►CNonCopyable< ConditionVariable > | |
| CConditionVariable | Synchronization primitive that allows threads to wait until a particular condition occurs |
| ►CNonCopyable< DeviceKey > | |
| CDeviceKey | |
| ►CNonCopyable< DirHandle > | |
| ►CDirHandle | Represents a directory stream |
| CDir | Dir class |
| ►CNonCopyable< EmacTestNetworkStack > | |
| CEmacTestNetworkStack | |
| ►CNonCopyable< Ethernet > | |
| CEthernet | An ethernet interface, to use with the ethernet pins |
| ►CNonCopyable< EventFlags > | |
| CEventFlags | Used to control event flags or wait for event flags other threads control |
| ►CNonCopyable< EventQueue > | |
| CEventQueue | EventQueue |
| ►CNonCopyable< FileBase > | |
| ►CFileBase | Class FileBase |
| ►CFileLike | Class FileLike |
| ►CStream | File stream |
| CSerial | A serial port (UART) for communication with other serial devices |
| CUSBKeyboard | USBKeyboard example |
| CUSBMouseKeyboard | USBMouseKeyboard example |
| CUSBSerial | USBSerial example |
| ►CFileSystemLike | A filesystem-like object is one that can be used to open file-like objects though it by fopen("/name/filename", mode) |
| ►CFileSystem | A file system object |
| CFATFileSystem | FAT file system based on ChaN's FAT file system library v0.8 |
| CLittleFileSystem | LittleFileSystem, a little file system |
| ►CNonCopyable< FileHandle > | |
| ►CFileHandle | Class FileHandle |
| CFile | File class |
| CFileLike | Class FileLike |
| CSerialWireOutput | |
| CUARTSerial | Class providing buffered UART communication functionality using separate circular buffer for send and receive channels |
| CTestFile< FILE_SIZE > | |
| ►CNonCopyable< FileLike > | |
| CFileLike | Class FileLike |
| ►CNonCopyable< FileSystemHandle > | |
| ►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) |
| ►CNonCopyable< FileSystemLike > | |
| CFileSystemLike | A filesystem-like object is one that can be used to open file-like objects though it by fopen("/name/filename", mode) |
| ►CNonCopyable< FlashIAP > | |
| CFlashIAP | Flash IAP driver |
| ►CNonCopyable< I2C > | |
| CI2C | An I2C Master, used for communicating with I2C slave devices |
| ►CNonCopyable< InterruptIn > | |
| CInterruptIn | A digital interrupt input, used to call a function on a rising or falling edge |
| ►CNonCopyable< InterruptManager > | |
| CInterruptManager | Use this singleton if you need to chain interrupt handlers |
| ►CNonCopyable< KVMap > | |
| CKVMap | KVMap class |
| ►CNonCopyable< LoRaPHY > | |
| CLoRaPHY | LoRaPHY Class Parent class for LoRa regional PHY implementations |
| ►CNonCopyable< LoRaWANStack > | |
| CLoRaWANStack | LoRaWANStack Class A controller layer for LoRaWAN MAC and PHY |
| ►CNonCopyable< LowPowerTicker > | |
| ►CLowPowerTicker | Low Power Ticker |
| CLowPowerTimeout | Low Power Timout |
| ►CNonCopyable< LowPowerTimeout > | |
| CLowPowerTimeout | Low Power Timout |
| ►CNonCopyable< LowPowerTimer > | |
| CLowPowerTimer | Low power timer |
| ►CNonCopyable< Mail< T, queue_sz > > | |
| CMail< T, queue_sz > | The Mail class allows you to control, send, receive or wait for mail |
| ►CNonCopyable< MemoryPool< T, pool_sz > > | |
| CMemoryPool< T, queue_sz > | |
| CMemoryPool< T, pool_sz > | Define and manage fixed-size memory pools of objects of a given type |
| ►CNonCopyable< MeshInterfaceNanostack > | |
| CMeshInterfaceNanostack | |
| ►CNonCopyable< Mutex > | |
| CMutex | Used to synchronize the execution of threads |
| ►CNonCopyable< Nanostack > | |
| CNanostack | |
| ►CNonCopyable< Nanostack::Interface > | |
| CNanostack::Interface | |
| ►CNonCopyable< NanostackEthernetInterface > | |
| CNanostackEthernetInterface | Ethernet interface for Nanostack |
| ►CNonCopyable< NVStore > | |
| CNVStore | NVStore class |
| ►CNonCopyable< PlatformMutex > | |
| CPlatformMutex | Used to synchronize the execution of threads |
| ►CNonCopyable< QSPI > | |
| CQSPI | A QSPI Driver, used for communicating with QSPI slave devices |
| ►CNonCopyable< Queue< T, queue_sz > > | |
| CQueue< T, queue_sz > | 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 |
| ►CNonCopyable< RawSerial > | |
| ►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 |
| CGreenteaSerial | |
| ►CNonCopyable< RtosTimer > | |
| CRtosTimer | Allow creating and and controlling of timer functions in the system |
| ►CNonCopyable< ScopedLock< Lockable > > | |
| CScopedLock< Lockable > | RAII-style mechanism for owning a lock of Lockable object for the duration of a scoped block |
| ►CNonCopyable< ScopedRamExecutionLock > | |
| CScopedRamExecutionLock | RAII object for disabling, then restoring RAM execute never mode Usage: |
| ►CNonCopyable< ScopedRomWriteLock > | |
| CScopedRomWriteLock | RAII object for disabling, then restoring ROM write never mode Usage: |
| ►CNonCopyable< Semaphore > | |
| CSemaphore | Used to manage and protect access to a set of shared resources |
| ►CNonCopyable< Serial > | |
| CSerial | A serial port (UART) for communication with other serial devices |
| ►CNonCopyable< SerialBase > | |
| ►CSerialBase | A base class for serial port implementations Can't be instantiated directly (use Serial or RawSerial) |
| 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 |
| CSerial | A serial port (UART) for communication with other serial devices |
| CUARTSerial | Class providing buffered UART communication functionality using separate circular buffer for send and receive channels |
| ►CNonCopyable< SPI > | |
| CSPI | A SPI Master, used for communicating with SPI slave devices |
| ►CNonCopyable< SPISlave > | |
| CSPISlave | A SPI slave, used for communicating with a SPI master device |
| ►CNonCopyable< Stream > | |
| CStream | File stream |
| ►CNonCopyable< SysTimer< US_IN_TICK, IRQ > > | |
| CSysTimer< US_IN_TICK, IRQ > | The SysTimer class is used to provide timing for system suspension, and the idle loop in TICKLESS mode |
| ►CNonCopyable< Thread > | |
| CThread | Allow defining, creating, and controlling thread functions in the system |
| ►CNonCopyable< Ticker > | |
| ►CTicker | A Ticker is used to call a function at a recurring interval |
| CLowPowerTicker | Low Power Ticker |
| CTimeout | A Timeout is used to call a function at a point in the future |
| ►CNonCopyable< Timeout > | |
| CTimeout | A Timeout is used to call a function at a point in the future |
| ►CNonCopyable< TimerEvent > | |
| ►CTimerEvent | Base abstraction for timer interrupts |
| CSysTimer< US_IN_TICK, IRQ > | The SysTimer class is used to provide timing for system suspension, and the idle loop in TICKLESS mode |
| CTicker | A Ticker is used to call a function at a recurring interval |
| ►CNonCopyable< UARTSerial > | |
| CUARTSerial | Class providing buffered UART communication functionality using separate circular buffer for send and receive channels |
| ►CNonCopyable< USBEndpointTester > | |
| CUSBEndpointTester | |
| ►CNonCopyable< USBTester > | |
| CUSBTester | |
| ►CNonCopyable< Watchdog > | |
| CWatchdog | A hardware watchdog timer that resets the system in the case of system failures or malfunctions |
| CNOOS_IP | |
| CNOOS_PACKET_POOL | |
| Cnsapi_addr | IP address structure for passing IP addresses by value |
| Cnsapi_ip_mreq | Nsapi_ip_mreq structure |
| Cnsapi_latency_req | Nsapi_latency_req structure |
| Cnsapi_stack | Nsapi_stack structure |
| Cnsapi_stack_api | Nsapi_stack_api structure |
| Cnsapi_stagger_req | Nsapi_stagger_req structure |
| Cnsapi_wifi_ap | Nsapi_wifi_ap structure |
| Cnvmem_param_t | |
| CWhdSTAInterface::OlmInterface | |
| CBLE::OnEventsToProcessCallbackContext | Events to process event |
| ►COperationListBase | |
| COperationList< T > | |
| COperationList< AsyncRead > | |
| COperationList< AsyncSend > | |
| COperationList< AsyncWait > | |
| COperationList< AsyncWrite > | |
| CAllArgs< B0 >::Operations< T, _ > | |
| CAllArgs< B0, B1 >::Operations< T, _ > | |
| CAllArgs< B0, B1, B2 >::Operations< T, _ > | |
| CAllArgs< B0, B1, B2, B3 >::Operations< T, _ > | |
| CAllArgs< B0, B1, B2, B3, B4 >::Operations< T, _ > | |
| CAllArgs< B0, B1, B2, B3, B4, B5 >::Operations< T, _ > | |
| CAllArgs< B0, B1 >::Operations< T *, R(U::*)()> | |
| CAllArgs< B0, B1, B2 >::Operations< T *, R(U::*)(B2)> | |
| CAllArgs< B0, B1, B2, B3 >::Operations< T *, R(U::*)(B2, B3)> | |
| CAllArgs< B0, B1, B2, B3, B4 >::Operations< T *, R(U::*)(B2, B3, B4)> | |
| CAllArgs< B0, B1, B2, B3, B4, B5 >::Operations< T *, R(U::*)(B2, B3, B4, B5)> | |
| CAllArgs< B0, B1 >::Operations< T, R(U::*)() const > | |
| CAllArgs< B0, B1 >::Operations< T, R(U::*)() const volatile > | |
| CAllArgs< B0, B1 >::Operations< T, R(U::*)() volatile > | |
| CAllArgs< B0, B1, B2 >::Operations< T, R(U::*)(B2) const > | |
| CAllArgs< B0, B1, B2 >::Operations< T, R(U::*)(B2) const volatile > | |
| CAllArgs< B0, B1, B2 >::Operations< T, R(U::*)(B2) volatile > | |
| CAllArgs< B0, B1, B2, B3 >::Operations< T, R(U::*)(B2, B3) const > | |
| CAllArgs< B0, B1, B2, B3 >::Operations< T, R(U::*)(B2, B3) const volatile > | |
| CAllArgs< B0, B1, B2, B3 >::Operations< T, R(U::*)(B2, B3) volatile > | |
| CAllArgs< B0, B1, B2, B3, B4 >::Operations< T, R(U::*)(B2, B3, B4) const > | |
| CAllArgs< B0, B1, B2, B3, B4 >::Operations< T, R(U::*)(B2, B3, B4) const volatile > | |
| CAllArgs< B0, B1, B2, B3, B4 >::Operations< T, R(U::*)(B2, B3, B4) volatile > | |
| CAllArgs< B0, B1, B2, B3, B4, B5 >::Operations< T, R(U::*)(B2, B3, B4, B5) const > | |
| CAllArgs< B0, B1, B2, B3, B4, B5 >::Operations< T, R(U::*)(B2, B3, B4, B5) const volatile > | |
| CAllArgs< B0, B1, B2, B3, B4, B5 >::Operations< T, R(U::*)(B2, B3, B4, B5) volatile > | |
| CCellularNetwork::operator_names_t | Cellular operator names in numeric and alpha format |
| CCellularNetwork::operator_t | 3GPP TS 27.007 - 7.3 PLMN selection +COPS |
| 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 |
| CEddystoneConfigService::Params_t | |
| CURIBeaconConfigService::Params_t | |
| CPasskeyAscii | Passkey stored as a string of digits |
| CMessageBuilder::PayloadBuilder | Build a record payload |
| Cpbuf | |
| CCellularContext::pdpcontext_params_t | PDP Context information |
| 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 |
| CPeripheralList | |
| CScanParameters::phy_configuration_t | Scan configuration of a physical channel |
| Cphy_set_t | Type that describe a set of PHY(sical) transports |
| CPinList | |
| CPinMap | |
| ►CPN512TransportDriver | The PN512 supports multiple transport mechanisms (SPI, I2C, UART): this class provides a unified API across these transports |
| CPN512SPITransportDriver | |
| Cpollfd | |
| Cpollfh | |
| CPort< N, PinMapType, FormFactorType, FunctionType > | |
| 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 |
| ►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 |
| CGattCharacteristic::PresentationFormat_t | Value of a Characteristic Presentation Format descriptor |
| CDiscoveredCharacteristic::Properties_t | Properties of a discovered characteristic |
| 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 | |
| CPwmOut | A pulse-width modulation digital output |
| 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 |
| Cqspi_pinmap_t | |
| CQspiCommand | |
| ►CQUECTEL_BG96 | |
| CSTModCellular | |
| 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 | |
| Crda5991h_user_data | |
| Crda_enetdata_t | |
| Crda_msg | |
| CRecord | Represent a record |
| ►CRecordParser | Parse a record |
| ►CGenericRecordParser< MimeParser, Mime > | |
| CMimeParser | Parse a Mime payload |
| ►CGenericRecordParser< TextParser, Text > | |
| CTextParser | Parse a Text |
| ►CGenericRecordParser< URIParser, URI > | |
| CURIParser | Parser of a URI |
| CGenericRecordParser< ParserImplementation, ParsingResult > | GenericRecordParser |
| CRecordParserChain | Record parser chain |
| CRecordType | Encode a record type |
| CCellularNetwork::registration_params_t | Network registration information |
| Cremove_reference< T > | |
| Cremove_reference< T & > | |
| Cremove_reference< T && > | |
| CResetReason | A platform-independent method of checking the cause of the last system reset |
| 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 |
| CSafeEnum< Target, LayoutType > | Helper class used to define safe enumerations |
| ►CSafeEnum< adv_data_appearance_t, uint16_t > | |
| Cadv_data_appearance_t | Enumeration of values for the adv_data_type_t::APPEARANCE |
| ►CSafeEnum< adv_data_type_t, uint8_t > | |
| Cadv_data_type_t | |
| ►CSafeEnum< advertising_data_status_t, uint8_t > | |
| Cadvertising_data_status_t | Used to indicate if the packet is complete and if it's truncated |
| ►CSafeEnum< advertising_filter_policy_t, uint8_t > | |
| Cadvertising_filter_policy_t | Advertising policy filter modes |
| ►CSafeEnum< advertising_type_t, uint8_t > | |
| Cadvertising_type_t | Encapsulates the peripheral advertising modes |
| ►CSafeEnum< att_security_requirement_t, uint8_t > | |
| Catt_security_requirement_t | Security requirement that can be attached to an attribute operation |
| ►CSafeEnum< clock_accuracy_t, uint8_t > | |
| Cclock_accuracy_t | Accuracy of the master clock |
| ►CSafeEnum< coded_symbol_per_bit_t, uint8_t > | |
| Ccoded_symbol_per_bit_t | Type describing the number of symbols per bit in le coded PHY |
| ►CSafeEnum< connection_role_t, uint8_t > | |
| Cconnection_role_t | Enumeration of GAP roles |
| ►CSafeEnum< controller_supported_features_t, uint8_t > | |
| Ccontroller_supported_features_t | Features supported by the controller |
| ►CSafeEnum< disconnection_reason_t, uint8_t > | |
| Cdisconnection_reason_t | Enumeration of disconnection reasons received in a disconnection event |
| ►CSafeEnum< duplicates_filter_t, uint8_t > | |
| Cduplicates_filter_t | Scanning policy filter mode |
| ►CSafeEnum< initiator_filter_policy_t, uint8_t > | |
| Cinitiator_filter_policy_t | Filter policy that you can use during connection initiation |
| ►CSafeEnum< io_capability_t, uint8_t > | |
| Cio_capability_t | Type that describe the IO capability of a device; it is used during Pairing Feature exchange |
| ►CSafeEnum< link_encryption_t, uint8_t > | |
| Clink_encryption_t | Type that describes link's encryption state |
| ►CSafeEnum< local_disconnection_reason_t, uint8_t > | |
| Clocal_disconnection_reason_t | Enumeration of disconnection reasons that should be transmited to the peer |
| ►CSafeEnum< own_address_type_t, uint8_t > | |
| Cown_address_type_t | Type used to model the own address used during the following GAP operations: advertising, scanning and initiating |
| ►CSafeEnum< pairing_failure_t, uint8_t > | |
| Cpairing_failure_t | Type that describe a pairing failure |
| ►CSafeEnum< peer_address_type_t, uint8_t > | |
| Cpeer_address_type_t | Type that describes a peer device address type |
| ►CSafeEnum< phy_t, uint8_t > | |
| Cphy_t | Type that describes a bluetooth PHY(sical) transport |
| ►CSafeEnum< random_address_type_t, uint8_t > | |
| Crandom_address_type_t | Type that describes a random device address type |
| ►CSafeEnum< scanning_filter_policy_t, uint8_t > | |
| Cscanning_filter_policy_t | Scanning policy filter mode |
| ►CSafeEnum< target_peer_address_type_t, uint8_t > | |
| Ctarget_peer_address_type_t | Type of an address to connect to |
| CScanParameters | Parameters defining the scan process |
| CScanRequestEvent | Event produced when a peer requests a scan response from the advertiser |
| CScanTimeoutEvent | Event generated when scan times out |
| Csector_info_t | Sector information structure |
| CSecurityManager | Overview |
| Cserial_fc_pinmap_t | |
| Cserial_pinmap_t | |
| Cserial_t | Asynch serial HAL structure |
| CServiceDiscovery | Host callback types needed by the service discovery procedure |
| CUSBDevice::setup_packet_t | |
| Cshared_data_tlv_entry | Shared data TLV entry header format |
| Cshared_data_tlv_header | Shared data TLV header |
| CSharedPtr< T > | Shared pointer class |
| CSharedPtr< mbed::nfc::NFCRemoteInitiator > | |
| CSingletonPtr< T > | Utility class for creating and using a singleton |
| CSingletonPtr< PlatformMutex > | |
| CSmartPoster | Smart poster object |
| ►CSocket | Socket interface |
| ►CInternetSocket | Socket implementation that uses IP network stack |
| ►CInternetDatagramSocket | InternetDatagramSocket socket implementation |
| CICMPSocket | ICMP socket implementation |
| CUDPSocket | UDP socket implementation |
| ►CTCPSocket | TCP socket connection |
| CTCPServer | TCP socket server |
| CCellularNonIPSocket | Socket implementation for cellular Non-IP data delivery(NIDD) |
| ►CTLSSocketWrapper | TLSSocket is a wrapper around Socket for interacting with TLS servers |
| ►CDTLSSocketWrapper | DTLSSocketWrapper implement DTLS stream over the existing Socket transport |
| CDTLSSocket | DTLSSocket implement DTLS stream over UDP Socket |
| CTLSSocket | TLSSocket is a wrapper around TCPSocket for interacting with TLS servers |
| CSocketAddress | SocketAddress class |
| CSocketStats | SocketStats class |
| CSpan< ElementType, Extent > | Nonowning view to a sequence of contiguous elements |
| CSpan< const uint8_t > | |
| CSpan< ElementType, SPAN_DYNAMIC_EXTENT > | Span specialization that handle dynamic size |
| CSpan< uint8_t > | |
| CSpecification | Test specification containing the setup and teardown handlers and test cases |
| Cspi_capabilities_t | Describes the capabilities of a SPI peripherals |
| Cspi_pinmap_t | |
| Cspi_t | Asynch SPI HAL structure |
| CSPIMaps | |
| CSPINoCSMaps | |
| CSPISlaveMaps | |
| 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 | |
| CStaticInterface< Impl, Interface > | Static Interface helper class |
| Cstatvfs | |
| CSynchronizedIntegral< T > | 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 |
| CTask< F > | |
| CTask< void()> | |
| CTask< void(const setup_packet_t *)> | |
| ►CTaskQueue | TaskQueue |
| CPolledQueue | PolledQueue |
| CCharacteristicDescriptorDiscovery::TerminationCallbackParams_t | Characteristic descriptor discovery ended event |
| Ctest_count_t | |
| Ctest_data | |
| Ctest_info_t | |
| Ctest_status_buffer_t | |
| CText | Represent the well known type text |
| 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 | |
| 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< TimeoutTesterType > | |
| ►CTimeoutType | |
| CAttachTester< TimeoutType > | |
| CAttachUSTester< TimeoutType > | |
| ►CTimer | |
| CLowPowerTimer | Low power timer |
| Ctimer_event_t | Timer object description |
| Ctimeval | |
| CTransaction< Class > | Transaction class defines a transaction |
| Ctransaction_t | Transaction structure |
| 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 |
| CUpdateConnectionParametersRequestEvent | Event received when a peer wants to change the connection parameters |
| CURI | Model the well known type URI |
| CURIBeaconConfigService | UriBeacon Configuration Service |
| Cusb_ep_entry_t | |
| Cusb_ep_table_t | |
| ►CUSBPhy | Abstract interface to physical USB hardware |
| CUSBPhyHw | |
| ►CUSBPhyEvents | Event handler for USBPhy |
| ►CUSBDevice | Core USB Device driver |
| CUSBAudio | USBAudio example |
| ►CUSBCDC | |
| CUSBSerial | USBSerial example |
| CUSBCDC_ECM | |
| CUSBEndpointTester | |
| ►CUSBHID | USBHID example |
| CUSBKeyboard | USBKeyboard example |
| CUSBMouse | USBMouse example |
| CUSBMouseKeyboard | USBMouseKeyboard example |
| CUSBMIDI | USBMIDI example |
| ►CUSBMSD | USBMSD class: generic class in order to use all kinds of blocks storage chip |
| CTestUSBMSD | |
| CUSBTester | |
| Cuse_gpio_ssel_t | |
| 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 |
| CUserAllocatedEvent< F, A > | |
| CUserAllocatedEvent< F, void(ArgTs...)> | UserAllocatedEvent |
| 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_interface_shared_info_t | |
| CGap::Whitelist_t | Representation of a whitelist of addresses |
| Cwiced_packet_t | |
| Cwiced_tcp_server_t | |
| Cwiced_tcp_socket_struct | |
| Cwiced_udp_socket_struct | |
| ►CWiFiAccessPoint | WiFiAccessPoint class |
| CWhdAccessPoint | WhdAccessPoint class |
| CWisunBorderRouter | Wi-SUN Border Router 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 |
| Cws_br_info | Struct br_information Border router dynamic information |
| Cws_br_route_info | Struct br_route_info is parent child relation structure |
| Cws_rpl_info | Struct ws_rpl_info Wi-SUN router RPL information |
