GHI.Premium.Hardware

Provides Watchdog functionality.

Watchdog is used to reset the system if it enters an erroneous state. The Watchdog is enabled with a specified timeout. The user must keep resetting the Watchdog time counter within this timeout interval or otherwise the system will reset.
Watchdog.LastResetCause gives you information about the last known reset cause. Note that this flag is automatically reset after it is read.

This should only be used by advanced users.

Note: On some systems, once the Watchdog is enabled, it cannot be disabled.

Enables the Watchdog.

Timeout in milli-seconds.

Disables the Watchdog.

Resets the Watchdog time counter.

Last known reset cause.

This can be used for troubleshooting when the system resets. Note that this flag is automatically reset after it is read.

EMX and G120
Works correctly.

Maximum supported timeout.

Value is platform dependant.

Cause of system reset.

Hard reset.

Reset because of the Watchdog timer elapsing.

Master I2C bus functionality implemented in software.

This class provides I2C functionality on any two digital pins. It is implemented by toggling the pins using software. It only supports one master on the same bus. Multiple masters on different buses work correctly.

You must provide two pins: one for I2C clock and one for I2C data. The user must connect external pull-up resistors on the pins as required for I2C operation.

Currently, only 7-bit I2C addresses are supported.
Clock rate is currently ignored. Specify 0 for this field. This will make the rate as fast as possible.

Creates an I2C bus using the clock and data pins.

Clock pin. Data pin.

Creates an I2C device on the bus.

Address of the device. This must be a 7 bit address. Clock rate in KHz. Currently ignored. Specify 0 to go as fast as possible. Created I2C device.

Processes I2C directly without creating objects.

Clock pin. Data pin. Clock rate in KHz. Address of the device. Write buffer. Offset into the write buffer. Number of bytes to write. Read buffer. Offset into the read buffer. Number of bytes to read. Number of bytes written successfully. Number of bytes read successfully. true if all the required bytes are written and read successfully. Do not use this method. It is intended for internal use only. See CreateI2CDevice instead.

Disposes the I2C bus.

Represents an I2C device on a bus.

Writes a data buffer to the I2C device.

Buffer. Offset into the buffer. Number of bytes to write. Number of bytes sent successfully.

Reads a data buffer from the I2C device.

Buffer. Offset into the buffer. Number of bytes to read. Number of bytes read successfully.

Writes a data buffer then reads a data buffer from the I2C device.

Write buffer. Offset into the write buffer. Number of bytes to write. Read buffer. Offset into the read buffer. Number of bytes to read. Number of bytes written successfully. Number of bytes read successfully. true if all the required bytes are written and read successfully.

Provides ParallelPort functionality.

This class controls multiple pins at the same time. The data is written and/or read by using 8 data pins.
The pins can be any I/Os available on the used platform.
When writing to the ParallelPort, the write pin is pulsed after each byte to signal that data is ready. The write pin is required for writing operation.
When reading from the ParallelPort, the read pin is pulsed before each byte to signal that data will be read. The read pin is required for reading operation.

Creates a new ParallelPort.

Must be valid 8 data pins. dataPins[0] corresponds to data bit 0 and so on. This pin must be provided for writing. The pin is active low.

Writes data to the ParallelPort.

Data buffer. Offset. Count.

Disposes the ParallelPort and all used pins.

Captures the pin's digital waveform into a buffer.

This performs a simple Pin Capture. It blocks all the managed threads until a specified timeout is passed or the specified pin toggles count is reached.
When the pin's state changes, the state, high or low, time is calculated and stored.

The pin can be an InputPort or an InterruptPort. The underlying Port object can be obtained from this class and controlled directly.

Constructor for input and interrupt pins.

Pin. Resistor mode.

Constructor for interrupt pins only.

Pin. Resistor mode. Interrupt mode.

Reads the pin's waveform. The method stores the initial state for the user.

The initial state of the pin. Buffer holds the pin toggle times in microseconds. Offset. Count. Timeout in milliseconds. Number of pin toggles.

Reads the pin's waveform after waiting for an initial state.

Waits for this pin state before starting the capture. The buffer holds the pin toggle times in microseconds. Offset. Count. Timeout in milliseconds. Number of pin toggles.

Disposes the pin and marks it as available.

Gets the underlying Port object for this pin.

CAN error received event arguments.

Constructor.

CAN error.

Associated error with this event.

CAN data received event arguments.

CAN data received event handler.

CAN sender. Event arguments.

CAN error received event handler.

CAN sender. Event arguments.

Provides Controller Area Network (CAN) functionality.

Controller Area Network (CAN) is a common network in the automotive industry. This class provides functions to read/write messages, Get events for incoming data or errors, and set filters on messages' IDs.

