GHI Electronics Documentation

https://docs.ghielectronics.com
Admin
Comprehensive documentation for GHI Electronics embedded computing platforms including Endpoint...
Tokens:294,468
Snippets:4,004
Trust Score:9.5
Update:4 months ago
Show doc for...
Tokens:
Raw
### Initialize UI Application

Source: https://docs.ghielectronics.com/endpoint/tutorials/ui.html

This code snippet provides a starting point for initializing a UI application. It includes setup for display and touch input, and creates a basic window with a gradient background. Ensure you have the GHIElectronics.Endpoint.Drawing and GHIElectronics.Endpoint.UI NuGet packages installed.

```csharp
using GHIElectronics.Endpoint.UI;

namespace UserInterfaceExample {
	class Program : Application {
		public Program(int width, int height) : base(width, height) {
		
		}

		static void Main(string[] args) {
			// Initialize Display
			InitDisplay();

			// Initialize Touch
			InitializeTouch();

			var app = new Program(display);
			app.Run(Program.CreateWindow(display));
		}

		private static Window CreateWindow(int width, int height)
		{
			var window = new Window
			{
				Height = height,
				Width = width
			};
			window.Background = new LinearGradientBrush(Colors.Blue, Colors.Teal, 0, 0,
			window.Width, window.Height);

			//window.Background = null;

			return window;
		}

		static void InitDisplay()
		{
			var backlightPort = EPM815.Gpio.Pin.PD14 / 16;
			var backlightPin = EPM815.Gpio.Pin.PD14 % 16;

			var gpioDriver = new LibGpiodDriver(backlightPort);
			var gpioController = new GpioController(PinNumberingScheme.Logical, gpioDriver);

			gpioController.OpenPin(backlightPin, PinMode.Output);
			gpioController.Write(backlightPin, PinValue.High); // low is on


			var configuration = new FBDisplay.Configuration()
			{
				Clock = 10000,
				Width = 480,
				Hsync_start = 480 + 2,
				Hsync_end = 480 + 2 + 41,
				Htotal = 480 + 2 + 41 + 2,
				Height = 272,
				Vsync_start = 272 + 2,
				Vsync_end = 272 + 2 + 10,
				Vtotal = 272 + 2 + 10 + 2,

			};

			var setting = $"{configuration.Clock},";

			setting += $"{configuration.Width},{configuration.Hsync_start},{configuration.Hsync_end},{configuration.Htotal},";
			setting += $"{configuration.Height},{configuration.Vsync_start},{configuration.Vsync_end},{configuration.Vtotal},";
			setting += $"{configuration.Num_modes},{configuration.Dpi_width},{configuration.Dpi_height},{configuration.Bus_flags},{configuration.Bus_format},{configuration.Connector_type},{configuration.Bpc}";

			Console.WriteLine(setting);

			var fbDisplay = new FBDisplay(configuration);

			displayController = new DisplayController(fbDisplay);
		}

		public static void InitializeTouch()
		{
			var resetPin = EPM815.Gpio.Pin.PF2 % 16;
			var resetPort = EPM815.Gpio.Pin.PF2 / 16;

			var gpioController = new GpioController(PinNumberingScheme.Logical, new LibGpiodDriver(resetPort));
			gpioController.OpenPin(resetPin);
			gpioController.Write(resetPin, PinValue.Low);

			Thread.Sleep(100);

			gpioController.Write(resetPin, PinValue.High);



			// On dev
			//EPM815.I2c.Initialize(EPM815.I2c.I2c6);
			//var touch = new FT5xx6Controller(EPM815.I2c.I2c6, EPM815.Gpio.Pin.PF12);

			// On Domino
			EPM815.I2c.Initialize(EPM815.I2c.I2c5);
			var touch = new FT5xx6Controller(EPM815.I2c.I2c5, EPM815.Gpio.Pin.PB11);

			touch.TouchDown += (a, b) =>
			{
				//Console.WriteLine("Touch down " + b.X + ", " + b.Y);
				Program.MainApp.InputProvider.RaiseTouch(b.X, b.Y, GHIElectronics.Endpoint.UI.Input.TouchMessages.Down, System.DateTime.Now);
			};

			touch.TouchUp += (a, b) =>
			{
				//Console.WriteLine("Touch up " + b.X + ", " + b.Y);

				Program.MainApp.InputProvider.RaiseTouch(b.X, b.Y, GHIElectronics.Endpoint.UI.Input.TouchMessages.Up, System.DateTime.Now);
			};

			//Thread.Sleep(-1);
		}
	}
}

```

--------------------------------

### Basic UI Application Setup

Source: https://docs.ghielectronics.com/software/tinyclr/tutorials/user-interface.html

This snippet demonstrates the fundamental structure for a UI application, including display controller initialization and application management. Ensure you have the GHIElectronics.TinyCLR.Devices.Display and GHIElectronics.TinyCLR.UI NuGet packages installed.

```csharp
using GHIElectronics.TinyCLR.Devices.Display;
using GHIElectronics.TinyCLR.UI;

namespace UserInterfaceExample {
    class Program : Application {
        public Program(DisplayController d) : base(d) {
        }

        static void Main() {
            var display = DisplayController.GetDefault();

            display.SetConfiguration(new ParallelDisplayControllerSettings {
                //Your display configuration
            });

            display.Enable();

            var app = new Program(display);
            app.Run(Program.CreateWindow(display));
        }

        private static Window CreateWindow(DisplayController display) {
            var window = ...
            return window;
        }
    }
}
```

--------------------------------

### Application.Run Method

Source: https://docs.ghielectronics.com/endpoint/api/GHIElectronics.Endpoint.UI.Application.html

Starts the application's execution. Typically called after initial setup.

```csharp
public void Run()
```

--------------------------------

### USB WinUSB Communication Example

Source: https://docs.ghielectronics.com/software/tinyclr/tutorials/usb-pc-comm.html

Demonstrates how to set up and use USB WinUSB for faster PC communication. Requires a specific GUID for the device. The code continuously reads data, increments each byte, and writes it back.

