Mono Developer Documentation¶

Using Monokiosk¶

If you want to install an existing app from Monokiosk, on to your Mono device - this guide is for you!

In this guide we will show you how to download and install a pre-built application on Mono. Monokiosk is the app store where you can browse and download mono applications, built by makers from around the world.

But until then, let us focus on the few apps we have in the kiosk right now. In this guide we shall install the Tic Tac Toe sample app.

$ monoprog
Usage: monoprog [options]
Bootloadable Programmer for Mono board.

Options:
  -h, --help             Displays this help.
  -V, --version          Displays version information.
  --license              Displays licenses of software components.
  -d, --detect           Detects whether a Mono is connected via USB.
  --mock <type>          Simulates device to be in <type>.
  -p, --program <app>    Transfers <app> to Mono.
  -v, --verbose <level>  Set output verbosity level (default is 1).
  -q, --quiet, --silent  Set output verbosity level to 0.

$ monoprog -d

$ monoprog -p ttt.elf

Resetting Mono¶

Like most Wifi routers and alike, Mono has a reset switch hidden inside a cavity.

If you have gotten stuck and need to force reboot Mono, this guide will help you in resetting Mono. If you have made a coding mistake that might have caused Mono to freeze - then we shall later look at how force Mono into bootloader mode.

$ monoprog -d

// Ordinary Reset
mono::IApplicationContext::SoftwareReset();

// Reset to Application
mono::IApplicationContext::SoftwareResetToApplication();

// Reset to Bootloader
mono::IApplicationContext::SoftwareResetToBootloader();

Using Mono’s Serial port¶

Let us examine how to use Mono’s built in USB Serial port, and how to monitor it from your computer

By default when you plug in Mono’s USB cable to a computer, Mono will appear as a USB CDC device. If you run Windows you have to install a driver, please goto this section to see how.

$ sudo aptitude install minicom

$ brew install minicom

printf("Hello Serial port!!\t\n");

class AppController : mono::IApplication
{
public:
    
    //Add a timer object to our appController
    mono::Timer timer;
    
    // just a counter variable - for fun
    int counter;
    
    // class contructor
    AppController();
    
    // add this method to print to the serial port
    void outputSomething();
    
    
    // ...

AppController::AppController()
{
    // in the contructor we setup the timer to fire periodicly (every half second)
    timer.setInterval(500);
    
    // we tell it which function to call when it fires
    timer.setCallback<AppController>(this, &AppController::outputSomething);
    
    // set the counter to zero
    counter = 0;
    
    //start the timer
    timer.Start();
}

void AppController::outputSomething()
{
    printf("I can count to: %i",counter++);
}

$ minicom -D /dev/cu.usbmodem1246

I can count to: 3
I can count to: 4
I can count to: 5
I can count to: 6

while(1)
{
    // I just wanna stay here for the rest of time ...
}

Sleep Mode¶

In this tutorial we will quickly demonstrate how to put Mono into sleep mode.

Mono has no physical on/off switch, so you cannot cut the power from the system. This means you must always provide a way for Mono to goto to sleep. Sleep mode is the closest we come to being powered off. Mono’s power consumption in sleep mode is around 50 µA (micro amperes), which is really close to no consumption at all.

$ monomake project MyNewProject

class AppController : public mono::IApplication {

    // we add our button view here
    mono::ui::ButtonView sleepBtn;

    // ... rest of appcontroller.h ...

AppController::AppController() :
    
    //first we call the button constructor with a Rect object and a string
    sleepBtn(Rect(10,175,150,40), "Enter Sleep"),

