 |
GM6000 Digital Heater Controller Branch: main
SDX-1330
|
|
GM6000 Digital Heater Controller Branch: main
SDX-1330
|
| ▼NAjax | The 'Ajax' namespace is the root name space all GM6000 application specific source code |
| ►NAlerts | The 'Alerts' namespace is responsible for the high level management of alerts, e.g |
| CSummary | This class manages the content of the Alert Summary model point |
| ►NDm | The 'Dm' namespace contains the model point types that are specific to the Ajax application |
| ►CMpAlert | This class provides a concrete implementation for a basic Alert that has following attributes: |
| CData | The MP's Data container |
| ►CMpAlertSummary | This class provides a concrete implementation for an Alert Summary |
| CData | The MP's Data container |
| CMpFanMode | Concrete Model Point the FanMode Enum |
| CMpFlcConfig | This class provides a concrete implementation for a Point who's data a Ajax::Heating::Flc::Config_t data structure |
| NEros | The 'Eros' namespace contains the start-up and shutdown business logic for the Eros application |
| ►NHeating | The 'Heating' namespace is the root name space for Heating Control algoritm(s) for the GM6000 DHC |
| ►NFlc | The 'Flc' namespace contains a Fuzzy Logic Controller that is used by control algorithm to calculate changes to the capacity output signal |
| CApi | This class implements the Fuzzy logic controller as defined by the SWA-1330 GM6000 Fuzzy Logic Temperature Control document |
| CConfig_T | Struct defines the geometry of the input membership function |
| ►NIo | The 'Io' namespace is the business logic that is responsible for 'translating' physical hardware signal to/from model point values |
| CApi | This class is responsible for 'translating' physical hardware signal to/from model point values |
| ►NSimulated | The 'Simulated' namespace is the root name space for a primitive house simulator |
| CCmd | This class implements a Shell command |
| CHouse | This class glues the House Simulation into the Heater Application |
| ►NSupervisor | The 'Supervisor' namespace is the top-level business logic for executing the heating algorithm |
| CApi | This class implements the Heating Algorithm Supervisor |
| CFsmContext_ | Context (aka actions/guards) for my Finite State Machine |
| CFsmEventQueue_ | Event Queue for FSM events |
| NLogging | The 'Logging' namespace provides the Ajax and Eros Application specific logging Categories and Message IDs |
| ►NMain | The 'Main' namespace contains the start-up and and shutdown business logic for the Ajax application |
| CMetricsRecord | This concrete class implements the "Record" class for storing user settings |
| CPersonalityRecord | This concrete class implements the "Record" class for storing the 'Personality' settings |
| CTShellSecurity | Validates the TShell login password |
| CUserRecord | This concrete class implements the "Record" class for storing user settings |
| ►NMetrics | The 'Metrics' namespace is responsible for the high level collections of metrics |
| CApi | This class manages the collection of Metrics and triggering their updates to persistent storage |
| ►NScreenMgr | The 'ScreenMgr' namespace is the root name for a Screen Manager |
| ►CApi | This class implements the Screen Manager |
| CNavigationElement | Type for 'elements' in the Navigation Stack |
| CDisplayApi | This class defines the Screen Manager's interface to Graphic library |
| CMockScreen | This class implements a 'Mock' ScreenApi instances |
| CMockStaticScreen | This class implements a 'Mock' StaticScreenApi instances |
| CMpScreenApiPtr | This class provides a concrete implementation for a Point who's data is a ScreenApi pointer |
| CMpStaticScreenApiPtr | This class provides a concrete implementation for a Point who's data is a StaticScreenApi pointer |
| CNavigation | This class defines the interface - used by ScreenApi instances - to navigate to other screen instances |
| CScreenApi | This class defines the interface for a 'Screen' |
| CStaticScreenApi | This class defines interface for Screens that only contain static data |
| ►NSimHouse | The 'SimHouse' namespace contains a primitive simulation - with respect to heating/cooling - of a house |
| CHouse | This class provides a 'functional' simulation of house with respect to Outdoor temperature, Indoor temperature, and active HVAC capacity |
| CSystem | This class simulates a "system" whose state is affected by its environment and any number of control systems that may change the environment over time |
| ►NTShell | The 'TShell' namespace contains the implementation of TShell commands that are specific to the Ajax namespace/application |
| CProvision | This class implements a TShell command that is used to provision a GM6000 unit at production |
| CState | This class implements a TShell command that displays the current 'state' of the unit |
| CUi | This class implements a TShell command that generates a UI event |
| ►NUi | The 'Ui' namespace is the root name for UI components, widgets, etc |
| ►NAbout | The 'About' namespace contains the implementation for the Ajax About Screen |
| CScreen | This class implements the About screen |
| ►NEditSetpt | The 'EditSetpt' namespace contains the implementation for the Ajax Edit Setpoint Screen |
| CScreen | This class implements the Edit setpoint screen |
| ►NError | The 'Error' namespace contains the implementation for the Ajax Error/Halt-UI screen |
| CScreen | This class implements the splash screen |
| ►NHome | The 'Home' namespace contains the implementation for the Ajax Home Screen |
| CScreen | This class implements the Home screen |
| ►NShutdown | The 'Shutdown' namespace contains the implementation for the Ajax Shutdown Screen |
| CScreen | This class implements the shutdown screen |
| ►NSplash | The 'Splash' namespace contains the implementation for the Splash screen |
| CScreen | This class implements the splash screen |
| ►NStatusIndicator | The 'StatusIndicator' namespace contains the business logic to drive the state/color of the display board's RGB LED |
| CApi | This class manages the what color/on-off-state of the RGB LED |
| CLogicalButtons | This concrete class translates physical button actions into logical UI Button events |
| CPicoDisplay | This concrete class implements the Ajax::ScreenMgr::DisplayApi using the Driver::PicoDisplay driver |
| ▼NBsp | The 'Bsp' namespace is the root name space for Board Support Packages (BSPs) that support a the common/generic interface defined in this root namespace |
| NUserSpace | This 'Bsp::User' namespace contains a 'Null' BSP for applications that run on a desktop OS in user space |
| ▼NCpl | The 'Cpl' namespace is the root name space for the Colony |
| ►NChecksum | The Checksum namespace provides classes for various types of Checksum, CRC, Hashes, etc |
| CApi16 | This class provides an interface for calculate a 16 bit wide Checksum |
| CApi32 | This class provides an interface for calculate a 32 bit wide Checksum |
| CApiMd5 | This class provides an interface for performing a MD5 Hash on a collection of bytes |
| CCrc16CcittFast | This class provides an implementation for the 16 Bit CRC-CCITT standard |
| CCrc32EthernetFast | This class provides an implementation for the 32 Bit "Ethernet" standard |
| CFletcher16 | This class provides an implementation for the 16 Bit wide Fletcher Checksum |
| CMd5Aladdin | This class provides an implementation for the MD5 Hash interface that is wrapper to the third party MD5 Library code developed by L |
| ►NContainer | The Container namespace provides classes for various types of containers |
| CAvlTree_ | This concrete class implements the core functionality of for AVL Binary tree (i.e |
| CDHashTable_ | This concrete class implements the core functionality for a Dictionary and/or Hash Table |
| CDictionary | This template class implements a Dictionary and/or Hash Table |
| CDictItem | This abstract class represents a item that can be contained in Dictionary |
| CDList | This template class implements a Doubly linked list which maintains the ordering imposed on it by the application |
| CExtendedItem | This class is used by the Container classes to implement a various types of DOUBLY linked containers |
| CFDictionary | This template class implements a Dictionary and/or Hash Table with a FIXED memory allocation (i.e |
| ►CFHashTable_ | This concrete class implements the core functionality for a Dictionary and/or Hash Table |
| CMemDList | Struct to allocate Memory for array of hash buckets |
| CHashTable_ | This concrete provides a collection of functions used by the 'Hash Table' classes |
| CHashTableStats | This struct defines what usage/stats can be retrieved from a Hash table |
| CItem | This class is used by the Container classes to implement a various types of singly linked containers |
| CKey | This abstract class defines the interface that a contained object must support if it has comparable key associated with it |
| CKeyLiteralString | This class provides a 'Key' wrapper for a C string literal |
| CKeyPlainType | This template class is used to generate Key classes for most of the C/C++ primitive data types |
| CKeyStringBuffer | This class provides a 'Key' wrapper for a array of Character of length N, i.e |
| CMap | This template class implements an Map using an AVL Binary tree (i.e |
| CMapItem | This abstract class represents a item that can be contained in an Map (aka a sorted list implemented using an AVL tree) |
| CReferenceItem | This template class defines wrapper class - that is makes a reference 'listable' |
| CRingBuffer | This template class implements a Ring Buffer |
| CRingBufferMP | This template class implements a THREAD SAFE Ring Buffer AND it maintains/reports the number of elements stored in the ring buffer via a Model Point |
| CRingBufferMT | This template class implements a THREAD SAFE Ring Buffer |
| CSList | This template class implements a singly linked list which maintains the ordering imposed on it by the application |
| CStack | This template class implements a Stack that has a fixed depth and stores copies of the data items |
| ►NDm | The 'Dm' namespace is the root namespace for a framework of the Data Model architecture pattern |
| ►NMp | The Mp namespace provides concrete Model Points for basic C types and other generic/utility Model Points |
| ►CArrayBase_ | This a mostly concrete class provides 'common' implementation for a Model Point who's data is a array of elements |
| CMetaData_T | Meta data for read/write/copy operations |
| CArrayDouble | Double Array |
| CArrayFloat | Float Array |
| CArrayInt32 | Int32_t Array |
| CArrayInt64 | Int64_t Array |
| CArrayInt8 | Int8_t Array |
| CArrayUint32 | Uint32_t Array |
| CArrayUint64 | Uint64_t Array |
| CArrayUint8 | Uint8_t Array |
| CBitArray16 | This template class provides a concrete implementation for a Point who's data is a a bit array of N bits |
| CBitArray_ | This template class extends the Numeric<> class to provide bit operation on the numeric value |
| CBool | This class provides a concrete implementation for a Point who's data is a bool |
| CDouble | This class provides a concrete implementation for a Point who's data is a double |
| CElapsedPrecisionTime | This class provides a concrete implementation for a Point who's data a Cpl::System::ElapsedTime::Precision_T data structure |
| CEnum_ | This template class provides a mostly concrete implementation for a Model Point who's data is a BETTER_ENUM type |
| CFloat | This class provides a concrete implementation for a Point who's data is a float |
| CInt32 | This class provides a concrete implementation for a Point who's data is a int32_t |
| CInt64 | This class provides a concrete implementation for a Point who's data is a int64_t |
| CNumeric | This template class provides a mostly concrete implementation for a Model Point who's data is a C numeric primitive type of type: 'ELEMTYPE' |
| CNumericArray_ | This mostly concrete template class implements an 'numeric Array' Model Point with an element size of N |
| CNumericArrayBase_ | This template class extends the implementation of ArrayBase_ to support the toJSON() and fromJSON_() methods for numeric element types |
| CPointer_ | This template class extends the implementation of Numeric<> class to support the pointers instead of integers |
| CRefCounter | This class provides a concrete implementation for a Point who's data is 32 bit unsigned reference counter |
| CString | This concrete template class provides the storage for a Point who's data is a null terminated string |
| CStringBase_ | This mostly concrete class provides the base implementation for a Point who's data is a null terminated string |
| CUint32 | This class provides a concrete implementation for a Point who's data is a uint32_t |
| CUint64 | This class provides a concrete implementation for a Point who's data is a uint64_t |
| CVoid | This class provides a concrete implementation for a Point who's data is a void pointer |
| ►NPersistent | The 'Persistent' namespace provides a persistent storage mechanism for Model Points |
| ►CEraseRequest | This abstract class define ITC message type and payload for the application to request invalidating/corrupting the Record in persistent storage (i.e |
| CPayload | Payload for Message |
| CEraseResponse | This abstract class define ITC message type and payload for asynchronous response (to the application) of a Erase message |
| ►CFlushRequest | This abstract class define ITC message type and payload for the application to request flushing the Record to persistent storage |
| CPayload | Payload for Message: GetLatest |
| CFlushResponse | This abstract class define ITC message type and payload for asynchronous response (to the application) of a Flush message |
| ►CRecord | This mostly concrete class implements the Cpl::Persistent::Record interface where a Record instance contains the data from N model points |
| CItem_T | This data structure associates a Data Model subscriber instance with a Model Point instance |
| ►NTShell | The 'TShell' namespace contains the implementation of TShell commands that access Model Points at runtime |
| CDm | This class implements a TShell command |
| CEventLoop | This class extends the Cpl::System::EventLoop class to support the asynchronous change notification generated from Model Points |
| CMailboxServer | This class extends the Cpl::Dm::EventLoop and Cpl::Itc:Mailbox classes to support the asynchronous change notification generated from Model Points with ITC messaging |
| CModelDatabase | This concrete class implements a simple Model Database |
| CModelDatabaseApi | This class defines the basic operations that can be performed on a Model Base |
| CModelPoint | This mostly abstract class defines the interface for a Model Point |
| CModelPointCommon_ | This concrete class provide common infrastructure for a Model Point |
| CNotificationApi_ | This class has PACKAGE Scope, i.e |
| CPeriodicScheduler | This class extends the Cpl::Dm::MailboxServer class to add periodic scheduling to an event based 'thread' |
| CSubscriber | This template class defines a type safe Subscriber |
| CSubscriberApi | This abstract class defines the Subscriber interface - for change notifications - to a Model Points data/state |
| CSubscriberBase | This mostly concrete class defines the Subscriber interface - for change notifications - to a Model Points data/state |
| CSubscriberComposer | This template class is a composer pattern/class that manages the callback function for a Model Point's Subscribers/Observers change notification |
| ►NIo | The Io namespace provides the base/common interfaces for reading and writing data from/to streams and files |
| ►NFile | The File namespace provides the base/common interfaces for reading and writing data from/to Files |
| NArduino | The Arduino namespace provides an interface for Arduino boards that support a 'file system' |
| ►NLittlefs | The 'Littlefs' namespace implements the CPL file abstractions using the open source 'littlefs' file system (https://github.com/littlefs-project/littlefs) |
| ►NTShell | The 'TShell' namespace provides the TShell command(s) for various file system commands |
| CFs | This class implements a TShell command for various file system commands for a system that is using a Littlefs file system |
| ►CApi | This 'singleton' class is used to create and manage the littlefs file system |
| CVolume_T | This structure defines the configuration and the underlying block driver used for each volume instance |
| CBdFile | Concrete Block Driver that uses the Host's file system for the persistent storage media |
| ►CBdSpi | Concrete Block Driver for a 'traditional' SPI based NOR flash |
| CJedecID_T | JEDEC ID |
| CBlockDriverApi | This partial abstract class defines the interface for block drivers |
| CFileDesc_T | This struct defines the memory need per opened file |
| CFileMemoryPool | Memory pool for opened files |
| ►CApi | This concrete class defines the interface for handling and manipulating entries in the System's File system |
| CDirectoryWalker | This abstract class defines the client interface for walking the contents of a directory, i.e |
| CInfo | This data structure defines status attributes for a file system entry |
| CCommon_ | This private concrete class is a helper class that implements the common functions for the handling files |
| ►CDirList_ | This private concrete does the work for Api::walkDirectory() method |
| CDirEntry_T | Structure to hold the directory name and depth |
| CInput | This concrete class provides a platform independent 'standard' implementation of a Cpl::Io::File::Input object |
| CInputApi | This abstract class defines the interface for a Random Access Input File |
| CInputOutput | This concrete class provides a platform independent 'standard' implementation of an InputOutputFileApi object |
| CInputOutputApi | This abstract class defines the interface for a Random Access Input Output File |
| CNull | This concrete class implements a NULL InputOutputApi File that all of its input operations return 'End-of-File' (i.e |
| CObjectApi | This abstract class defines the basic additional functionality, beyond that of a stream, for a file |
| COutput | This concrete class provides a platform independent 'standard' implementation of a Cpl::Io::File::Output object |
| COutputApi | This abstract class defines the interface for a Random Access Input File |
| ►NRam | The 'Ram' namespace provides an implementation of the Cpl::Io::InputOutput interface using RAM as the media |
| CInputOutput | This concrete class implements an InputOutput stream using a Ring Buffer |
| ►NSerial | The Serial namespace provides interfaces for accessing Serial types of devices using the Cpl::Io paradigm, aka file descriptors for Serial Ports |
| ►NAdafruit | The Adafruit namespace provides interfaces for Adafruit specific hardware/boards |
| ►NNrf5 | The Nrf5 namespace provides interfaces for Adafruit's Arduino boards that use a Nordic Semiconductor's nRF5 based SOC |
| ►NBLE | The BLE namespace provides interfaces for Adafruit's Arduino boards that use a Nordic Semiconductor's nRF5 based SOC for Bluetooth Low Energy Services |
| CInputOutput | This concrete class implements the InputOutput stream interface as a wrapper around Adafruit's BLEUart class |
| CInputOutput | This concrete class implements the InputOutput stream interface as a wrapper around Adafruit's Arduino UART class |
| ►NArduino | The Arduino namespace provides an interface for Arduino boards that use the Serial class |
| CInputOutput | This concrete class implements the InputOutput stream interface as a wrapper around Arduino Serial class |
| ►NPhonyStdio | The PhonyStdio namespace provides a crude implementation of the Cpl::Io::InputOutput interface using the C Library's fread/fwrite functions |
| CInputOutput | This concrete class implements the InputOutput stream interface built on top the C Library's fread/fwrite functions with the 'stdin' and 'stdout' file handles |
| ►NST | The ST namespace provides interfaces for ST specific hardware, i.e |
| ►NM32F4 | The M32F4 namespace provides implementation of the Cpl::Io::Output interface over a serial port using a STM32F4xxx MCU |
| CInputOutput | This concrete class implements the InputOutput stream interface built on top of ST HAL Layer/SDK |
| ►CStreamDriver | This concrete class implements a non-busy-wait blocking Transmit/Receive Stream UART driver with a SOFTWARE FIFO |
| CHalMapping_T | Used to map a HAL UART Handle to an instance of this class |
| ►NSocket | The Socket namespace provides interfaces for creating BSD socket connections |
| ►NPosix | The Posix namespace provides Posix implementation for Colony Core's socket interfaces |
| CConnector | This concrete class implements the Cpl::Io::Socket::Connector interface using IPv4/IPv6 addressing for a Posix platform |
| CListener | This concrete class implements the Cpl::Io::Socket::Listener interface using IPv4 addressing for the Posix compliant platform |
| ►NWin32 | The Win32 namespace provides Windows (i.e |
| CConnector | This concrete class implements the Cpl::Io::Socket::Connector interface using IPv4/IPv6 addressing for the Win32 (aka winsock2) platform |
| CListener | This concrete class implements the Cpl::Io::Socket::Listener interface using IPv4 addressing for the Win32 (aka winsock2) platform |
| CConnector | This abstract class defines the interface for establishing/requesting a SIMPLE socket connection, i.e |
| CFactory | This abstract class defines an interface for a Socket factory |
| CInputOutput | This concrete class provides a platform independent 'standard' implementation of an InputOutput stream object where the stream is Socket connection |
| ►CListener | This abstract class defines the interface for a SIMPLE socket listener |
| CClient | This class defines the callback mechanism used for accepting incoming socket connections |
| CListener_ | This private, mostly concrete helper class manages the top level threading aspects for a simple listener |
| ►CListenerClientRequest | This abstract class define message types and payloads for a set of ITC services |
| CNewConnectionPayload | Payload for Message: newConnection |
| CListenerClientSync | This partially concrete class implements the synchronous ITC open call for the OpenApi |
| CStreamPool | This concrete template class implement a socket factory that is capable of creating N concurrently opened socket streams |
| ►NStdio | The Stdio namespace provides concrete classes for the C Library's 'stdin', 'stdout', and 'stderr' input/output streams |
| CInput_ | This concrete class implements a Input stream using the underlying platform's native OS 'file interface' for the C library's stdin, stdout, and stderr streams |
| CInputOutput_ | This concrete class implements a Input-Output stream |
| COutput_ | This concrete class implements a Output stream using the underlying platform's native OS 'file interface' for the C library's stdin, stdout, and stderr streams |
| CStdErr | This concrete class represents the C-library 'stderr' stream |
| CStdIn | This concrete class represents the C-library 'stdin' stream |
| CStdOut | This concrete class represents the C-library 'stdout' stream |
| ►NTcp | The 'Tcp' namespace provides interfaces for creating non-blocking Cpl::Io streams using TCP/IP connections |
| NlwIP | The 'lwIP' namespace implements the TCP interfaces using 'raw' lwIP TCP interfaces |
| ►NWin32 | The 'Win32' namespace implements the TCP interfaces using the Win32 APIs |
| CAsyncConnector | This class implements the Asynchronous Connector |
| CAsyncListener | This class implements the Asynchronous Listener |
| ►CAsyncConnector | This abstract class defines the interface for establishing/requesting a SIMPLE socket connection, i.e |
| CClient | This class defines the callback mechanism used for accepting incoming TCP connections |
| ►CAsyncListener | This abstract class defines the interface for a SIMPLE socket listener |
| CClient | This class defines the callback mechanism used for accepting incoming TCP connections |
| CInputOutput | This concrete class defines a platform independent implementation of an InputOutput stream used by the Listener and Connector interfaces |
| CAtomicOutput | This concrete template class implements the AtomicOutputApi using a mutex to enforce the 'atomic-ness' of the operation, i.e |
| CAtomicOutputApi | This abstract template class defines a interface for an Atomic outputs to a stream |
| CClose | This abstract class defines a close operation that is intended to be used Input and Output streams/files |
| CDescriptor | This union defines a 'IO descriptor' in terms of a an integer and/or a void* |
| CDescriptor.__unnamed2__ | Union the different possible types for a descriptor |
| CInput | This partially abstract class defines a interface for operating on an input stream (example of a stream is 'stdin' or a socket connection) |
| CInputOutput | This abstract class defines a interface for operating on an input-output stream (example of a stream is socket connection) |
| CIsEos | This abstract class defines a isEos() operation that is intended to be used Input and Output streams |
| CLineReader | This concrete class implements a Line Reader stream using a previously opened Input stream |
| CLineReaderApi | This abstract class defines a interface for a stream line reader |
| CLineWriter | This concrete class implements a Line Writer stream using a previously opened Output stream |
| CLineWriterApi | This abstract class defines a interface for a stream line writer |
| CNewLine | This interface defines the 'newline' character(s) |
| CNull | This concrete class implements a NULL InputOutput stream - that all of its input operations return 'End-of-Stream' (i.e |
| COutput | This partially abstract class defines a interface for operating on an output stream (example of a stream is 'stdout' or a socket connection) |
| CTeeOutput | This concrete class implements a Output stream that outputs the data to MANY (or none) output streams |
| ►NItc | The Itc namespace provides classes for message based Inter Thread Communications (ITC) as well as Event Flags |
| CAsyncReturnHandler | This class implements an asynchronous ReturnHandler |
| CAtomicApi | This abstract class provides an interface to allow a client to call the server synchronously to have the server invoke the client's atomic operation |
| CAtomicCallback | This abstract class defines a call-back interface that clients use to issue multiple service requests as a single "atomic" operation |
| ►CAtomicRequest | This concrete class define the 'Atomic' Message request that allows a client to invoke multiple operation on a server/service as one single atomic operation |
| CPayload | Payload for Message |
| CAtomicResponse | This abstract class define response message types for a set of ITC services |
| CAtomicSync | This concrete class provides the ITC wrapper implementation for calling the "Atomic Api" synchronously |
| CCloseApi | This abstract class defines an close interface |
| ►CCloseRequest | This abstract class define message types and payloads for a set of ITC services |
| CClosePayload | Payload for Message: Open |
| CCloseResponse | This abstract class define response message types for a set of ITC services |
| CCloseSync | This partially concrete class implements the synchronous ITC close call for the CloseApi |
| CMailbox | This mailbox class implements an Inter Thread Communications message queue |
| CMailboxServer | This class collects the common functions of a generic server providing a mailbox and Event loop |
| CMessage | This abstract class defines the operations for an ITC message |
| CNullReturnHandler | This class implements a Null ReturnHandler |
| COpenApi | This abstract class defines an open interface |
| ►COpenRequest | This abstract class define message types and payloads for a set of ITC services |
| COpenPayload | Payload for Message: Open |
| COpenResponse | This abstract class define response message types for a set of ITC services |
| COpenSync | This partially concrete class implements the synchronous ITC open call for the OpenApi |
| CPeriodicScheduler | This class extends the Cpl::Itc::MailboxServer class to add periodic scheduling to an event based 'thread' |
| CPostApi | This abstract class represents the interface used to send messages to a mailbox |
| CRequestMessage | This template class represents a service request message to a particular server |
| CResponseMessage | This template class represents a client response message, which is posted to the client's mailbox after the corresponding server request message is returned to the client via the server message returnToSender interface |
| CReturnHandler | This abstract class represents the action that is executed by a server thread in response to the server completing the operation requested by the SrvMsg, when the server invokes the returnToSender() operation of the message |
| CSAP | This concrete template class represents the interface to a ITC Service Access Point (SAP) |
| CServiceMessage | This class represents a defined message, which is posted to a mailbox-server as a request |
| CSyncReturnHandler | This class implements a synchronous ReturnHandler |
| ►NJson | The 'Json' namespace is a collection of classes, modules, etc |
| CObjectDetector | This helper class is used to determine when an entire Json object has been read from an input source |
| ►NLogging | The 'Logging' namespace provides a framework for Logging events |
| CEntryData_T | Defines the content of the Log entry |
| CLogSink | This class is responsible for consuming the application's Log buffer and 'dispatching' log entries |
| ►NMApp | The 'MApp' namespace is provides a 'micro application' framework for asynchronously running micro applications |
| ►NTemperature | The 'Temperature' namespace implements a simple/example MApp that samples and displays temperature |
| CApi | This concrete class implements MApp the polls a model point for a temperature value and periodically writes the value to the trace output |
| CCmd | The class implements a TShell command that interacts with the MApp Manager to start, stop, and list available MApp instances |
| ►CGetAvailableMAppRequest | This abstract class define ITC message type and payload for the application to get list of all of the MApps instances |
| CPayload | Payload for Message: |
| ►CGetStartedMAppRequest | This abstract class define ITC message type and payload for the application to Get a list of started MApp instances |
| CPayload | Payload for Message: |
| ►CLookupMAppRequest | This abstract class define ITC message type and payload for the application to look-up a MApp by name |
| CPayload | Payload for Message: |
| CManager | This concrete class implements the MApp Manager |
| CManagerApi | This abstract class defines the "manager" interface to for starting, stopping, etc |
| CMApp_ | This partial concrete class provide common infrastructure that is common to all MApp instances |
| CMAppApi | This abstract class defines the interface for a Micro Application (MApp) |
| ►CStartMAppRequest | This abstract class define ITC message type and payload for the application to start a MApp |
| CPayload | Payload for Message: GetLaMApp |
| ►CStopAllMAppRequest | This abstract class define ITC message type and payload for the application to stop the current MApp |
| CPayload | Payload for Message: StopMApp (No actual Data -->just a type name) |
| ►CStopMAppRequest | This abstract class define ITC message type and payload for the application to stop the current MApp |
| CPayload | Payload for Message: StopMApp |
| ►NMath | The Math namespace provides classes, utilities, etc |
| CIntegerExpressionParser | This template class evaluates an null terminate string that represents an integer arithmetic expression |
| CRealExpressionParser | This template class evaluates an null terminate string that represents an real-number arithmetic expression |
| ►NMemory | The 'Cpl::Memory' namespace provides a collection interfaces that allow a application to manually manage "dynamic memory" independent of the actual heap |
| CAligned | This type is used to create a memory-block that is aligned to a size_t boundary |
| CAlignedClass | This type is used to create a memory block that is large enough to hold the memory footprint of ONE instance of 'class T' |
| CAllocator | This abstract class defines the interface for a Memory Allocator |
| CContiguousAllocator | This abstract class is used 'extend' the Memory Allocator to have contiguous semantics |
| CHPool | This template class defines a concrete Allocator that allocates its block memory from the HEAP |
| CLeanHeap | This class manages an allocate-only-heap |
| ►CNew_TS | This class provides methods to access the unit testing support for overriding the global new/delete operators |
| CStats | New/Delete metrics |
| ►CPool_ | This private concrete class implements a Memory Allocator using a pool of fixed size blocks |
| CBlockInfo_ | Helper class so I can put my blocks into to my standard containers |
| CSPool | This template class defines a concrete Allocator that STATICALLY allocates all of its Memory and can allocate up to N instances of the specified Class |
| ►NPersistent | The 'Persistent' namespace provides a basic persistent storage mechanism for non-volatile data |
| CChunk | This abstract class defines the interface for a Chunk |
| ►CClearAllEntriesRequest | This abstract class define ITC message type and payload for the application to clear/delete all entries |
| CPayload | Payload for Message |
| CClearAllEntriesResponse | This abstract class define ITC message type and payload for asynchronous response (to the application) of a ClearAllEntries message |
| CCrcChunk | This concrete class implements the Chunk interface by using a 32Bit CRC for ensuring data integrity |
| CDataRecord | This mostly concrete class implements the Cpl::Persistent::DataRecord interface where a DataRecord instance contains an unmanaged data store |
| CFileAdapter | This concrete class implements the RegionMedia interface using the Cpl::Io::File interfaces |
| ►CGetByBufferIndexRequest | This abstract class define ITC message type and payload for the application to request read Indexed Entry data |
| CPayload | Payload for Message: GetByBufferIndex |
| CGetByBufferIndexResponse | This abstract class define ITC message type and payload for asynchronous response (to the application) of a GetByBufferIndex message |
| ►CGetLatestRequest | This abstract class define ITC message type and payload for the application to request read Indexed Entry data |
| CPayload | Payload for Message: GetLatest |
| CGetLatestResponse | This abstract class define ITC message type and payload for asynchronous response (to the application) of a GetLatest message |
| ►CGetNextRequest | This abstract class define ITC message type and payload for the application to request read Indexed Entry data |
| CPayload | Payload for Message: GetNext |
| CGetNextResponse | This abstract class define ITC message type and payload for asynchronous response (to the application) of a GetNext message |
| ►CGetPreviousRequest | This abstract class define ITC message type and payload for the application to request read Indexed Entry data |
| CPayload | Payload for Message: GetPrevious |
| CGetPreviousResponse | This abstract class define ITC message type and payload for asynchronous response (to the application) of a GetPrevious message |
| ►CIndexedEntryReader | This abstract class defines interface for reading/retrieve 'entries' from a a collection of entries (i.e |
| CEntryMarker_T | This structure define an 'marker' that identifies an entry's location in persistent media |
| CIndexedEntryRecord | This concrete class implements the Cpl::Persistent::Record interface to store a collection 'entries' |
| CIndexedEntryServer | This concrete template class implements the ITC messaging (and Model Point monitoring) needed to provide a thread-safe/asynchronous interface for reading/writing 'Indexed Entries' |
| CIndexedEntryWriter | This abstract class defines interface for appending a single 'entry' to a a collection of entries (i.e |
| CIndexRecord | This concrete class extends the Cpl::Persistent::DataRecord interface to store a latest/oldest 'record index' into a RegionMedia |
| CMirroredChunk | This concrete class implements the Chunk interface by storing two copies of the Record's data |
| CNullRegionMedia | This concrete class provides a 'null' implementation of the RegionMedia interface |
| CNVAdapter | This concrete class implements the RegionMedia interface using the Driver::NV::Api interface |
| CPayload | This abstract class defines the interface accessing the 'data payload' of an individual Record instance |
| CRecord | This abstract class defines the public interface for a Record instance |
| CRecordServer | This concrete class provides an Event driven Runnable object for executing the read/write operation to persistent storage media for N Records |
| CRegionMedia | This mostly abstract class defines the operations that can be performed on a persistent media |
| ►NSystem | The System namespace contains platform independent foundation abstractions and classes related to program execution |
| ►NBareMetal | Concrete implementation of the platform specific classes/features of the Cpl::System namespace interfaces for a Baremetal/Singled-threaded system |
| CThread | This concrete class implements 'enough' of a Thread object to support Cpl::System framework on a bare metal system (a system that has only ONE thread and potentially ISR contexts) |
| ►NCpp11 | Concrete implementation of the platform specific classes/features of the Cpl::System namespace interfaces using the C++11 standard threading features |
| CThread | This concrete class implements a Thread object using C++11 threads |
| ►NFreeRTOS | Concrete implementation of the platform specific classes/features of the Cpl::System namespace interfaces using FreeRTOS threading functions |
| CMakeCurrentThreadACplThread | This is a helper class that can be used to make the current thread a CPL thread |
| CThread | This concrete class implements a Thread object using FreeRTOS threads |
| ►NPosix | Concrete implementation of the platform specific classes/features of the Cpl::System namespace interfaces using POSIX threading functions |
| CThread | This concrete class implements a Thread object using Posix threads |
| ►NWin32 | Concrete implementation of the platform specific classes/features of the Cpl::System namespace interfaces using native Win32 threading functions |
| CThread | This concrete class implements a Thread object using Win32 threads NOTE: The class/implementation uses _beginthread() instead of CreateThread() ->this is per Microsoft's documentation that says the _beginthread() properly initializes/cleans-up the C-Runtime library as where CreateThread() does NOT |
| CApi | This class defines methods for initializing the Colony.Core class library and other startup/init actions |
| CCounterCallback_ | This abstract class defines the call-back interface for a Counter object |
| CCounterSource_ | This abstract class defines the interface for registering for an Counter object with the Timer Manager |
| ►CElapsedTime | This class defines the interface for accessing the elapsed time since power up and/or reset of the platform |
| CPrecision_T | Data type for time in seconds with a 'fractional' millisecond precision |
| CEventFlag | This abstract class defines the interface to generated a 'Event Flag' |
| CEventLoop | This concrete class is a Runnable object that provides a event driven execution model for a thread |
| CFatalError | This class defines methods for handling fatal errors encountered by an application |
| CGlobalLock | This class defines an interface for a "Global Lock" |
| CLocks_ | This class provide access to Colony.Core's internal global mutexes |
| ►CMutex | This mutex class defines the interface for a mutex that has "recursive" semantics |
| CScopeBlock | This concrete class provides a simple mechanism for providing mutex protection for a "scope block" |
| ►CPeriodicScheduler | This concrete class is a 'policy' object that is used to add polled based, cooperative monotonic scheduling to a Runnable object |
| CInterval_T | Defines an interval |
| CRunnable | This is an abstract class defines the interface for an object that is "executed" when a Thread object is created |
| CSemaphore | This semaphore class defines the interface for a Counting Semaphore |
| CSharedEventHandler | This template concrete class is a 'strategy class' in that in provides most of work needed for a Runnable object to support a list of callback functions for handling event-signally - instead of hard coded switch statement in its processEventFlag() method |
| ►CSharedEventHandlerApi | This abstract class defines the interface for a Shared Event Handler |
| CEventCallback_T | Define a callback entry (i.e |
| CShell | This class defines methods for interfacing with the Platform native OS to execute a native OS system/shell command |
| ►CShutdown | This class defines methods for forcibly terminating the application |
| CHandler | This call defines the callback interface that is used when the application is shutdown |
| CShutdown_TS | This class provides methods to access the unit testing support for the Cpl::System::Shutdown interface |
| CSignable | This abstract class defines the interface by which a client can cause an object that is waiting-on-a-signal to become unblocked |
| CSimTick | This class define the interface to provide a simulates system tick (in milliseconds) to the application |
| CStartupHook_ | This class defines a start-up handler/hook that allows a Colony.Core sub-system to register to be called when the Api::initialize() method is called |
| ►CThread | This abstract class defines the operations that can be performed on a thread |
| CTraverser | This abstract class defines the client interface for walking the list of threads, i.e |
| CTimer | This mostly concrete interface defines the operations that can be performed on a software timer |
| CTimerComposer | This template class implements a Software Timer that is context independent and allows for a single context to contain many Timers |
| CTimerManager | This mostly concrete class implements manages a list of Software Timers |
| CTls | This concrete class defines the interface for Thread Local Storage (TLS) |
| CTrace | This concrete class provide a 'printf' tracing mechanism |
| CTracePlatform_ | This class defines the interface to the platform specific implementation of the Cpl::System::Trace interface |
| ►NText | The Text namespace provides yet-another String class and additional string and/or text processing utilities |
| NEncoding | The 'Encoding' namespace provides various encoding algorithms for converting binary data to (and from) ASCII text to facilitate transport of the binary data using text based protocols |
| ►NFrame | The Frame namespace provides interfaces for encoding and decoding text frames |
| CAsciiDecoder | This concrete template class provide a basic implementation of the Frame::Decoder interface that uses Cpl::Io::Input stream as the input source |
| CBlockEncoder | This concrete class implements extends the StreamDecoder implementation to be more efficient with respect to outputting data to a Stream |
| CDecoder | This class defines an interface for 'receiving' (decode) a frame |
| CDecoder_ | This private partially concrete class implements the basic/common logic for a frame decoder |
| CEncoder | This class defines an interface for 'transmitted' (encoding) a frame |
| CEncoder_ | This Private Namespace partially concrete class implements common/helper method for supporting the Encoder API |
| CLineDecoder | This concrete template class provide a basic implementation of the Frame::Decoder interface that uses Cpl::Io::Input stream as the input source |
| CStreamDecoder | This partially concrete class defines an interface a Text "Decoder" that has a Cpl::Io::Input stream as its input source |
| CStreamEncoder | This concrete class implements the Encoder API where the Output destination is a Cpl::Io::Output stream |
| CStringDecoder | This concrete class defines an interface a Text "Decoder" that accepts a null terminated string as its input source |
| CStringEncoder | This concrete class implements the Encoder API where the Output destination is a Cpl::Text::String |
| ►NTokenizer | The Tokenizer namespace provides interfaces for tokenizing strings |
| CBasic | This concrete class performs basic tokenizing/parse functions on a string |
| CTextBlock | This concrete class tokenizes a Text Block that has the following format: |
| CDFString | This concrete class is a mix of FString and a DString - the initial memory is dynamically allocated - but no additional memory allocation will occur after the instance is created, i.e |
| CDFStringItem | This concrete class implements the StringItem class for a 'String' using a 'DFString' as the internal storage for String instance |
| CDString | This concrete class implements a simple "dynamic storage" String Type |
| CDStringItem | This concrete class implements the StringItem class for a 'String' using a 'DString' as the internal storage for String instance |
| CFString | This template class represents a NULL terminated string of a specific length |
| CFString_ | This mostly concrete class implements a "fixed storage" String Type |
| CFStringItem | This template class implements the StringItem class for a 'String' using a 'FString' as the internal storage for String instance |
| CString | This abstract class defines the operations that can be before on a NULL terminated string |
| CString_ | This partially concrete class implements the portions of the String Api that is independent of the internal storage mechanisms |
| CStringItem | This partially concrete provides a wrapper class that allows a String object to be stored directly in one the CPL Containers |
| ►NTShell | The 'Cpl::TShell' namespace provides a Text based shell that can be used interact with an Application |
| ►NCmd | The 'Cmd' namespace contains the implementation of TShell commands |
| ►NArduino |
This namespace contains the implementation of TShell commands that are specific to Arduino framework/system. The application is free to choose which commands to include in its TShell. |
| CDbg | This class implements a DAC Shell command |
| ►NFreeRTOS | This namespace contains the implementation of TShell commands that are specific to FreeRTOS operating system |
| CThreads | This class implements a TShell command |
| ►NWin32 | This namespace contains the implementation of TShell commands that are specific to Windows operating system |
| CThreads | This class implements a TShell command |
| CBye | This class implements a Shell command |
| CCommand | This partially concrete class implements infrastructure and/or common functionality for a Shell command |
| CHelp | This class implements a Shell command |
| CThreads | This class implements a Shell command |
| CTick | This class implements a Shell command |
| CTPrint | This class implements a Shell command |
| CTrace | This class implements a Shell command |
| CUser | This class implements a Shell command |
| CWait | This class implements a Shell command |
| CCommand | This class defines the interface for a TShell command |
| CContext_ | This Private Namespace class defines a "Context" for a TShell command |
| CMaker | This concrete class is a "Maker" that assembles the objects needed for a 'basic' TShell Processor engine |
| CPolledMaker | This concrete class is a "Maker" that assembles the objects needed for a 'basic' TShell Processor engine that has POLLED semantics |
| CPolledProcessor | This concrete class provides a non-blocking implementation of Command PolledProcessor for a TShell engine |
| CProcessor | This concrete class provides the implementation of Command Processor for a TShell engine |
| CProcessorApi | This class defines the interface a TShell Command Processor |
| CRestartable | This concrete class extends the 'Stdio' class for running a TShell Command Processor that provides the ability to 'restart' the TShell to be 'restarted' |
| CSecurity | This abstract defines the interface for validating a 'user login' for TShell |
| CSecurityNull | This concrete class dummy/null implementation of the Security interface |
| CSocket | This concrete class provides a socket listener/server and 'threading wrapper' for running a TShell Command Processor |
| CStdio | This concrete class provides the 'threading wrapper' for running a TShell Command Processor |
| ►NType | The 'Cpl::Type' namespace contain various typedefs and/or helper classes that function as general purpose types, callback mechanisms, etc |
| CGuid_T | This structure defines a type for a 16 Byte GUID/UUID |
| CGuid_T.__unnamed6__ | Value as single memory block, and/or internal structure |
| CGuid_T.__unnamed6__.__unnamed8__ | |
| CSeqNumber | This class defines a sequence number and the operation that can be performed on it |
| CTraverser | This class defines a set of type(s) that are used with the traverser design pattern |
| ▼NDriver | Namespace |
| ►NAIO | Namespace |
| ►NAjax | The 'Ajax' namespace provides analog input driver(s) for the Ajax application |
| CThermistor | This class is responsible for sampling the on-board temperature sensor every N milliseconds and populating a model point |
| NArduino | The 'Arduino' namespace provides Arduino specific HAL implementation for AIO driver(s) |
| ►NEros | The 'Eros' namespace provides analog input driver(s) for the Eros application |
| CThermistor | This class is an Eros specific extension of the Driver::AIO::Ajax::Thermistor driver |
| NSimulated | The 'Simulated' namespace provides simulated specific HAL implementation for AIO driver(s) |
| ►NButton | The 'Button' namespace provides a drivers for handling 'button' inputs |
| NArduino | The 'Arduino' namespace provides Arduino specific HAL implementation for Button driver(s) |
| NSTM32 | The 'STM32' namespace provides STM32 specific HAL implementation for AIN driver(s) |
| NTPipe | The 'TPipe' namespace provides an implementation of the Button driver using a TPipe (see src/Driver/TPipe) |
| CPolledDebounced | This concrete class implements a button driver where a single button is polled and its raw button state is de-bounced |
| ►NCrypto | The 'Crypto' namespace provides a collection of Cryptographic functions and algorithms |
| ►NOrlp | The 'Orlp' namespace implements a sub-set of the Crypto interfaces using third-party code from Orson Peters (https://github.com/orlp) |
| CSHA512 | This class implements the Hash interface using Orson Peter's SHA512 algorithm |
| NPasswordHash | The 'PasswordHash' namespace provides a basic 'algorithm' to hash a password when something like 'bcrypt' is not available |
| ►NTShell | The 'TShell' namespace provides TShell/Console commands that invoke Crypto functions |
| CRandom | This class implements a Shell command |
| ►CED25519 | This class implements the Edwards-curve digital signature defined by Edwards-Curve Digital Signature Algorithm (EdDSA) [RFC8032], using standard parameters |
| CKeys_T | Asymmetrically Key Pair |
| CHash | This class defines an abstract interface for a Hashing Algorithms |
| ►NDIO | The 'DIO' namespace provides drivers for Digital Input/Output drivers |
| NArduino | The 'RP2040' namespace implements the Driver::DIO interfaces for the Raspberry PI Pico RP2040 microcontroller |
| NSimulated | The 'Simulated' namespace implements the DIO interface using model points |
| NSTM32 | The 'STM32' namespace implements the Driver::DIO interfaces for the ST Microelectronics STM32 family of micro-controllers |
| CIn | This class defines a generic interface for sampling a single Digital Input signal |
| ►CInOut | This class defines a generic interface for controlling N Digital inputs and M Digital outputs |
| CConfig_T | Configuration Options |
| CInOutCmd | This class implements a TShell command that exercises the RH/Temp driver |
| COut | This class defines a generic interface for controlling a single Digital output signal |
| CPwm | This class defines a generic interface for controlling a simple PWM output signal |
| ►NI2C | The 'I2C' namespace defines a platform independent interface for a I2C bus |
| ►NArduino | The 'Arduino' namespace implements the I2C interfaces using the Arduino Framework |
| CMaster | This class implements the I2C interface using the Arduino framework and/or APIs |
| ►NSTM32 | The 'STM32' namespace implements the I2C interfaces for the STM32 family of microcontrollers |
| CMaster | This class implements the I2C interface for the STM32 family of micro-controller using the ST's MX Cube/IDE to configure the SPI peripherals and IO pins |
| CMaster | This class defines a non-platform specific interface for an I2C master device driver |
| ►NLED | The 'LED' namespace provides drivers for various LEDs |
| ►NPimoroni | The 'Pimoroni' namespace provides implementations that are specific to the GENERIC port of the Pimoroni C++ drivers/libraries |
| CRedGreenBlue | This concrete class is wrapper to the GENERIC pimoroni RGBLED class |
| ►NTPipe | The 'TPipe' namespace provides implementations that use the TPipe for the output of the LEDs |
| CRedGreeBlue | This concrete class implements the Red-Green-Blue LED interface by sending the LED state over the TPipe to an external client |
| CRedGreenBlue | This abstract class defines a basic interface for a single Red-Green-Blue LED where the application can set the individual color values and the overall brightness of the LED |
| ►NNV | The 'NV' namespace defines a platform independent interface for reading and writing from/to non-volatile storage |
| ►NFile | The 'File' namespace contains drivers for non-volatile storage using a a file system as the storage media |
| ►NCpl | The 'Cpl' namespace contains the non-volatile storage driver for using the CPL C++ class library's Cpl::Io::File interfaces |
| CApi | This class implements the Non-volatile storage driver using the Cpl::Io::File interfaces |
| ►NOnsemi | The 'Onsemi' namespace contains drivers for non-volatile storage for Onsemi devices |
| ►NCAT24C512 | The 'CAT24C512' namespace contains the non-volatile storage driver for the Onsemi 512Kb (64KB) I2C EEPROM IC |
| CApi | This class implements the Non-volatile storage driver for the Onsemi CAT24C512 serial 512Kb (64KB) I2C EEPROM |
| CApi | This class defines the interface for a platform independent Non-volatile storage driver |
| CCmd | This class implements a TShell command that tests/directly-operates on the NV media |
| CGang | This class implements the Non-volatile storage driver using a collection of NV drivers to provide a 'flat address' space that spans multiple discrete storage chips/media |
| CNull | This concrete class provides a 'null' implementation of the NV Storage interface |
| ►NPicoDisplay | The 'PicoDisplay' namespace provides a top-level/composite driver that provides an abstraction that represents the physical hardware of the Pimoroni Pico Display board |
| NArduino | The 'Arduino' namespace implements the composite PicoDisplay driver for the actual hardware connected to a board using the Arduino framework |
| NSTM32 | The 'STM32' namespace implements the composite PicoDisplay driver for the actual hardware |
| NTPipe | The 'TPipe' namespace implements the composite PicoDisplay driver using a 'TPipe' to communicate with an external executable that provides the actual Display/IO |
| CApi | This class defines an interface for accessing the 'hardware bits' of the Pico Display board |
| ►NRHTemp | The 'RHTemp' namespace provides a top-level driver that provides an abstraction that represents a combined Relative Humidity and Temperature sensor |
| ►NSimulated | The 'Simulated' namespace implements the RH/Temperature driver that is mocked for a Desktop OS (e.g |
| CApi | This class implements the RH/Temperature driver interface using model points as the physical signals |
| CApi | This class defines an interface for reading and managing a combined RH and Temperature sensor |
| CTShellCmd | This class implements a TShell command that exercises the RH/Temp driver |
| ►NSPI | The 'SPI' namespace defines a platform independent interface SPI drivers |
| ►NArduino | The 'Arduino' namespace implements the SPI interfaces using the Arduino framework |
| ►CMaster | This class implements the SPI interface using the Arduino Framework |
| CSPIConfig_T | SPI Settings (note: needed because the SPISettings class does not allow changing the baudrate once instantiated) |
| ►NSTM32 | The 'STM32' namespace implements the SPI interfaces for the STM32 family of microcontrollers |
| CMaster | This class implements the SPI interface for the STM32 family of micro-controller using the ST's MX Cube/IDE to configure the SPI peripherals and IO pins |
| CMasterHalfDuplex | This class implements the SPI Half-duplex interface for the STM32 family of micro-controller using the ST's MX Cube/IDE to configure the SPI peripherals and IO pins |
| CMaster | This class defines a non-platform specific interface for an SPI master device driver |
| CMasterHalfDuplex | This class defines a non-platform specific interface for an SPI master device driver using HALF-DUPLEX data transfers, i.e, only transmit data or receive data |
| ►NTPipe | The 'TPipe' namespace provides a point-to-point full duplex 'pipe' used to pass text based commands between to two end points |
| CMaker | This concrete class is a "Maker" that assembles the objects needed for TPipe |
| CPipe | This concrete class provides the implementation of TPipe |
| CRxFrameHandler | This partially concrete class provides functionality that is common to all Frame handlers |
| CRxFrameHandlerApi | This abstract class defines the 'Received Frame Handler' interface for the TPipe |
| CTx | This abstract class defines the 'Transmit Command' interface for the TPipe |
| ►NWifi | The 'Wifi' namespace provides various types of drivers related to WIFI networks |
| ►NStation | The 'Station' namespace provides various types of drivers for a device that connects to a WIFI network as a station node |
| ►NTShell | The 'TShell' namespace contains the implementation of TShell commands that provide access to the Wifi Station Interface(s) |
| CWifi | This class implements a TShell command |
| CConnection | This class defines an asynchronous interface for a Station device to connect to a WIFI network |
| ▼NEros | The 'Eros' namespace is the root name space all of the GM6000 Engineering Test Application specific source code |
| ►NTest | The 'Test' namespace is the root name space for the individual tests (aka Cpl::MApp instances) |
| ►NCycle | The 'Cycle' namespace implements a MApp that duty cycles the heating equipment |
| CApi | This concrete class implements MApp the duty cycles the heating equipment based on command arguments |
| ►NThermistor | The 'Thermistor' namespace implements a MApp that samples and displays temperature as measured by the unit's thermistor |
| CApi | This concrete class implements MApp the monitors the output of the specialized Eros Thermistor driver and periodically writes the temperature and ADC-bits values to the trace output |
| ►NTShell | The 'TShell' namespace is the root name space for Eros specific debug/command console commands |
| CHwSafety | This class implements a TShell command to verify the PWM signals on the board |
| CPwm | This class implements a TShell command to verify the PWM signals on the board |
| CRgb | This class implements a TShell command to verify the operation of the RGB LED on the display board |
| ►NUi | The 'Ui' namespace is the root name for UI components, widgets, etc |
| ►NHome | The 'Home' namespace contains the implementation for the Eros Home Screen |
| CScreen | This class implements the Home screen |
| ►NLcdTest | The 'LcdTest' namespace contains the implementation for the Eros LCD Test Screen |
| CScreen | This class implements the Home screen |
| Nmp | Encapsulate all Model Points in the 'mp' namespace to prevent polluting the global name space |
1.9.8