```C#
var usbclientController = UsbClientController.GetDefault();
    
var usbClientSetting = new UsbClientSetting(){
    Mode = UsbClientMode.WinUsb,
    ManufactureName = "Manufacture_Name",
    ProductName = "Product_Name",
    SerialNumber = "12345678",
    Guid = "{your guid}",
};

var winUsb = new WinUsb(usbclientController, usbClientSetting);

winUsb.DeviceStateChanged += (a,b) => Debug.WriteLine("Connection changed."); 
winUsb.DataReceived += (a,count) => Debug.WriteLine("Data received:" + count);
                 
winUsb.Enable();

while (winUsb.DeviceState != DeviceState.Configured) ;
        Debug.WriteLine("UsbClient Connected");

// The example will read data from port to dataR array
// Copy dataR to dataW array, plus 1 for each element
// Write dataW array back to port
    
while (true){
    var len = winUsb.Stream.BytesToRead;

    if (len > 0){
        var dataR = new byte[len];
        var dataW = new byte[len];
        int read = winUsb.Stream.Read(dataR);

        for (var i = 0; i < read; i++){
            dataW[i] = (byte)(dataR[i] + 1);
        }
        winUsb.Stream.Write(dataW);
    }
    Thread.Sleep(100);
}
```

--------------------------------

### Start Method

Source: https://docs.ghielectronics.com/endpoint/api/GHIElectronics.Endpoint.Core.Script.html

Starts the script execution.

```APIDOC
## Start(bool waitforexit = true) Method

### Description
Starts the script execution.

### Parameters
#### Parameters
- **waitforexit** (bool) - Optional. Specifies whether to wait for the script to exit. Defaults to true.
```

--------------------------------

### Initialize and Start VNC Server

Source: https://docs.ghielectronics.com/software/tinyclr/tutorials/vnc.html

This snippet shows how to initialize the VNC server with specified dimensions and port, attach an event handler for pointer changes, and start the server. It also sets up a drawing loop to continuously update the VNC display.

```csharp
static VncServer vncServer;

// To do: Setup the preferred network connection here
// ...
    
// Start VNC 
vncServer = new VncServer("VNC Viewer", 5900, 320, 240);
vncServer.PointerChangedEvent += S_PointerChangedEvent;
vncServer.Start();
Debug.WriteLine("VNC started");
    
// Start Drawing!
Graphics vncDisplay = Graphics.FromImage(new Bitmap(320, 240));
var font = Resources.GetFont(Resources.FontResources.Arial);
var cnt = 0;

Graphics.OnFlushEvent += Graphics_OnFlushEvent;

    while (true) {
        vncDisplay.Clear();
        vncDisplay.DrawString(cnt + " SITCore VNC ! ", font, new SolidBrush(Color.Yellow), 15, 20);
        vncDisplay.DrawEllipse(new Pen(Color.Red), cnt, 160, 40, 40);

        vncDisplay.Flush();
        if ((cnt += 5) > 320) {
            cnt = 0;
            vncDisplay.Clear();
        }        
        Thread.Sleep(10);
    }
}

void S_PointerChangedEvent(int x, int y, bool pressed) {
    Debug.WriteLine("x = " + x + ", y = " + y + ", press: " + pressed);
}

void Graphics_OnFlushEvent(Graphics sender, byte[] data, int x, int y, int width, int height, int originalWidth) {
        vncServer.Send(data, x, y, width, height);
}
```

--------------------------------

### ArrangeOverride Example

Source: https://docs.ghielectronics.com/endpoint/api/GHIElectronics.Endpoint.UI.Controls.Border.html

Example of how to implement ArrangeOverride, iterating through visual children and arranging them.

```csharp
protected override void ArrangeOverride(int arrangeWidth, int arrangeHeight)
{
    foreach (UIElement child in VisualChildren)
    {
        child.Arrange(new Rect(childX, childY, childWidth, childHeight);
    }
}
```

--------------------------------

### Low-Level Display Access Example

Source: https://docs.ghielectronics.com/software/tinyclr/tutorials/displays.html

This example demonstrates how to directly write pixel data to a display using low-level access. It requires specific NuGets and configures the display controller for RGB565 format. Use this only in advanced edge cases.

```C#
using GHIElectronics.TinyCLR.Devices.Display;
using GHIElectronics.TinyCLR.Devices.Gpio;
using GHIElectronics.TinyCLR.Pins;

GpioPin backlight = GpioController.GetDefault().OpenPin(SC20260.GpioPin.PA15);
backlight.SetDriveMode(GpioPinDriveMode.Output);
backlight.Write(GpioPinValue.High);
var displayController = DisplayController.GetDefault();

// Enter the proper display configurations
displayController.SetConfiguration(new ParallelDisplayControllerSettings{
    Width = 480,
    Height = 272,
    DataFormat = GHIElectronics.TinyCLR.Devices.Display.DisplayDataFormat.Rgb565,
    Orientation = DisplayOrientation.Degrees0, //Rotate display.
    PixelClockRate = 10000000,
    PixelPolarity = false,
    DataEnablePolarity = false,
    DataEnableIsFixed = false,
    HorizontalFrontPorch = 2,
    HorizontalBackPorch = 2,
    HorizontalSyncPulseWidth = 41,
    HorizontalSyncPolarity = false,
    VerticalFrontPorch = 2,
    VerticalBackPorch = 2,
    VerticalSyncPulseWidth = 10,
    VerticalSyncPolarity = false,
});

displayController.Enable();
byte[] myPic = new byte[480 * 272 * 2];

for (var i = 0; i < myPic.Length; i++){
    myPic[i] = (byte)(((i % 2) == 0) ?
        ((i / 4080) & 0b00000111) << 5 :
        i / 32640);
}

displayController.DrawString("\f");     
displayController.DrawBuffer(0, 0, 0, 0, 480, 272, 480, myPic, 0);
displayController.DrawString("GHI Electronics\n");
displayController.DrawString("Low Level Display Demo.");

for (var x = 20; x < 459; x++){
    displayController.DrawPixel(x, 50, 0xF800);     //Color is 31,0,0 (RGB565).
    displayController.DrawPixel(x, 51, 0xF800);
}

```

--------------------------------

### Start Method

Source: https://docs.ghielectronics.com/endpoint/api/GHIElectronics.Endpoint.Devices.Watchdog.WatchdogController.html

Starts the watchdog timer with a specified timeout in seconds.

```csharp
public bool Start(uint second)
```

--------------------------------

### VideoStreamStart Method