    // here comes the project template code...
    // Call the TextLabel's constructor, with a Rect and a static text
    helloLabel(Rect(0,100,176,20), "Hi, I'm Mono!")
{

mono::IApplicationContext::EnterSleepMode();

public:

    // The default constructor
    AppController();
    
    // we add our sleep method here:
    void gotoSleep();

    // Called automaticlly by Mono on device reset
    void monoWakeFromReset();

void AppController::gotoSleep()
{
    mono::IApplicationContext::EnterSleepMode();
}

// set another text color
helloLabel.setTextColor(display::TurquoiseColor);

// tell the button to call our gotoSleep function
sleepBtn.setClickCallback<AppController>(this, &AppController::gotoSleep);

// tell the button to show itself on the screen
sleepBtn.show();

#ifndef app_controller_h
#define app_controller_h

// Include the Mono Framework
#include <mono.h>

// Import the mono and mono::ui namespaces into the context
// to avoid writing long type names, like mono::ui::TextLabel
using namespace mono;
using namespace mono::ui;

// The App main controller object.
// This template app will show a "hello" text in the screen
class AppController : public mono::IApplication {
    
    // we add our button view here
    mono::ui::ButtonView sleepBtn;
    
    // This is the text label object that will displayed
    TextLabelView helloLabel;
    
public:

    // The default constructor
    AppController();

    // we add our sleep method here:
    void gotoSleep(); 

    // Called automaticlly by Mono on device reset
    void monoWakeFromReset();

    // Called automatically by Mono just before it enters sleep mode
    void monoWillGotoSleep();

    // Called automatically by Mono right after after it wakes from sleep
    void monoWakeFromSleep();
    
};

#endif /* app_controller_h */

#include "app_controller.h"

using namespace mono::geo;

// Contructor
// initializes the label object with position and text content
// You should init data here, since I/O is not setup yet.
AppController::AppController() :
    
    //first we call the button constructor with a Rect object and a string
    sleepBtn(Rect(10,175,150,40), "Enter Sleep"),
    
    // Call the TextLabel's constructor, with a Rect and a static text
    helloLabel(Rect(0,100,176,20), "Hi, I'm Mono!")
{

    // the label is the full width of screen, set it to be center aligned
    helloLabel.setAlignment(TextLabelView::ALIGN_CENTER);
    
    // set another text color
    helloLabel.setTextColor(display::TurquoiseColor);
    
    // tell the button to call our gotoSleep function
    sleepBtn.setClickCallback<AppController>(this, &AppController::gotoSleep);

    // tell the button to show itself on the screen
    sleepBtn.show();
}

void AppController::gotoSleep()
{
    mono::IApplicationContext::EnterSleepMode();
}

void AppController::monoWakeFromReset()
{
    // At this point after reset we can safely expect all peripherals and
    // I/O to be setup & ready.

    // tell the label to show itself on the screen
    helloLabel.show();
}

void AppController::monoWillGotoSleep()
{
    // Do any clean up here, before system goes to sleep and power
    // off peripherals.

}

void AppController::monoWakeFromSleep()
{
    // Due to a software bug in the wake-up routines, we need to reset here!
    // If not, Mono will go into an infinite loop!
    mono::IApplicationContext::SoftwareResetToApplication();
    // We never reach this point in the code, CPU has reset!

    // (Normally) after sleep, the screen memory has been cleared - tell the label to
    // draw itself again
    helloLabel.scheduleRepaint();
}

Using Wifi¶

Let us walk through the steps required to connect Mono to a Wifi access point, and download the content of a web page

$ monomake project wifi_tutorial

    #include <mono.h>
    #include <wireless/module_communication.h>
    #include <wireless/redpine_module.h>

    using namespace mono;
    using namespace mono::ui;

    class AppController : public mono::IApplication {
    
        // This is the text label object that will displayed
        TextLabelView helloLabel;
        
        // The hardware SPI port
        mbed::SPI spi;
        // The spi based communication interface for the module
        redpine::ModuleSPICommunication spiComm;
        
        // The http client object variable
        network::HttpClient client; 
    
    public:
    
        AppController();
        
        // ...
    }
    

    
    // You should init data here, since I/O is not setup yet.
    AppController::AppController() :
        helloLabel(Rect(0,100,176,20), "Hi, I'm Mono!"),
        spi(RP_SPI_MOSI, RP_SPI_MISO, RP_SPI_CLK),
        spiComm(spi, NC, RP_nRESET, RP_INTERRUPT)
    {
    // ...
    

    void AppController::monoWakeFromReset()
    {
        //initialize the wifi module
        redpine::Module::initialize(&spiComm);

    redpine::Module::setupWifiOnly("MY_SSID", "MY_PASSPHRASE");

    class AppController : mono::IApplication
    {
    // ...
    
    public:
    
        void networkReadyHandler();
    
    // ...

    void AppController::networkReadyHandler()
    {
        helloLabel.setText("Network Ready");
    }

    redpine::Module::setNetworkReadyCallback<AppController>(this, &AppController::networkReadyHandler);

    
    // ...
    
    public:
    
        void networkReadyHandler();
        
        void httpHandleData(const network::HttpClient::HttpResponseData &data);
        
    // ...

    void AppController::httpHandleData(const network::HttpClient::HttpResponseData &data)
    {
        helloLabel.setText(data.bodyChunk);
        
        if (data.Finished)
        {
            helloLabel.setText("Downloaded");
        }
    }

    void AppController::networkReadyHandler()
    {
        helloLabel.setText("Network Ready");
        
        //fetch a webpage
        client = mono::network::HttpClient("http://developer.openmono.com/en/latest/");
        
        //now the client will be fetching the web page
        // let setup the data callback
        client.setDataReadyCallback<AppController>(this, &AppController::httpHandleData);
    }

IApplication¶

class mono::IApplication¶

Entry point for all mono applications, abstract interface.

Every mono application must implement this interface. This is the starting point of the your application code, you must call it after the runtime initalization.

You do this from inside the main() function. Your main function should look like this:

int main()
{
     // Construct you IApplication subclass
     MyIApplicationSubclass appCtrl;
     
     // Tell the IApplicationContext of your existance
     IApplicationContext::Instance->setMonoApplication(&appCtrl);

     // Start the run loop... - and never come back! (Gollum!, Gollum!)
     return appCtrl.enterRunLoop();
}

Your mono applications entry point must be your own subclass of IApplication. And you must initalize it inside (not outside) the main() function. This is strictly nessesary, because the IApplicationContext must be ready when the IApplication is executed.

Also you must call the enterRunLoop method from main, to enter the event loop and prevent main() from returning.

Public Functions

IApplication()¶

Construct the global Application class.

Constructor for the global Application Controller. See IApplication for a describtion on when to call this constructor.

virtual void monoWakeFromReset() = 0¶

Called when mono boot after having been power off or after a reset This method is only called once, you should use it to do inital data and object setup.

When this method returns mono will enter in an event loop, so use this method to setup event listeners for your code.

Do not call this method yourself, it is intended only to be called by the mono framework runtime.

virtual void monoWillGotoSleep() = 0¶

The runtime library calls this function when the MCU will go into standby or sleep mode. Use this method to disconnect from networks or last-minute clean ups.

When you return from this method the system will goto sleep, and at wakeup the monoWakeFromSleep() method will be called automatically.

Do not call this method yourself, it is ontended only to be called by the mono framework runtime.

virtual void monoWakeFromSleep() = 0¶

Called when mono comes out of a standby or sleep state, where the MCU instruction execution has been paused.

Use this method to reestablish I/O connections and refresh data objects.

You should not call this method your self, it is intended only to be called by the mono framework runtime.

int enterRunLoop()¶

Start the mono application run loop.

Start the main run loop for your mono application. This method calls the global IApplicationContext run loop.

The last line in the main.cpp file must be a call to this function:

int main()
{
    MyIApplicationSubclass appCtrl;

    // Some app ctrl setup code here perhaps?
    
    return appCtrl.enterRunLoop();
}

Return

The run loop never returns, the return type is only for comformaty.

IApplicationContext¶

class mono::IApplicationContext¶

The Application context class is a singleton class that is automatically instanciated by the framework. You should not need to interact with it directly. It is allocated on the stack, with its member objects.

The application context controls the application event loop at hardware event inputs. It is essential for communicating with Serial-USB and the display.

Depending on the execution context (hardware mono device or simulator), different subclasses of this interface it used. This interface is provided to give your application code a pointer to the concrete implementation of the application context. Regardless of running on a simulator or the actual device.

Subclassed by mono::ApplicationContext

Public Functions

virtual int exec() = 0¶

Start the application run loop.

This method starts the global run/event loop for the mono application. The method never returns, so a call to this function should be the last line in your main() function.

The event loop automatically schedules the sub system, such as the network, inputs and the display.

virtual void setMonoApplication(mono::IApplication *app) = 0¶

Sets a pointer to the mono application object

Public Members

power::IPowerManagement *PowerManager¶

A pointer the power management system.

Pointer to the global power management object, that controls power related events and functions. Use this pointer to go into sleep mode’ or get the current battery voltage level.

AppRunLoop *RunLoop¶

A reference to the main run loop of the application. This pointer must be instanciated be subclasses

display::IDisplayController *DisplayController¶

Pointer to the display interface controller object. The object itself should be initialized differntly depending on the ApplicationContext

ITouchSystem *TouchSystem¶

Pointer to the touch system controller object.

The touch system handles touch input from the display or other input device. It must be initialized by an ApplicationContext implementation.

The touch system is the source of TouchEvent and delegate these to the TouchResponder classes. It is the ITouchSystem holds the current touch calibration. To re-calibrate the touch system, you can use this reference.

See

ITouchSystem

QueueInterrupt *UserButton¶

The User Button queued interrupt handler.

Here you add your application handler function for mono user button. To handle button presses you can set a callback function for the button push.

The callback function is handled in the AppRunLoop, see the QueueInterrupt documentation for more information.

Note that the default initialized callback handler will toggle sleep mode. This means that if you do not set your own handler, the user button will put mono into sleep mode. The default callback is set on the .fall(...) handler.

Example for replacing the user button handler, with a reset handler:

// the button callback function
void MyApp::handlerMethod()
{
    IApplicationContext::SoftwareReset();
}

// on reset install our own button handler callback
void MyApp::monoWakeFromReset()
{
    IApplicationContext::Instance->UserButton->fall<MyApp>(this, &MyApp::handlerMethod);
}

sensor::ITemperature *Temperature¶

A pointer to the Temperatrure sensor, if present in hardware.

This is an automatically initialized pointer to the temperature object, that is automatically created by the framework.

sensor::IAccelerometer *Accelerometer¶

A pointer to the Accelerometer, if present in hardware.

This is an automatically initialized pointer to the accelerometer object, that is automatically created by the framework.

sensor::IBuzzer *Buzzer¶

A pointer to the buzzer, if present in hardware.

This is an automatically initialized pointer to the buzzer object, that is automatically created by the framework.

Public Static Functions

static void EnterSleepMode()¶

The mono application controller should call this to give the Application Context a reference to itself.

This will ensure the Application Controllers methods gets called. Call this method to make mono goto sleep.

In sleep mode the CPU does not excute instruction and powers down into a low power state. The power system will turn off dynamically powered peripherals.

NOTE: Before you call this method make sure that you configured a way to go out of sleep.

static void ResetOnUserButton()¶

Enable Reset On User Button mode, where user button resets mono.

If your application encounters unmet dependencies (missing SD Card) or gracefully handles any runtime errors, you can call this method. When called, the run loop will reset mono if the user button (USER_SW) is activated.

This method allows you to reset mono using the user button, instead of the reset button.

static void SleepForMs(uint32_t ms)¶

Enter MCU sleep mode for a short time only. Sets a wake-up timer us the preferred interval, and calls the EnterSleepMode method.

Parameters

• ms -

  The number of milli-second to sleep

static void SoftwareReset()¶

Trigger a software reset of Mono’s MCU.

Calls the MCU’s reset exception, which will reset the system. When reset the bootloader will run again, before entering the application.

static void SoftwareResetToApplication()¶

Trigger a software reset of MOno’s MCU, that does not load the bootloader.

Use this to do a fast reset of the MCU.

static void SoftwareResetToBootloader()¶

Trigger a software reset, and stay in bootloader.

Calls the MCU reset exception, which resets the system. This method sets bootloader parameters to stay in bootloader mode.

CAUTION: To get out of bootloader mode you must do a hard reset (by the reset button) or program mono using monoprog.

Public Static Attributes

IApplicationContext *Instance¶

Get a pointer to the global application context

Protected Functions

virtual void enterSleepMode() = 0¶

Subclasses should overirde this method to make the sysetm goto sleep

virtual void sleepForMs(uint32_t ms) = 0¶

Subclasses should override this to enable sleep mode for a specefic interval only.

virtual void resetOnUserButton() = 0¶

Subclasses must implement this to enable the “Reset On User Button” behaviour. See ResetOnUserButton

virtual void _softwareReset() = 0¶

Subclasses must implement this method to enable software resets. See SoftwareReset

virtual void _softwareResetToApplication() = 0¶

Subclasses must implement this to enable software reset to application See SoftwareResetToApplication

virtual void _softwareResetToBootloader() = 0¶

Subclasses must implement this method to allow reset to bootloader See SoftwareResetToBootloader

IApplicationContext(power::IPowerManagement *pwr, AppRunLoop *runLp, display::IDisplayController *dispCtrl, ITouchSystem *tchSys, QueueInterrupt *userBtn, sensor::ITemperature *temp = 0, sensor::IAccelerometer *accel = 0, sensor::IBuzzer *buzzer = 0)¶

Protected constructor that must be called by the sub class. It sets up needed pointers for the required subsystems. This ensure the pointers are available when class members’ constructors are executed.

If this contructor did not setup the pointers, the PowerManagement constructor would see the Instance global equal null.

AppRunLoop¶

class mono::AppRunLoop¶

This is the event run-loop for all mono applications. This class is instantiated and used inside the IApplicationContext interface. You should not interact with this class directly.

The run loop handles non-critical periodicly tasks. Classes can install tasks in the run-loop. Such classes are usually repetitive timers or lazy interrupt handlers.

Some standard system tasks are handled staticly inside the loop, like the USB serial reads.

Public Functions

void exec()¶

Start executing the run loop.

void CheckUsbDtr()¶

Do a single check of the DTR on the virtual UART.

bool addDynamicTask(IRunLoopTask *task)¶

Add a task to the dynamic task queue. This task is repeated over and over, until it reports that its should not be scheduled.

The task is added to a linked list, runtime is n.

Return

Always true at this point

bool removeDynamicTask(IRunLoopTask *task)¶

Remove a task from the dynamic task queue. This will search the queue for he pointer provided, and remove it.

Return

true if the object was found and removed, false otherwise.

Parameters

• task -

  A pointer to the object, that should be removed

void setResetOnUserButton(bool roub)¶

Sets the Reset on User Button mode.

If true the run loop will check the user button, and if pressed it will trigger a software reset.

Parameters

• roub -

  true will reset on user button, false is normal functionality.

void quit()¶

Terminate the run loop. Application events and more will stop working

You should use this, if you use your own embedded run loops.

Public Members

bool resetOnDTR¶

As default behaviour the run loop will force a reset on high-to-low transition on the serial ports DTR (Data Terminal Ready) line.

This property controls this feature, setting it to true will enable software reset via the serial connection. This means the monoprog programmer can reset the device and connect to the bootloader.

Setting this to false means monoprog cannot automatically reset into the bootloader, you must press the reset button yourself.

uint32_t TouchSystemTime¶

The CPU time used on proccessing touch input. This includes:

• ADC sampling (approx 16 samples)
• Touch value evaluation, and possible convertion into events
• Traversing the responder chain
• Handling TouchBegin, TouchEnd & TouchMove, and any function they call

This time includes the execution of your code if you have any button handlers or touch based event callbacks.

uint32_t DynamicTaskQueueTime¶

The CPU time used on processing the dynamic task queue The time spend here include all queued tasks and callbacks. these could be:

• Timer callback
• Any QueueInterrupt you might have in use
• All display painting routines (repainting of views subclasses)
• Any custom active IRunLoopTask you might use

Nearly all callbacks are executed with origin inside the dynamic task queue. Expect that the majority of your code are executed here.

Protected Functions

void processDynamicTaskQueue()¶

Execute all tasks in the dynamic task queue

void removeTaskInQueue(IRunLoopTask *task)¶

Internal method to sow together neightbourghs in the linked list

void process()¶

Process a single iteratio of the run loop

void checkUsbUartState()¶

read the UART DTR state if possible

Protected Attributes

bool runLoopActive¶

As long as this i true the stadard run loop will run

If set to false, the run loop will exit, and mono might will enter a low power state. TODO: power safe modes and run loops?

bool lastDtrValue¶

The last seen serial DTR value. Reset can only happen in transitions.

bool resetOnUserButton¶

Set to true if you want the run loop to call software reset when pressing the user button. Initial value is false

IRunLoopTask *taskQueueHead¶

A pointer to the head task of the dynamic task queue. If no task are in the queue, this is NULL

IRunLoopTask¶

class mono::IRunLoopTask¶

THis interface defines tasks or functions that can be inserted into the ApplicationRunLoop.

The interface defines a method that implements the actual logic. Also, the interface defines the pointers previousTask and nextTask. These define the previous and next task to be run, in the run loops task queue.

To avoid dynamic memory allocation of linked lists and queues in the run loop, the run loop handler functions, are themselves items in a linked list.

All classes that that want to use the run loop, must inherit this interface.

NOTE that tasks in the run loop do not have any contraints on how often or how rare they are executed. If you need a function called at fixes intervals, use a Ticker or timer.

Subclassed by mono::display::ILI9225G, mono::power::MonoPowerManagement, mono::QueueInterrupt, mono::Timer, mono::ui::Animator

Protected Functions

virtual void taskHandler() = 0¶

This is the method that gets called by the run loop.

NOTE that this is not an interrupt function, you can do stuff that take some time.

Protected Attributes

IRunLoopTask *previousTask¶

A pointer to the previous task in the run loop The the task is the first in queue, this is NULL

IRunLoopTask *nextTask¶

A pointer to the next task to be run, after this one. If this task is the last in queue, this is NULL

bool singleShot¶

Tasks are expected to be repetative. They are scheduled over and over again. Set this property to true and the task will not scheduled again, when handled.

String¶

class mono::String¶

High level string class, that is allocated on the HEAP or rodata

The mono framework has it own string class, that either reside on the HEAP or inside the read-only data segment (.rodata).

We use this string class to pass string data to async routines like the View ‘s scheduleRepaint method. Because views might be repainted at any point in time, we cannot have view data reside on the stack. This string class hold its data on the HEAP, but behaves as it would reside on the stack.

THis string class takes care of all alloc and dealloc of memory. It is a referenced based string class. You should not pass pointers of C++ references to this class, but instead normal assignment or pass the full class to functions. The efficient copy / assignment operator methods on the class ensure only data references are passed, behind the scenes.

For example:

String str = String::Format("Hello World, number: %i", 1);
String str2 = str;
String str3 = str2;

In the code only 1 copy of the string data is present in memory. And only references are passed to the objects str2 and str3. Only as the last object is deallocated is the data disposed from the HEAP.

These features makes the class very lightweight and safe to pass around functions and objects.

Timer¶

class mono::Timer¶

A queued Timer class, recurring or single shot.

A timer can call a function at regular intervals or after a defined delay. You can use the timer to do periodic tasks, like house-keeping functions or display updates.

Queued callback

The timer uses the Application Run Loop to schedule the callback handler function. This means your callback are not executed inside a hardware interrupt context. This is very convenient since your can do any kind of heavy lifting in your callback handler, and your code is not pre-empted.

Presicion

You should note that the timer are not guaranteed to be precisely accurate, it might fire later than your defined interval (or delay). The timer will not fire before your defined interval though. If you use any blocking wait statements in your code, you might contribute to loss in precision for timers.

If you want precise hardware timer interrupts consider the mbed Ticker class, but you should be aware of the hazards when using hardware interrupts.

Example

Create a reocurring timer that fires each second:

Timer timr(1000);
timr.setCallback<MyClass>(this, &MyClass::callback);
timr.Start();

The member function callback will now be called every second. If you want to use a single shot callback with a delay, Timer has a convenience static function:

Timer delay = Timer::callOnce<MyClass>(100, this, &MyClass::callback);

Now delay is a running timer that calls callback only one time. Note that the timer object (delay) should not be deallocated. Deallocating the object will cause the timer to shut down.

Time slices

Say you set an interval of 1000 ms, and your callback takes 300 ms to execute. Then timer will delay for 700 ms and not 1000 ms. It is up to you to ensure your callback do not take longer to execute, than the timer interval.

Inherits from mono::IRunLoopTask

Public Functions

Timer()¶

Contruct an empty (zero-timeout) re-occurring timer.

After calling this contructor, you must set the time out and callback function. Then start the timer.

Timer(uint32_t intervalOrTimeoutMs, bool snglShot = false)¶

Create a new timer with with an interval or timeout time.

All newly created timers are stopped as default. You must also attach callback handler to the timer, before it can start.

Parameters

• intervalOrTimeoutMs -

  The timers time interval before it fires, in milliseconds

• snglShot -

  Set this to true if the timer should only fire once. Default false

void Start()¶

Start the timer and put into running state.

Note: You must set a callback handler, before starting the timer.

void Stop()¶

Stop the timer, any pending callback will not be executed.

bool SingleShot()¶

See if the timer is single shot.

bool Running()¶

See if the timer is currently running

void setInterval(uint32_t newIntervalMs)¶

Set a new timer interval.

Parameters

• newIntervalMs -

  The timer interval in milliseconds

template <typename Owner>

void mono::Timer::setCallback(Owner * obj, void(Owner::*)(void) memPtr)

Sets a C++ callback member function to the timer.

Parameters

• obj -

  A pointer to the callback member function context (the this pointer)

• memPtr -

  A pointer to the member function, that is the callback

void setCallback(void (*cFunction)(void))¶

Sets a callback handler C function to the timer.

Parameters

• cFunction -

  A pointer to the C function, that is the callback

Public Static Functions

template <typename Owner>

static Timer* mono::Timer::callOnce(uint32_t delayMs, Owner * obj, void(Owner::*)(void) memPtr)

Create a single shot timer with a delay and callback function.

The timer object is created on the HEAP, which allows it to exists across stack frame contexts. You can safely create a callOnce(...) timer, and return from a function. Even if you do not have a reference to the timer object, it will still run and fire. The timer deallocates itself after it has fired. It cannot be reused.

Return

A pointer to the single shot timer

Parameters

• delayMs -

  Delay time before the timer fires, in milliseconds.

• obj -

  A pointer to the callbacks function member context (the this pointer)

• memPtr -

  A pointer to the callback member function

static Timer *callOnce(uint32_t delayMs, void (*memPtr)(void))¶

Create a single shot timer with a delay and callback function.

The timer object is created on the HEAP, which allows it to exists across stack frame contexts. You can safely create a callOnce(...) timer, and return from a function. Even if you do not have a reference to the timer object, it will still run and fire. The timer deallocates itself after it has fired. It cannot be reused.

Return

A pointer to the single shot timer

Parameters

• delayMs -

  Delay time before the timer fires, in milliseconds.

• memPtr -

  A pointer to the callback C function

Protected Functions

virtual void taskHandler()¶

This is the method that gets called by the run loop.

NOTE that this is not an interrupt function, you can do stuff that take some time.

DateTime¶

class mono::DateTime¶

A DateTime representation.

Public Functions

DateTime()¶

Construct an empty / invalid DateTime object.

DateTime(uint16_t years, uint8_t months, uint8_t days, uint8_t hours = 0, uint8_t minutes = 0, uint8_t seconds = 0)¶

Construct a DateTime object with a given date and time.

Parameters

• years -

  The Year component of the date, for example 2016

• months -

  The month component of the date from 1 to 12, May is 5

• days -

  The day component of the date, 1-indexed, from 1 to 31

• hours -

  Optional: The hour component of the timestamp, range is 0 to 23

• minutes -

  The minute component of the timestamp, range is 0 to 59

• seconds -

  The seconds component of the timestamp, range is 0 to 59

String ToString() const¶

Return the DateTime object as a huamn readable string.

Return

A mono string on the format: yyyy-MM-dd hh:mm:ss

ISettings¶

QueueInterrupt¶

class mono::QueueInterrupt¶

An queued input pin interrupt function callback handler This class represents an input pin on mono, and provides up to 3 different callback handler functions. You can installed callback function for rising, falling or both edges.

Queued interrupts

In Mono framework a queued interrupt is handled inside the normal execution context, and not the hardware interrupt routine. In embedded programming it is good practice not to do any real work, inside the hardware interrupt routine. Instead the best practice method is to set a signal flag, and handled the event in a run loop.

QueueInterrupt does this for you. The rise, fall and change callback are all executed by the default mono run loop (AppRunLoop) You can safely do heavy calculations or use slow I/O in the callback routines you assign to QueueInterrupt!

Latency

The run loop might handle the interrupt callback some time after it occur, if it is busy doing other stuff. THerefore you cannot expect to have your callback executed the instant the interrupt fires. (If you need that use DirectInterrupt) QueueInterrupt holds the latest interrupt trigger timestamp, to help you determine the latency between the actual interrupt and you callback. Also, many interrupt triggering signal edges might occur, before the run loop executes you handler. The timestamp only shows the latest one.

Inherits from InterruptIn, mono::IRunLoopTask

Public Functions

QueueInterrupt(PinName inputPinName = NC, PinMode mode = PullNone)¶

Assign a queued inetrrupt handler to a physical pin

Parameters

• inputPinName -

  The actual pin to listen on (must be PORT0 - PORT15)

• mode -

  OPTIONAL: The pin mode, default is Hi-Impedance input.

void DeactivateUntilHandled(bool deactive = true)¶

Set this property to true, to turn off incoming interrupts while waiting for the run loop to finish process a pending interrupt.

If you want to do heavy calculations or loading in your interrupt function, you might want to not queue up new interrupts while you process a previous one.

Parameters

• OPTIONAL -

  Set this to false, to not disable interrupts while processing. Default is true

bool IsInterruptsWhilePendingActive() const¶

Get the state of the DeactivateUntilHandled property. If true the hardware interrupt is deactivated until the handler has run. If false (the default when constructing the object), all interrupt are intercepted, and will be handled. This means the handler can be executed two times in row.

Return

true if incomming interrupt are displaed, until previous is handled.

void setDebouncing(bool active)¶

Enable/Disable interrupt de-bounce.

Switches state change might cause multiple interrupts to fire, or electrostatic discharges might cause nano seconds changes to I/O lines. The debounce ensures the interrupt will only be triggered, on sane button presses.

void setDebounceTimeout(int timeUs)¶

Change the timeout for the debounce mechanism.

Parameters

• timeUs -

  The time from interrupt to the signal is considered stable, in micro-seconds

void rise(void (*fptr)(void))¶

Attach a function to call when a rising edge occurs on the input

Parameters

• fptr -

  A pointer to a void function, or 0 to set as none

template <typename T>

void mono::QueueInterrupt::rise(T * tptr, void(T::*)(void) mptr)

Attach a member function to call when a rising edge occurs on the input

Parameters

• tptr -

  pointer to the object to call the member function on

• mptr -

  pointer to the member function to be called

void fall(void (*fptr)(void))¶

Attach a function to call when a falling edge occurs on the input

Parameters

• fptr -

  A pointer to a void function, or 0 to set as none

template <typename T>

void mono::QueueInterrupt::fall(T * tptr, void(T::*)(void) mptr)

Attach a member function to call when a falling edge occurs on the input

Parameters

• tptr -

  pointer to the object to call the member function on

• mptr -

  pointer to the member function to be called

uint32_t FallTimeStamp()¶

On fall interrupts, this is the µSec. ticker timestamp for the falling edge inetrrupt. You can use this to calculate the time passed from the interrupt occured, to the time you process it in the application run loop.

Return

The ticker time of the falling edge in micro seconds

uint32_t RiseTimeStamp()¶

On rise interrupts, this is the µSec. ticker timestamp for the rising edge inetrrupt. You can use this to calculate the time passed from the interrupt occured, to the time you process it in the application run loop.

Return

The ticker time of the rising edge in micro seconds

bool Snapshot()¶

The pin value at the moment the H/W interrupt triggered The callback might be executed some time after the actual inetrrupt occured. THis method return the pin state at the moment of the interrupt.

Return

The pin state, at the time of the interrupt

template <typename T>

void mono::QueueInterrupt::change(T * tptr, void(T::*)(void) mptr)

Attach a function to call when a rising or falling edge occurs on the input

Parameters

• fptr -

  A pointer to a void function, or 0 to set as noneAttach a member function to call when a rising or falling edge occurs on the input

• tptr -

  pointer to the object to call the member function on

• mptr -

  pointer to the member function to be called

Protected Functions

virtual void taskHandler()¶

This is the method that gets called by the run loop.

NOTE that this is not an interrupt function, you can do stuff that take some time.

TouchResponder¶

class mono::TouchResponder¶

The TouchReponder handles incoming touch events.

The TouchResponder is an interface that classes and inherit from to receive touch input events. This class also defined global static method used by Mono’s hardware dependend touch system. These static methods receives the touch events and delegates them to all objects in the responder chain.

You can make any object a receiver of touch events if you inherit from this interface. You need to override 3 methods:

• RespondTouchBegin
• RespondTouchMove
• RespondTouchEnd

These methods are called on any subclass when touch input events are received. Note that your subclass will receive all incoming events not handled by other responders.

If you want to make touch enabled graphical elements, you should use the interface ResponderView. This class is the parent class for all touch enabled views.

See

ResponderView

ITouchSystem

Inherits from mono::IQueueItem

Subclassed by mono::ui::ResponderView

Public Functions

TouchResponder()¶

Create a new responder object that receives touch input.

Upon creation, this object is automatically inserted into the responder chain, to receive touch input events.

void Activate()¶

Add this responder to the responder chain

void Deactivate()¶

Remove this responder from the responder chain

TouchEvent¶

class mono::TouchEvent¶

Public Members

TouchEvent *TouchBeginEvent¶

If