Platform Support

Using CAN
CAN is constructed using the channel number and the bitrate. Note that the bitrate defines the timings needed and must be set as provided in the example section.
Since processing all incoming messages is important, there is an optional receiveBufferSize argument. You can increase the number of bufferd messages to make sure the application can process all of them. Also, it is recommended to use the filters.

Messages are read using GetMessages(...). This method is optimized for batch reading. The more messages read, the faster it will be versus reading them individually. Event are sent when messages are available. Also, ReceivedMessagesCount provides the number of available messages.

Messages are written using PostMessages(...). The messages are queued for transmission. PostedMessagesSent specifies whether all messages are transmitted.

CAN Errors
CAN errors are sent as events to the user using ErrorReceivedEvent. RXOver error is sent when the input buffer is full and a message is lost. In this case, you can increase the receive buffer size in the CAN constructor and use the CAN filters. Another important error is BusOff. When this error occurs, the CAN controller is stopeed from further communications. To enable the controller again, use CAN.Reset.
Also, there are error counters: ReceiveErrorCount and TransmitErrorCount.

CAN Filters
Software filters for messages' IDs are supported for exact and group matches. One of them or both can be used at the same time. Exact matches are done using SetExplicitFilters. Only messages with identifiers included in these filters will pass through to the receive buffer. Group identifiers defines a group (range) or more of messages that are filtered using SetGroupFilters. Only messages with identifiers between a lower bound and an upper bound are passed to the receive buffer. Searching through software filters is done natively and highly optimized.
Hardware filters are not directly supported but can be set using registers (Register class). You can set explicit or group identifiers for each CAN controller. For complete details, please see LPC24xx User Manual.
A combination of software and hardware filters can be used.

Sets explicit filters.

Messages' IDs to filter. This filters exact matches for message identifiers (standard or extended). The provided filters will be copied internally and searched using an optimized software search.
For example, to only receive messages with these IDs (0x1234, 0x5789, 0x12345678), do the following:


            uint[] explicitIDs = new uint[] {0x1234, 0x5789, 0x12345678};
            can.SetExplicitFilters(explicitIDs);

Sets group (range) filters.

Group lower bounds for messages' IDs to filter. Each lower bound corresponds to an upper bound. Group upper bounds for messages' IDs to filter. Each upper bound corresponds to a lower bound. This filters a group (range) of message identifiers (standard or extended). The provided filters will be copied internally and searched using an optimized software search.
Every pair of a lower bound at index i and an upper bound at the same index defines a valid group. The provided groups MUST not overlap. Otherwise, the method will throw an argument exception.
For example, to only receive messages with these two groups of IDs [0x1200 to 0x1248] and [0x500 to 0x1000], do the following:


            uint[] lowerBounds = new uint[] { 0x1200, 0x500 };
            uint[] upperBounds = new uint[] { 0x1248, 0x1000 };
            can.SetGroupFilters(lowerBounds, upperBounds);

Note that the bounds' limits are considered valid. In the above example, 0x1200, 0x1248, 0x500 and 0x1000 are valid IDs and will pass through to the receive buffer.

Disables the explicit filters.

Disables the group filters.

Initializes CAN.

Channel. Bitrate. Refer to provided the example. For bitrate calculation, please see the provided example.

Initializes CAN.

Channel. Bitrate. Refer to provided the example. Specifies the receive buffer size (number of internally buffered CAN messages). For bitrate calculation, please see the provided example.

Resets the CAN controller.

This methods resets the CAN controller. This is needed in the Bus Off condition because the controller get disabled automatically.
Note that a reset causes the hardware buffered messages to be lost (this is 2 for receive and 3 for transmit). The software receive buffer is not affected. The software filters are not affected either.

Receives CAN messages.

User provided messages buffer. Offset into the buffer. Number of messages to read. Number of read messages. This methods reads messages, if available, and returns how many messages it was able to read.

Posts (queues for writing) CAN messages.

User provided messages buffer. Offset into the buffer. Number of messages to write. Number of written messages. This methods writes as many messages as possible until the internal buffers are full. The user MUST check the return value to see how many messages were written.

Disposes CAN.

Data received event.

The event will fire only once when CAN messages are received. Then the user can read as many CAN messages as possible. If there are more unread messages, the event will fire again automatically.

Error received event.

CAN receive error count.

CAN transmit error count.

The number of messages ready to be read.

A boolean value denoting if all posted (queued for writing) messages are sent.

CAN errors.

A CAN message is lost because the hardware was not able to receive the message in time.

A CAN message is lost because the receive buffer is full. Try increasing the receive message buffer in the CAN constructor and use CAN filters.