Source: https://docs.ghielectronics.com/endpoint/api/GHIElectronics.Endpoint.Devices.Dcmi.DcmiController.html

Starts the video streaming process.

```APIDOC
## VideoStreamStart()

### Description
Starts the video streaming from the camera.
```

--------------------------------

### Modbus IP Listener Setup

Source: https://docs.ghielectronics.com/software/tinyclr/tutorials/modbus.html

This snippet shows how to instantiate and start a Modbus IP listener for a slave device. It configures the listener with the device, port, and timeout settings.

```C#
ModbusDevice ModbusTCP_Device;
ModbusTCP_Device = new ModbusSlave(248);
ModbusTcpListener mbListner;
mbListner = new ModbusTcpListener(ModbusTCP_Device, 502, 5, 1000);
Thread.Sleep(100);
ModbusTCP_Device.Start();
```

--------------------------------

### Install Endpoint Python Core Library

Source: https://docs.ghielectronics.com/endpoint/beyond-dotnet.html

Install the Endpoint Python Core library using pip to enable IntelliSense in VS Code.

```bash
C:\pip install GHIElectronics.Endpoint.Core
__
```

--------------------------------

### Create and Start a Thread

Source: https://docs.ghielectronics.com/software/tinyclr/tutorials/multithreading.html

This snippet demonstrates how to define a method to be executed in a separate thread and then create and start that thread. Use this for concurrent operations.

```C#
void Blinker() {
    // LED on
    Thread.Sleep(100);
    // LED off
    Thread.Sleep(100);
}

var t = new Thread(Blinker);
t.Start();
// do secondary task
Thread.Sleep(Timeout.Infinite);
```

--------------------------------

### Configure and Enable ENC28J60 Ethernet Controller

Source: https://docs.ghielectronics.com/software/tinyclr/tutorials/ethernet.html

This snippet shows the setup for the ENC28J60 Ethernet controller, including SPI and GPIO configurations, IP settings, and event subscriptions. Ensure all required NuGets are installed.

```csharp
static void Enc28Test() {
    var networkController = NetworkController.FromName
        (SC20260.NetworkController.Enc28j60);

    var networkInterfaceSetting = new EthernetNetworkInterfaceSettings();

    var networkCommunicationInterfaceSettings = new
        SpiNetworkCommunicationInterfaceSettings();

    var cs = GpioController.GetDefault().OpenPin(SC20260.GpioPin.PG12);

    var settings = new Spi.SpiConnectionSettings(){
        ChipSelectLine = cs,
        ClockFrequency = 4000000,
        Mode = GHIElectronics.TinyCLR.Devices.Spi.SpiMode.Mode0,
        ChipSelectType = SpiChipSelectType.Gpio,
        ChipSelectHoldTime = TimeSpan.FromTicks(10),
        ChipSelectSetupTime = TimeSpan.FromTicks(10)
    };

    networkCommunicationInterfaceSettings.SpiApiName = SC20260.SpiBus.Spi3;

    networkCommunicationInterfaceSettings.GpioApiName = SC20260.GpioPin.Id;

    
    networkCommunicationInterfaceSettings.SpiSettings = settings;
    networkCommunicationInterfaceSettings.InterruptPin = GetDefault().OpenPin(SC20260.GpioPin.PG6);

    networkCommunicationInterfaceSettings.InterruptEdge = GpioPinEdge.FallingEdge;
    networkCommunicationInterfaceSettings.InterruptDriveMode = GpioPinDriveMode.InputPullUp;
    networkCommunicationInterfaceSettings.ResetPin = GpioController.GetDefault().OpenPin(SC20260.GpioPin.PI8);

    networkCommunicationInterfaceSettings.ResetActiveState = GpioPinValue.Low;

    networkInterfaceSetting.Address = new IPAddress(new byte[] { 192, 168, 1, 122 });
    networkInterfaceSetting.SubnetMask = new IPAddress(new byte[] { 255, 255, 255, 0 });
    networkInterfaceSetting.GatewayAddress = new IPAddress(new byte[] { 192, 168, 1, 1 });
    networkInterfaceSetting.DnsAddresses = new IPAddress[] { new IPAddress(new byte[]
        { 75, 75, 75, 75 }), new IPAddress(new byte[] { 75, 75, 75, 76 }) };

    networkInterfaceSetting.MacAddress = new byte[] { 0x00, 0x4, 0x00, 0x00, 0x00, 0x00 };
    networkInterfaceSetting.DhcpEnable = true;
    networkInterfaceSetting.DynamicDnsEnable = true;

    networkController.SetInterfaceSettings(networkInterfaceSetting);
    networkController.SetCommunicationInterfaceSettings(networkCommunicationInterfaceSettings);

    networkController.SetAsDefaultController();

    networkController.NetworkAddressChanged += NetworkController_NetworkAddressChanged;
    networkController.NetworkLinkConnectedChanged += NetworkController_NetworkLinkConnectedChanged;

    networkController.Enable();

    while (linkReady == false) ;

    System.Diagnostics.Debug.WriteLine("Network is ready to use");

    Thread.Sleep(Timeout.Infinite);
}

private static void NetworkController_NetworkLinkConnectedChanged
    (NetworkController sender, NetworkLinkConnectedChangedEventArgs e) {

    // Raise event connect/disconnect
}

private static void NetworkController_NetworkAddressChanged
    (NetworkController sender, NetworkAddressChangedEventArgs e) {

    var ipProperties = sender.GetIPProperties();
    var address = ipProperties.Address.GetAddressBytes();
           
    linkReady = address[0] != 0;
    Debug.WriteLine("IP: " + address[0] + "." + address[1] + "." + address[2] + "." + address[3]);
}
```

--------------------------------

### Example ColorTable for 5:6:5 to 8:8:8 Conversion

Source: https://docs.ghielectronics.com/software/tinyclr/tutorials/encoding-decoding.html

Provides an example of a color table to map RGB colors from 5:6:5 to 8:8:8 format, allowing for scaled color values. This is optional and used for custom scaling.

```C#
var ColorTable565To888 = new byte[64]{
    0,2,4,8,12,16,20,24,28,32,36,40,44,48,52,56,60,64,68,72,76,80,85,89,93,97,101,105,109,113,117,121,
    125,129,133,137,141,145,149,153,157,161,165,170,174,178,182,186,190,194,198,202,206,210,214,218,222,226,230,234,238,242,246,250
};
```

--------------------------------

### OnTouchGestureStarted Method

Source: https://docs.ghielectronics.com/endpoint/api/GHIElectronics.Endpoint.UI.UIElement.html

Handles the start of touch gestures.

```csharp
protected virtual void OnTouchGestureStarted(TouchGestureEventArgs e)__
```

--------------------------------

### OnTouchGestureStarted

Source: https://docs.ghielectronics.com/endpoint/api/GHIElectronics.Endpoint.UI.UIElement.html

Handles the start of touch gestures.

```APIDOC
## OnTouchGestureStarted(TouchGestureEventArgs)

### Description
Handles the start of touch gestures.

### Method Signature
```csharp
protected virtual void OnTouchGestureStarted(TouchGestureEventArgs e)
```

### Parameters
* `e` (TouchGestureEventArgs) - The touch gesture event arguments.
```

--------------------------------

### Configure Camera and Display Images

Source: https://docs.ghielectronics.com/software/tinyclr/tutorials/camera.html

This example demonstrates setting up the camera and displaying captured images on a 4.3-inch display. It includes initializing GPIO for backlight, configuring the display controller, and setting up the camera for VGA resolution. The `Ov9655_FrameReceived` event handler draws the captured image data onto the display.

```csharp
GpioPin backlight = GpioController.GetDefault().OpenPin(SC20260.GpioPin.PA15);
backlight.SetDriveMode(GpioPinDriveMode.Output);
backlight.Write(GpioPinValue.High);

var displayController = Display.DisplayController.GetDefault();

var controllerSetting = 
    new ParallelDisplayControllerSettings {
    Width = 480,
    Height = 272,
    DataFormat = DisplayDataFormat.Rgb565,
    Orientation = DisplayOrientation.Degrees0, //Rotate display.
    PixelClockRate = 10000000,
    PixelPolarity = false,
    DataEnablePolarity = false,
    DataEnableIsFixed = false,
    HorizontalFrontPorch = 2,
    HorizontalBackPorch = 2,
    HorizontalSyncPulseWidth = 41,
    HorizontalSyncPolarity = false,
    VerticalFrontPorch = 2,
    VerticalBackPorch = 2,
    VerticalSyncPulseWidth = 10,
    VerticalSyncPolarity = false,
};

displayController.SetConfiguration(controllerSetting);
displayController.Enable();

var screen = Graphics.FromHdc(displayController.Hdc);
var controller = I2cController.FromName(SC20260.I2cBus.I2c1);

// Camera
var ov9655 = new Ov9655Controller(controller);
ov9655.FrameReceived += Ov9655_FrameReceived;
var id = ov9655.ReadId();

Debug.WriteLine("id = " + id);

ov9655.SetResolution(Ov9655Controller.Resolution.Vga);

byte temp = 0;

while (true) {
    try {
        ov9655.Capture();		
    }
    catch (System.Exception) { 
    }
	
	Thread.Sleep(10);
}

private static void Ov9655_FrameReceived(byte[] data, int size) {
	// 480 is screen width
	// 272 is screen height
	// 640 is original image width with VGA = 640
	displayController.DrawBuffer(0, 0, 0, 0, 480, 272, 640, data, 0);
}
```

--------------------------------

### ImageFormat.Guid Property

Source: https://docs.ghielectronics.com/endpoint/api/GHIElectronics.Endpoint.Drawing.Imaging.ImageFormat.html

Gets the GUID that represents the image format.

```csharp
public Guid Guid { get; }
```

--------------------------------

### RecommendedValue Property

Source: https://docs.ghielectronics.com/endpoint/api/GHIElectronics.Endpoint.UI.Controls.Gauge.html

Gets or sets the recommended value, which marks the start of the green area on the Gauge control's scale.

```APIDOC
## RecommendedValue

### Description
Threshold value from which green area will be marked.

### Property Value
float
```

--------------------------------

### Run(Window)

Source: https://docs.ghielectronics.com/endpoint/api/GHIElectronics.Endpoint.UI.Application.html

Starts the application by setting up the main window and triggering startup events. Developers typically configure application properties and event handlers before calling this method.

```APIDOC
## Run(Window)

### Description
Starts the application. Typically, a developer will set properties and attach to events after instantiating an application object, and then call Run() to start the application.

### Method
public void Run(Window window)

### Parameters
#### Path Parameters
* None

#### Query Parameters
* None

#### Request Body
* None

### Request Example
* None

### Response
#### Success Response
* None

#### Response Example
* None

### Remarks
Once run has been called - an application's OnStartup override and Startup event is called immediately afterwards.
```

--------------------------------

### NetworkStream Example

Source: https://docs.ghielectronics.com/software/tinyclr/tutorials/stream.html

Illustrates the creation of a NetworkStream from a network socket.

```csharp
var myNetworkStream = new NetworkStream(networkSocket);
```

--------------------------------

### Modbus RTU Master Example

Source: https://docs.ghielectronics.com/software/tinyclr/tutorials/modbus.html

This snippet demonstrates how to configure and use a Modbus RTU master to read holding registers over RS485. Ensure the GHIElectronics.TinyCLR.Devices.Uart, GHIElectronics.TinyCLR.Pins, and GHIElectronics.TinyCLR.Devices.Modbus NuGet packages are installed.

```C#
var serial = UartController.FromName(SC20100.UartPort.Uart5);

var uartSetting = new UartSetting(){
        BaudRate = 19200,
        DataBits = 8,
        Parity = UartParity.None,
        StopBits = UartStopBitCount.One,
        Handshaking = UartHandshake.None,
    };

serial.SetActiveSettings(uartSetting);

serial.Enable();

IModbusInterface mbInterface;
mbInterface = ModbusRtuInterface(
    serial,
    19200,
    8,
    UartStopBitCount.One,
    UartParity.None);

ModbusMaster mbMaster;
mbMaster = new ModbusMaster(mbInterface);

var mbTimeout = false;

ushort[] reply = null;
int count = 0;

while (true) {
    try {
        mbTimeout = false;

        reply = mbMaster.ReadHoldingRegisters(10, 0, 1, 3333);
        count++;

        if (count == 5)
            break;
    }
    catch (System.Exception error) {
        Debug.WriteLine("Modbus Timeout");
        mbTimeout = true;
    }

    if (!mbTimeout) {
        Debug.WriteLine("Modbus : " + (object)reply[0].ToString());
    }

    Thread.Sleep(1000);
}
```