CAN Bus Off condition. Note that the controller is disabled in this case. Use CAN.Reset() to re-enable it.

Error passive condition.

Lists the available CAN channels.

CAN channel.

CAN message.

The CAN message data.

The message data is a maximum of 8 bytes. The user store data directly before trasmitting.
When receiving data, the user can read this field directly.

CAN message ID.

CAN message data count.

Specifies if the message is RTR (Remote Transmission Request).

Specifies if the message is EID (Extended ID - 29 bit identifier). Otherwise, it is 11 bit identifier.

Received message time stamp.

Provides access to some hardware and software configurations.

Some of the configurations must only be used by advanced users. If you need to revert to the default settings and you are not able to do so in software, you must download TinyCLR firmware files and possibly TinyBooter again to your hardware. The configurations are normally saved in the config file.
Configurations will be saved internally and always used for future reboots, unless otherwise noted.

Note: You must reset the hardware after you change the settings for them to take effect, unless otherwise noted.

Startup logo.

You can set a custom startup logo for your device. This is saved internally and will be used on every reboot.
There are restrictions on the size of the logo, see SupportedWidth and SupportedHeight. This class only accepts a Bitmap byte array which can be generated from myBitmap.GetBitmap().

Sets custom Startup logo.

Bitmap bytes. Logo x position. Logo y position. true if configurations where updated. false if configurations did not change.

Gets/Sets Startup Logo enable.

Supported Width.

Currently fixed to 180.

Supported Height.

Currently fixed to 180.

LCD configurations.

This class can change the used LCD. You can change the needed display settings to match your LCD requirements.
Do not use LCD_Configuration.PriorityEnable unless necessary. It may degrade performance.

Note that setting PixelClockRateKHz to 0 will not refresh the LCD and it will be disabled.
EMX
The LCD Controller Source Clock is 72 MHz. LCD Clock = PixelClockRateKHz
Maximum supported resolution is 800x600.

Changes LCD orientation.

Rotation setting. true if configurations where updated. false if configurations did not change. This is used to rotate the LCD. For example, if the LCD need to be viewed from the side or upside down.
Typically, an LCD with the needed orientation should be used and this method is not needed. But in cases where the LCD cannot be changed, use this function.
Assume an LCD with 320x240 resolution. After rotation 90 degrees, the LCD graphics will be 240x320 instead.
Note that because of the dimension change, the LCD must NOT be rotated while WPF is active. Typically, the user will set the LCD rotation at startup and then run the WPF application.
The change in dimensions and LCD rotation is done in software and consumes CPU processing time when graphics are flushed to the LCD. Therefore, only use it if necessary.
Also, when LCD is rotated, touch events are rotated accordingly. You need to set the touch calibration after rotation.

For example to rotate 320x240 LCD to output 240x320 graphics,
1) Set rotation to CW 90 degrees.
2) Start WPF. Dimensions and graphics are 240x320 now.
3) Calibrate touch if used.

Note: Rotation settings are done dynamically; no reboot is needed and they are NOT saved internally. They must be set each time the application starts.

Choose for headless LCD.

Enables/Disables LCD bootup messages.

true if messages are enabled. true if configurations where updated. false if configurations did not change.

Sets LCD Configuration.

LCD configuration. true if configurations where updated. false if configurations did not change.

Rotation type.

Normal.

Rotate clockwise 90 degrees.

Rotate 180 degrees.

Rotate counterclockwise 90 degrees.

Configurations.

Constructor.

Resolution width. Resolution height. true if LCD enable is a fixed state. false if LCD enable is managed by LCD controller. true if active state is high. true if active state is high. true if active state is high. true if your LCD clocks data on the rising edge of the LCD clock. Horizontal Sync pulse width in clock cycles. Horizontal back porch in clock cycles. Horizontal front porch in clock cycles. Vertical Sync pulse width given by number of lines. Vertical back porch given by number of lines. Vertical front porch given by number of lines. Pixel clock rate.

Resolution width.

Resolution height.

true if LCD enable is a fixed state. false if LCD enable is managed by LCD controller.

true if active state is high.

true if your LCD clocks data on the rising edge of the LCD clock.

Horizontal Sync pulse width in clock cycles.

Horizontal back porch in clock cycles.

Horizontal front porch in clock cycles.

Vertical Sync pulse width given by number of lines.

Vertical back porch given by number of lines.

Vertical front porch given by number of lines.

Pixel clock rate.

Power Management Methods.

This class provides several methods to manage the power.
Important Note: When using waking up upon InterruptInputs activity, the desired InterruptPort must be enabled with glitch filter or has OnInterrupt event assigned.