--------------------------------

### Initialize and Configure Ethernet/IP Adapter

Source: https://docs.ghielectronics.com/software/tinyclr/tutorials/ethernet-ip.html

This snippet demonstrates the complete initialization process for the Ethernet/IP adapter, including setting device details, creating assembly objects, configuring connection points, and enabling the adapter. Ensure the necessary NuGets are installed.

```csharp
public static void DoInitAdapter()
{
    string deviceName = "GHI Adapter";
	uint deviceVendorID = 3;
	ushort deviceType = 12;
	ushort deviceProductCode = 65001;
	uint deviceSerialNumber = 87654321;
	byte deviceMajorRevision = 4;
	byte deviceMinorRevision = 3;
	
	var adapter = new AdapterController(deviceName, deviceVendorID, deviceType, deviceProductCode, deviceSerialNumber, deviceMajorRevision, deviceMinorRevision);

    adapter.EnableHeaderO2T(true); // enable O2T 32bit header
	
	int numberClassAttributes = 0 ;
	uint highestClassAttributeNumber = 7;
	int numberClassServices = 1;
	int numberInstanceAttributes = 2;
	uint highestInstanceAttributeNumber = 4;
	int numberInstanceServices = 2;
	uint numberInstances = 0;
	string name = "assembly";
	ushort revision = 2;

    adapter.CreateAssemblyClass(numberClassAttributes, highestClassAttributeNumber, numberClassServices, numberInstanceAttributes, highestInstanceAttributeNumber,  numberInstanceServices, numberInstances, name, revision);

    MessageRouterInit(adapter);
    IdentityInit(adapter);
    ConnectionManagerInit(adapter);
	

    var g_assembly_t_o = new byte[T_O_IODataSize]; 
    var g_assembly_o_t = new byte[O_T_IODataSize]; 
    var g_assembly_cfg = new byte[Config_DataSize]; 
    var g_assembly_explicit = new byte[ExplicitMessage_DataSize]; 

    var input_asm = new AssemblyObject(DEMO_APP_INPUT_ASSEMBLY_NUM, g_assembly_t_o, (ushort)g_assembly_t_o.Length);
    var output_asm = new AssemblyObject(DEMO_APP_OUTPUT_ASSEMBLY_NUM, g_assembly_o_t, (ushort)g_assembly_o_t.Length);
    var config_asm = new AssemblyObject(DEMO_APP_CONFIG_ASSEMBLY_NUM, g_assembly_cfg, (ushort)g_assembly_cfg.Length);
    var heartbeat_input_asm = new AssemblyObject(DEMO_APP_HEARTBEAT_INPUT_ONLY_ASSEMBLY_NUM, null, 0);
    var heartbeat_output_asm = new AssemblyObject(DEMO_APP_HEARTBEAT_LISTEN_ONLY_ASSEMBLY_NUM, null, 0);
    var explicit_asm = new AssemblyObject(DEMO_APP_EXPLICT_ASSEMBLY_NUM, g_assembly_explicit, (ushort)g_assembly_explicit.Length);

    adapter.AddAssemblyObject(input_asm);
    adapter.AddAssemblyObject(output_asm);
    adapter.AddAssemblyObject(config_asm);
    adapter.AddAssemblyObject(heartbeat_input_asm);
    adapter.AddAssemblyObject(heartbeat_output_asm);
    adapter.AddAssemblyObject(explicit_asm);

    adapter.ConfigureExclusiveOwnerConnectionPoint(0, DEMO_APP_OUTPUT_ASSEMBLY_NUM, DEMO_APP_INPUT_ASSEMBLY_NUM, DEMO_APP_CONFIG_ASSEMBLY_NUM);
    adapter.ConfigureInputOnlyConnectionPoint(0, DEMO_APP_HEARTBEAT_INPUT_ONLY_ASSEMBLY_NUM, DEMO_APP_INPUT_ASSEMBLY_NUM, DEMO_APP_CONFIG_ASSEMBLY_NUM);
    adapter.ConfigureListenOnlyConnectionPoint(0, DEMO_APP_HEARTBEAT_LISTEN_ONLY_ASSEMBLY_NUM, DEMO_APP_INPUT_ASSEMBLY_NUM, DEMO_APP_CONFIG_ASSEMBLY_NUM);


    adapter.RegisterSessionDetected += Adapter_RegisterSessionDetected;
    adapter.UnregisterSessionDetected += Adapter_UnregisterSessionDetected;

    adapter.ForwardOpenDetected += Adapter_ForwardOpenDetected;
    adapter.ForwardCloseDetected += Adapter_ForwardCloseDetected;

    adapter.Enable();
	
	Thread.sleep(-1);
}

```

--------------------------------

### Initialize Display and Create UI Window

Source: https://docs.ghielectronics.com/software/tinyclr/tutorials/user-interface.html

This snippet shows how to initialize the display controller, set its configuration, enable it, and create a basic window with a gradient background. It includes necessary using statements and setup for the UI application.

```C#
using GHIElectronics.TinyCLR.Devices.Display;
using GHIElectronics.TinyCLR.Devices.Gpio;
using GHIElectronics.TinyCLR.Devices.I2c;
using GHIElectronics.TinyCLR.Native;
using GHIElectronics.TinyCLR.Pins;
using GHIElectronics.TinyCLR.UI;
using GHIElectronics.TinyCLR.UI.Media;
using System.Drawing;

namespace UserInterfaceExample {
    class Program : Application {
        public Program(DisplayController d) : base(d){
        }
        static Program app;

        static void Main() {
            GpioPin backlight = GpioController.GetDefault().OpenPin(SC20260.GpioPin.PA15);
            backlight.SetDriveMode(GpioPinDriveMode.Output);
            backlight.Write(GpioPinValue.High);
            var display = DisplayController.GetDefault();

            var controllerSetting = new 
                GHIElectronics.TinyCLR.Devices.Display.ParallelDisplayControllerSettings {
                Width = 480,
                Height = 272,
                DataFormat = GHIElectronics.TinyCLR.Devices.Display.DisplayDataFormat.Rgb565,
                Orientation = DisplayOrientation.Degrees0, //Rotate display.
                PixelClockRate = 10000000,
                PixelPolarity = false,
                DataEnablePolarity = false,
                DataEnableIsFixed = false,
                HorizontalFrontPorch = 2,
                HorizontalBackPorch = 2,
                HorizontalSyncPulseWidth = 41,
                HorizontalSyncPolarity = false,
                VerticalFrontPorch = 2,
                VerticalBackPorch = 2,
                VerticalSyncPulseWidth = 10,
                VerticalSyncPolarity = false,
            };

            display.SetConfiguration(controllerSetting);
            display.Enable();

            var screen = Graphics.FromHdc(display.Hdc);
            var controller = I2cController.GetDefault();

            app = new Program(display);
            app.Run(Program.CreateWindow(display));
        }

        private static Window CreateWindow(DisplayController display){
            var window = new Window {
                Height = (int)display.ActiveConfiguration.Height,
                Width = (int)display.ActiveConfiguration.Width
            };

            window.Background = new LinearGradientBrush
                (Colors.Blue, Colors.Teal, 0, 0, window.Width, window.Height);

            window.Visibility = Visibility.Visible;

            return window;
        }
    }
}
```

--------------------------------

### AWS IoT Core MQTT Client Setup

Source: https://docs.ghielectronics.com/software/tinyclr/tutorials/aws.html

This snippet demonstrates the setup of an MQTT client for AWS IoT Core, including certificate loading and connection configuration. Ensure you have your AWS endpoint, device ID, root CA, client certificate, and private key.

```C#
var iotEndPoint = "Need your Rest API Endpoint";
var iotPort = 8883;
var deviceId = "Need your Device ID";

var topicShadowUpdate = string.Format("$aws/things/{0}/shadow/update", deviceId);
var topicShadowGet = string.Format("$aws/things/{0}/shadow/get", deviceId);

var message = "{\"state\":{\"desired\":{\"My message\":\"Hello World"}}}";

var caCertSource = UTF8Encoding.UTF8.GetBytes("Need AWS root CA certificate");
var clientCertSource = UTF8Encoding.UTF8.GetBytes("Need your AWS client CA certificate");
var privateKeyData = UTF8Encoding.UTF8.GetBytes("Need your AWS private key");

X509Certificate CaCert = new X509Certificate(caCertSource);
X509Certificate ClientCert = new X509Certificate(clientCertSource);

ClientCert.PrivateKey = privateKeyData;    

var clientSetting = new MqttClientSetting {
    BrokerName = iotEndPoint,
    BrokerPort = iotPort,
    CaCertificate = CaCert,
    ClientCertificate = ClientCert,
    SslProtocol = System.Security.Authentication.SslProtocols.Tls12
};

var iotClient = new Mqtt(clientSetting);

iotClient.PublishReceivedChanged += (p1, p2, p3, p4, p5, p6) => {
Debug.WriteLine("Received message: " + Encoding.UTF8.GetString(p3));
};

iotClient.SubscribedChanged += (a, b) => { Debug.WriteLine("Subscribed"); };

Debug.WriteLine("Connecting....")

var connectSetting = new MqttConnectionSetting {
    ClientId = deviceId,
    UserName = null,
    Password = null
};

var connectCode = iotClient.Connect(connectSetting);

ushort packetId = 1;

iotClient.Subscribe(new string[] { topicShadowGet }, new QoSLevel[]
    { QoSLevel.LeastOnce }, packetId++);
            
iotClient.Publish(topicShadowUpdate, Encoding.UTF8.GetBytes(message),
    QoSLevel.MostOnce, false, packetId++);
```

--------------------------------

### Read Adafruit IO Feed Status via HTTP GET

Source: https://docs.ghielectronics.com/software/tinyclr/tutorials/adafruit-io.html

This snippet retrieves the status of an Adafruit IO toggle feed using an HTTP GET request. Ensure the Adafruit certificate is loaded and an internet connection is active. The `x-aio-key` header requires your Adafruit IO key, and the feed name should match your Adafruit IO setup. For toggles, ensure `Button On Text` is '1' and `Button Off Text` is '0' in Adafruit IO.

```C#
url = "https://io.adafruit.com/api/v2/adafruit_io_username/
    feeds/toggleswitch/data?include=value&limit=1";

var cert = Resource.GetBytes(Resource.BinaryResources.DigiCertGlobalRootG2);

certx509 = new X509Certificate[] { new X509Certificate(cert) };

using (var getRequest = HttpWebRequest.Create(url) as HttpWebRequest) {
    getRequest.KeepAlive = false;
    getRequest.HttpsAuthentCerts = certx509;
    getRequest.ReadWriteTimeout = 2000;
    getRequest.Headers.Add("x-aio-key: your_adafruit_io_key_goes_here");
    getRequest.Method = "GET";

    using (var response = getRequest.GetResponse() as HttpWebResponse){
        using (var stream = response.GetResponseStream()) {
            do {
                read = stream.Read(result, 0, result.Length);
                total += read;

                System.Diagnostics.Debug.WriteLine("read : " + read);
                System.Diagnostics.Debug.WriteLine("total : " + total);

                String page = "";

                page = new String(System.Text.Encoding.UTF8.GetChars
                    (result, 0, read));

                System.Diagnostics.Debug.WriteLine("Response : " + page);
            }
            while (read != 0);
        }
    }
}

```

--------------------------------

### Initialize and Use Configuration Storage

Source: https://docs.ghielectronics.com/software/tinyclr/tutorials/secure-storage.html

Demonstrates how to initialize the configuration secure storage, check if it's blank, erase it, write data, and verify the written data. Requires GHIElectronics.TinyCLR.Core and GHIElectronics.TinyCLR.Devices.SecureStorage NuGet packages.