Hibernates the system.

The interrupt(s) desired to wake up the system This method is very useful when power saving is a must. On Hibernate, the processor will turn off completely.
You have to specifiy interrupt(s) to wake up the system later.

This method turns off the Ethernet oscillator when Ethernet networking is not used.

false to disable the oscillator. On EMX module power savings is about 25mA.

Interrupts that can wake up the system after hibernating.

External Interrupt 0 (IO23 on EMX/Embedded Master).

Activity of the CAN bus.

Specified activity on any InterruptPort.

Brown-Out Detect interrupt.

Assertion of an RTC alarm interrupt.

Access to the internal Real Time Clock.

With Real Time Clock, you can keep track of date and time even if the power is off. The time is running using an external backup battery and can last for years.
The RTC time is not related to the NETMF time. You have to set the time manually at startup, see examples.
To verify that a valid time is stored (battery is still running), the user has to make some checks for validations. For example:
- The battery can be monitored.
- RealTimeClock.GetTime() might throw an exception because of incorrect time.
- RealTimeClock.GetTime() will return infeasible dates that the user can check, such as, a date that is less than 2010.
- Store a checksum in the BatteryRAM. The number will only be correct and stay the same if the connected battery is alive.

Please refer to your platform user manual for details on requirements and hardware connections.

Sets RTC.

Date and time.

Gets RTC.

Date and time.

Sets the alarm.

Date and time. This feature lets the user specify an alarm time. This can be used to drive the ALARM pin high or wakeup the processor from hibernation.
The alarm pin is an RTC controlled output. This is a 1.8 V pin. The pin goes low when the alarm time is specified. It goes HIGH when an RTC alarm is generated.
The RTC can supply battery power to the ALARM pin and that can be used by external hardware to restore module power and resume operation.

RTC is valid if it was set before and still running using a charged battery.

Provides access to the address space.

Writes a buffer to the target address space.

Starting address. Buffer. Offset. Count.

Reads the address space into a buffer.

Starting address. Buffer. Offset. Count.

Provide register access.

Creates a new register.

Address.

Writes a value to the register.

Value to be written.

Reads the register's value.

Value of the register.

Sets certain bits in the register using a mask.

Clears certain bits in the register using a mask.

Toggles certain bits in the register using a mask.

Provides signal generation functionality.

This is available on any pin. It has a blocking option for fast accurate timings and a non-blocking option that uses interrupts. This doesn't use real hardware signal generation. Therefore, it may not be 100% accurate. Also, there is a limit in how much time the pin can toggle. Values are platform dependent.

Disposes the pin and marks it as available again.

Creates a new signal generation pin.

Pin. Initial pin value. Maximum number of non-blocking timings. MAX_TIMINGS_BUFFER_SIZE limits the number of non-blocking timings that are set. For example, if you set this value to 10, you can send between 0 and 10 toggle timings in the Set method.

Sets the current pin state.

Pin state.

Sets pin state transition times. This is a non-blocking method.

Initial pin value. Toggle timings. Offset. Count. State transitions loop again when done. First, the pin is set to initialValue. After timingsBuffer_us[bufferOffset + 0] micro seconds, the pin will toggle its state and so on until bufferCount is reached. When done, if bufferRepeating is true, the signal will get regenerated automatically.

Sets pin state transition times. This is a blocking method.

Initial pin value. Toggle timings. Offset. Count. Holds the last pin state for this much time (without toggling the state) before returning to the user. true to disable processor interrupts during this call in order to get accurate timings. First, the pin is set to initialValue. After timingsBuffer_us[bufferOffset + 0] micro seconds, the pin will toggle its state and so on until bufferCount is reached. When done, it will hold the last pin state for lastBitHoldTime_us micro seconds.

Sets pin state transition times. This is a blocking method.

Initial pin value. Toggle timings. Offset. Count. Holds the last pin state for this much time (without toggling the state) before returning to the user. true to disable processor interrupts during this call in order to get accurate timings. If this is set, it will generate a carrier frequency. Note that this is generated using software and may not be fully accurate. First, the pin is set to initialValue. After timingsBuffer_us[bufferOffset + 0] micro seconds, the pin will toggle its state and so on until bufferCount is reached. When done, it will hold the last pin state for lastBitHoldTime_us micro seconds.
This is intended for internal use by GHI.

Signal Generation toggling active state.

This flag is true when the OC is processing the timings buffer to toggle the pin.
For example, assume the used toggle timings are [300, 500, 400] and SignalGenerator.Set(...) is called then:


            SignalGenerator.Set(...);
            while(SignalGenerator.IsActive) // This will be true for 300 + 500 + 400 micro seconds
            ;