```csharp
const uint STORAGE_SIZE = 32 * 1024;
var configStorage = new SecureStorageController(SecureStorage.Configuration);
var data = new byte[STORAGE_SIZE];

Debug.WriteLine("Configuration storage total size: " +
    configStorage.TotalSize.ToString() + " bytes.");

Debug.WriteLine("Configuration storage block size: " +
    configStorage.BlockSize.ToString() + " bytes.");

Debug.WriteLine("Checking if blank. . .");
var isBlank = true;

for (uint block = 0; block < configStorage.TotalSize / configStorage.BlockSize; block++) {
    if (!configStorage.IsBlank(block)) isBlank = false;
}

if (isBlank) {
    Debug.WriteLine("Configuration storage area is blank.");
}
else {
    Debug.WriteLine("Erasing entire configuration storage area...");
    configStorage.Erase();
}

Debug.WriteLine("Filling buffer...");

for (var i = 0; i < data.Length; i++) {
    data[i] = (byte)(i % 255);
}

Debug.WriteLine("Writing buffer...");
var dataBlock = new byte[configStorage.BlockSize];

for (uint block = 0; block < data.Length / configStorage.BlockSize; block++) {
    Array.Copy(data, (int)(block * configStorage.BlockSize), dataBlock, 0,
        (int)(configStorage.BlockSize));

    configStorage.Write(block, dataBlock);
}

Debug.WriteLine("Comparing buffer...");

for (uint block = 0; block < data.Length / configStorage.BlockSize; block++) {
    for (var byteIndex = 0; byteIndex < configStorage.BlockSize; byteIndex++) {
        configStorage.Read(block, dataBlock);

        if (data[block * configStorage.BlockSize + byteIndex] != dataBlock[byteIndex]) {
            Debug.WriteLine("Configuration storage data is corrupted!");
            Thread.Sleep(Timeout.Infinite);
        }
    }
}

Debug.WriteLine("Configuration storage is good to go!!!");
```

--------------------------------

### Initialize DisplayController and Draw Graphics

Source: https://docs.ghielectronics.com/endpoint/api/GHIElectronics.Endpoint.Devices.Display.DisplayController.html

This snippet demonstrates the complete setup for a GHIElectronics display, including GPIO configuration for backlight, display controller initialization with custom timing, and drawing various SkiaSharp elements like bitmaps, circles, ovals, lines with gradients and dashes, and text with custom fonts and styles. It runs in an infinite loop to continuously update the display.

```C#
using System.Device.Gpio;
using System.Device.Gpio.Drivers;
using GHIElectronics.Endpoint.Core;
using GHIElectronics.Endpoint.Devices.Display;
using SkiaSharp;
using EndpointDisplayTest.Properties;

var backlightPort = EPM815.Gpio.Pin.PD14 /16;
var backlightPin = EPM815.Gpio.Pin.PD14 % 16;

var gpioDriver = new LibGpiodDriver((int)backlightPort);
var gpioController = new GpioController(PinNumberingScheme.Logical, gpioDriver);
gpioController.OpenPin(backlightPin, PinMode.Output);
gpioController.Write(backlightPin, PinValue.High); 
var screenWidth = 480;
var screenHeight = 272;

SKBitmap bitmap = new SKBitmap(screenWidth, screenHeight, SKImageInfo.PlatformColorType, SKAlphaType.Premul);
bitmap.Erase(SKColors.Transparent);

var configuration = new FBDisplay.Configuration(){
    Clock = 10000,
    Width = 480,
    Hsync_start = 480 + 2,
    Hsync_end = 480 + 2 + 41,
    Htotal = 480 + 2 + 41 + 2,
    Height = 272,
    Vsync_start = 272 + 2,
    Vsync_end = 272 + 2 + 10,
    Vtotal = 272 + 2 + 10 + 2,

};
var fbDisplay = new FBDisplay(configuration);
var displayController = new DisplayController(fbDisplay);
var imageWidth = 100;
var imageHeight = 67;

while (true){
    //Initialize Screen
    using (var screen = new SKCanvas(bitmap)){
        //Create Black Screen 
        screen.DrawColor(SKColors.Black);
        screen.Clear(SKColors.Black); //same thing but also erases anything else on the canvas first

        // Draw Logo from Resources
        var logo = Resources.logo;
        var info = new SKImageInfo(imageWidth, imageHeight);
        var sk_img = SKBitmap.Decode(logo, info);
        screen.DrawBitmap(sk_img, 0, 200);

        // Draw circle
        using (SKPaint circle = new SKPaint()){
            circle.Color = SKColors.Blue;
            circle.IsAntialias = true;
            circle.StrokeWidth = 15;
            circle.Style = SKPaintStyle.Stroke;
            screen.DrawCircle(410, 220, 30, circle); //arguments are x position, y position, radius, and paint
        }

        // Draw Oval
        using (SKPaint oval = new SKPaint()){
            oval.Style = SKPaintStyle.Stroke;
            oval.Color = SKColors.Blue;
            oval.StrokeWidth = 10;
            screen.DrawOval(300, 20, 60, 10, oval);
            oval.Style = SKPaintStyle.Fill;
            oval.Color = SKColors.SkyBlue;
            screen.DrawOval(300, 20, 60, 10, oval);
        }

        // Draw Line
        float[] intervals = [10, 20, 10, 20, 5, 40,];//sets the dash intervals
        using (SKPaint line = new SKPaint()){
            line.Color = SKColors.Red;
            line.IsAntialias = true;
            line.StrokeWidth = 20;
            line.Style = SKPaintStyle.Stroke;

            //Rounds the ends of the line
            line.StrokeCap = SKStrokeCap.Round;

            //Creates dashes in line based on intervals array
            line.PathEffect = SKPathEffect.CreateDash(intervals, 25);

            // Create linear gradient from upper-left to lower-right
            line.Shader = SKShader.CreateLinearGradient(
            new SKPoint(0, 0),
            new SKPoint(screenWidth, screenHeight),
            new SKColor[] { SKColors.Red, SKColors.Blue },
            new float[] { 0, 1 },
            SKShaderTileMode.Repeat);
            screen.DrawLine(0, 0, 400, 200, line);
        }

        //Using SkiaTypeface
        byte[] fontfile = Resources.OldeEnglish;
        Stream stream = new MemoryStream(fontfile);

        using (SKPaint textPaint = new SKPaint())
        using (SKTypeface tf = SKTypeface.FromStream(stream)){
            textPaint.Color = SKColors.White;
            textPaint.IsAntialias = true;
            textPaint.StrokeWidth = 2;
            textPaint.Style = SKPaintStyle.Stroke;

            //SKFont Text - 
            SKFont font = new SKFont();
            font.Size = 40;
            font.ScaleX = 2;
            font.Typeface = tf;
            SKTextBlob textBlob = SKTextBlob.Create("D", font);
            screen.DrawText(textBlob, 10, 150, textPaint);
        }

        // Draw Basic text
        using (SKPaint text = new SKPaint()){
            text.Color = SKColors.Yellow;
            text.IsAntialias = true;
            text.StrokeWidth = 2;
            text.Style = SKPaintStyle.Stroke;
            screen.DrawText("Hello World", 20, 20, text);
        }

        // Draw text
        using (SKPaint text = new SKPaint()){
            text.Color = SKColors.Yellow;
            text.IsAntialias = true;
            text.StrokeWidth = 2;
            text.Style = SKPaintStyle.Stroke;

            //SKFont Text - 
            SKFont font = new SKFont();
            font.Size = 22;
            font.ScaleX = 2;
            SKTextBlob textBlob = SKTextBlob.Create("I am Yellow", font);
            screen.DrawText(textBlob, 50, 100, text);
        }

        // Character Outlines
        using (SKPaint textPaint = new SKPaint()){
        // Set Style for the character outlines

```

--------------------------------

### Basic MQTT Client Connection and Messaging

Source: https://docs.ghielectronics.com/software/tinyclr/tutorials/mqtt.html

This snippet shows how to initialize an MQTT client, connect to a broker, subscribe to a topic, and publish messages. It requires the GHIElectronics.TinyCLR.Networking.Mqtt NuGet package. Ensure your certificate, host, port, and credentials are correctly configured.

```C#
var caCertificate = new X509Certificate(UTF8Encoding.UTF8.GetBytes("Your certificate"));

var mqttHost = "your_host";
var mqttPort = 8883; //default 8883
var deviceId = "your_device_id";

var username = "your_username";
var password = "your_password";
var topic = "your_topic";

try {
    var clientSetting = new MqttClientSetting {
        BrokerName = mqttHost,
        BrokerPort = mqttPort,
        ClientCertificate = null,
        CaCertificate = caCertificate,
        SslProtocol = System.Security.Authentication.SslProtocols.Tls12
    };

    var client = new Mqtt(clientSetting);

    var connectSetting = new MqttConnectionSetting {
        ClientId = deviceId,
        UserName = username,
        Password = password
    };

    // Connect to host
    var returnCode = client.Connect(connectSetting);

    var packetId = 1;
                
    // Subscribe to a topic
    client.Subscribe(new string[] { topic }, new QoSLevel[] { QoSLevel.ExactlyOnce },
        (ushort)packetId++);

    // Publish a topic
    client.Publish(topic, Encoding.UTF8.GetBytes("your message"), QoSLevel.MostOnce,
        false, (ushort)packetId);

    // Publish recieved change from a specific topic
    client.PublishReceivedChanged += (object sender, string topic, byte[] data, bool duplicate, QoSLevel qosLevel, bool retain) => {
    Debug.WriteLine("Received message: " + Encoding.UTF8.GetString(data));
    };

} 
catch (Exception e) { 
}
```

--------------------------------

### Application Constructor

Source: https://docs.ghielectronics.com/endpoint/api/GHIElectronics.Endpoint.UI.Application.html

Initializes a new instance of the Application class with specified width and height.

```APIDOC
## Application(int width, int height)

### Description
Initializes a new instance of the Application class.

### Parameters
#### Parameters
- **width** (int) - The initial width of the application.
- **height** (int) - The initial height of the application.
```

--------------------------------

### Draw Text in Rectangle (with Relative Start)

Source: https://docs.ghielectronics.com/endpoint/api/GHIElectronics.Endpoint.Drawing.Graphics.html

Draws text within a specified rectangle, returning a boolean indicating success and modifying relative start coordinates.

```csharp
public bool DrawTextInRect(ref string text, ref int xRelStart, ref int yRelStart, int x, int y, int width, int height, Graphics.DrawTextAlignment dtFlags, Color color, Font font)
```

--------------------------------

### LinearGradientBrush Constructor with Colors and Coordinates

Source: https://docs.ghielectronics.com/endpoint/api/GHIElectronics.Endpoint.UI.Media.LinearGradientBrush.html

Initializes a new instance of the LinearGradientBrush class with specified start and end colors, and the start and end coordinates of the gradient. Use this constructor to define a precise gradient orientation.

```csharp
public LinearGradientBrush(Color startColor, Color endColor, int startX, int startY, int endX, int endY)
```

--------------------------------

### DeviceInformation.SdBoot

Source: https://docs.ghielectronics.com/endpoint/api/GHIElectronics.Endpoint.Native.DeviceInformation.html

Initiates a boot process from the SD card.

```APIDOC
## Method SdBoot

### Description
Initiates a boot process from the SD card.

### Method Signature
```csharp
public static bool SdBoot()
```

#### Returns
bool - Returns true if the SD boot process was initiated successfully, false otherwise.
```

--------------------------------

### OnStartup Method

Source: https://docs.ghielectronics.com/endpoint/api/GHIElectronics.Endpoint.UI.Application.html

Called to raise the Startup event. Can be overridden to perform actions at application startup.

```APIDOC
## OnStartup(EventArgs e)

### Description
Called to raise the Startup event. Developers can override this method to take action at startup time. This method is called once when the application begins after the Run() method has been called.

### Parameters
#### Parameters
- **e** (EventArgs) - The event arguments passed to the Startup event.

### Remarks
If you override this method, you need to call Base.OnStartup(...) for the corresponding event to be raised.
```

--------------------------------

### Enable and Start mDNS Service

Source: https://docs.ghielectronics.com/software/tinyclr/tutorials/networking-core.html

Enable Multicast DNS on a network interface and start the mDNS service with a specified name and Time To Live (TTL). Note that mDNS support may vary by operating system.

```csharp
networkInterfaceSetting.MulticastDnsEnable = true;

networkController.Enable();

MulticastDns.Start("MyServer", TimeSpan.FromSeconds(1*60*60));
```

--------------------------------

### Run Method

Source: https://docs.ghielectronics.com/endpoint/api/GHIElectronics.Endpoint.UI.Application.html

Starts the application. Typically called after setting properties and attaching to events.

```APIDOC
## Run()

### Description
Starts the application. Typically called after instantiating an application object, setting properties, and attaching to events.

### Method
public void Run()
```
Tokens:
Raw