PiBox » Iron Man

h1. Ironman Users Guide

table{border-width:0;width:100%}.

|={font-size:140%;margin-bottom:15px;color:blue}. Last updated: 2025-04-08 |

{{>toc}}

In this document the term _host system_ refers to a Linux desktop or laptop that will be used to download and install software onto an SD card.

h2. Overview

_*Ironman*_ is a home automation project based on the PiBox build system.  It supports a Nest-like monitor for controlling Arduino based sensors, cameras and remote voice control.

table{align=center}.

|!{width:640px}http://redmine.graphics-muse.org/attachments/download/114!|

|={font-size:120%;margin-bottom:15px;background-color:#dff}. *Design Intent of the Ironman Project* |

|=. Mark I release is in progress.  Mark II and Mark III are future development plans. |

_*Ironman*_ consists of the following components.

| *Monitor* | The Nest-like control hub based on a Raspberry Pi 3 and the official 7" touchscreen display |

| *Sensors* | Arduino based devices, such as door alarms and cameras, running code based on a sensor and camera templates for pairing and secure communication with the Monitor |

| *Jarvis*  | A Java application that supports voice control of Monitor managed devices |

| *Controllers* | Network enabled control of Monitor managed devices and PiBox Systems such as PiStore and PiSentry |

h3. Security

_*Ironman*_ supports AES encrypted communication with IoT sensors and Jarvis interfaces.

h3. What it is

_*Ironman*_ is a do-it-yourself system, where you buy the parts and assemble them as described, modifying the provided code to suit your needs and handling flashing and maintenence.  _*Ironman*_ is designed to allow you to build your own home automation system where you specify the devices you want to control and how you want to control them.  

h3. What it is not

_*Ironman*_ is not a product.  It is not intended for anyone other than Makers (aka DIY'ers) who like to tinker and see not just how to assemble things but why they actually work.

While the Users Guide is intended to bring up a currently working version of _*Ironman*_ with limited sensor and camera support, if you aren't prepared to deal with writing code or flashing devices and dealing with electrical circuits then _*Ironman*_ is not for you.

h2. The Ironman Monitor

The _*Ironman*_ Monitor runs on a Raspberry Pi 3 and provides a central hub for management of home automation devices.  It uses a 7" touch screen display and a mechanical switch to manage pairing with IoT devices and Jarvis interfaces.

%{background:yellow;letter-spacing:0.25em}The mechanical switch will be removed with upcoming versions of the sensors app and imrest server that run on the Ironman monitor.%

h3. Installation Prerequisites

* A "Raspberry Pi 3":https://rpilocator.com/?country=US&cat=PI3

* The official "Raspberry Pi 7inch touchscreen display":https://www.sparkfun.com/products/13733

* The Pi 3 requires a "5V / 2A power supply":https://www.adafruit.com/product/1994.  For best results, use a power supply rated to at least 5.25V to avoid under voltage conditions.  For ease of use the power supply cable should include an "on/off switch":https://www.adafruit.com/product/2379.

* A keyboard is not required for initial installation.  A "wireless keyboard":https://www.adafruit.com/product/922 should work as will a wired keyboard.  The keyboard will not be needed for normal operation but can be helpful in debugging.

* The Pi 3 requires a microSD card that is at least 4GB.  A mechanism for using the SD card on your host system is needed, such as an SD card USB adapter or an SD port on your laptop.

* A mechanical switch, such as a "SPDT":https://www.electronicshub.org/switches/#Single_Pole_Double_Throw_Switch_SPDT, should be connected to the Pi GPIOs to allow for pairing the Monitor with IoT Sensors and Jarvis interfaces.  The ASCII diagram below describes the setup. The LED is off in normal mode, lit in Config Mode, and off in Pair Mode until something tries to pair with the Pi which then turns on the LED for 3 seconds. Config and Pair mode operations are discussed in later sections.  A Fritzing Diagram (attachment:IronmanMonitorSwitch.fzz) is available for this hardware component.

!>{width:300px}IronmanMonitorSwitchBreadboard.png(Ironman Monitor Switch)!

<pre>

                      ___

   Config/Pair Mode  |---|  Normal Mode

                   --------- 

                  |         |

                   --------- 

connector pins -->  |  |  |  

                    |  |   ------ Not connected

                    |  |

                    |  ----330 Ohm R-----

                    |  |                |

                    |  |  +-----LED------

                    |  |  |

          RPi pin   7  9  13     

         RPi GPIO   4  G  27

</pre>

* You will need to have sudo access for your Linux user id.

h3. Generating the SD Card for the Pi

* Clone and build PiBox Development System

** git clone https://gitlab.com/pibox/pibox.git

** cd pibox

** _make pkg_

** The build artifacts will be in the "../pkg" directory

** export STAGING="$(pwd)/../bld/buildroot-<date>/output/staging"

** export XID="$(pwd)/../bld/crosstool-ng-1.25.0.bld/install

* Clone the metabuild repository and build the Ironman package set.

** git clone https://gitlab.com/pibox/metabuild.git

** cd metabuild

** _./build.sh -m ironman_

*** You need to set STAGING and XID variables before running this command

** The packages will be in ../pkg.

* In a terminal window run: _dmesg -w_

* Insert the microSD card and note the device name displayed for the newly added card as displayed in the _dmesg -w_ terminal window.  It should be something like /dev/sdb or /dev/sde.

* Kill the _dmesg -w_ command with Ctrl-C.

To install the PiBox Development System on the SD card.

* Format the SD card

** cd <pibox clone dir>/../pkg

** _./mksd.sh -d <device name>_

** where <device name> is the name you noted from the output of _dmesg -w_.

* Mount the boot partition from the sd card: 

** _sudo mkdir -p /mnt/boot_

** _sudo mount <device name>1 /mnt/boot_

** where <device name> is the name you noted from the output of _dmesg -w_.

* Install the Development Platform to the SD card

** _./mkinstall.sh -b /mnt/boot -d <device name>2 -o_ 

** where <device name> is the name you noted from the output of _dmesg -w_.

%{background:yellow}You will need sudo access to run mksd and mkinstall.%

To install the Ironman package to the SD card.

* Mount the data partition from the sd card: 

** _sudo mkdir -p /mnt/data_

** _sudo mount <device name>1 /mnt/data_

* Copy the _*Ironman*_ packages to the SD card

** cd <metaboot clone dir>/../pkg

** _sudo cp *.opk /mnt/data/opkg/incoming_

** _sudo touch /mnt/data/opkg/incoming/.install_

Make sure all writes to the SD card have completed

* _sync;sync;sync_

Unmount the SD card partitions

* _sudo umount /mnt/boot_

* _sudo umount /mnt/data_

Remove the SD card from the host system and insert it into the Raspberry Pi 3.

h3. First time boot

Power on the Monitor and wait for it to complete installation.  During this time the display may be upside down.  Once initial installation is complete the display will be right side up.

%{background:yellow}Right side up for the monitor is when the power supply is connected at the top.%

The Monitor is now fully installed and ready for use.  At this point the keyboard can be removed though you may want to leave it connected for debugging purposes.

h3. First time configuration

%{background:yellow}This section will be replaced when PiNet is ported to Ironman.%

!>{width:300px}ironman-config-ui.png(Ironman Config UI)!

Turn the power off and set the Mode switch to Config/Pair, then power the Monitor back on.  The LED should light indicating the Monitor is ready to be configured.

Use a smartphone or laptop with wifi to connect to the "ironman" SSID.  The default password is _ironman1_.  Then use a browser to connect to the Ironman web UI at 

  http://192.168.36.1:1337

The display should be as shown in the adjacent photo.  There are two network domains to configure, as described in the following table.

|_. Domain |_. Description |

| Internet Connection | This is how the Monitor will connect to your home network. |

| Sensors Network | This is how the Monitor will communicate with your IoT devices. |

After both networks are configured, power off the Monitor and set the Mode switch to Normal, then power the Monitor on.  The Monitor is now ready to use with IoT sensors, Jarvis and controllers.

h3. Network configuration

The Monitor's hardware supports WiFi B/G/N networks.  However, in order to use the Monitor as both a WiFi client on the local

network and as an Access Point for IoT devices, only G networks are supported by the Ironman software.

h4. Internet Connection

The Internet Connection domain configures the Monitor to connect to your local network.  

|_. Field |_. Description |

|Location |Unique name for this monitor, such as Bedroom or Office.  This name is used to identify monitors by name via commands from Jarvis or other remote controllers|

|SSID |Network name configured on your router for your local WiFi network. |

|Security | Type of security used on your router. Only WPA2 Personal and WPA2 Enterprise are currently supported. |

|Password | Your router's password, specifically for the SSID entered previously. |

The *Show Password* button will display the password typed in the Password field.  By default this button is not enabled, causing the Password field to be hidden using asterisks for each character.

h4. Sensor Network

The Sensor Network domain is used to configure the Monitor's private network used with IoT devices.  Data on this network is not routed to the Internet Connection and data from the Internet Connection domain are not routed to the Sensor Network.

|_. Field |_. Description |

|SSID |Network name for this private WiFi network. This name will be hidden on Wifi scans.|

|Channel | Channel to use.  Select a channel that has low use in your neighborhood.  Only a subset of channels on G networks are available.  This will be addressed in future releases. |

|Password | Password IoT devices should use to gain access to the specified SSID. |

|Static IP | An IP address to give the Monitor as it acts as an Access Point. This should be a Class C subnet for the network, which limits the number of IoT devices that can be managed by a single Monitor to 254. |

The *Show Password* button will display the password typed in the Password field.  By default this button is not enabled, causing the Password field to be hidden using asterisks for each character.

h2. IoT Sensor

h3. Sensor Types

There is currently two sensor types:  pwrctrl (power control for outlets) and pwremote (remote for 433MHz managed outlets).  

The sensor template GIT repository, which is the imlightsw (historical name) repo, is intended to be used to design additional sensor types, such as door and window alarms, window shade controllers, environment sensors and so forth.  These all are based on the pwrctrl source for registration and communicating with the Ironman monitor.

h4. Light Switch

!>{width:300px}imlightsw.png(Ironman Light Switch)!

%{color:blue}The following describes use of the pwrctrl sensor.  The same process works with the pwremote for connecting to a WiFi network and registering with an Ironman monitor. Note that if the code is compiled with the SERIAL=1 environment variable then the Blue LED is not used and only the FTDI serial output is used.%

This prototype pwrctrl sensor (attachment:imlightsw-with-relay-2.fzz) uses a relay to power an LED on and off, simulating enabling and disabling an outlet via a relay.  The breadboard power supply can be replaced with an "HLK-PM01":http://www.hlktech.net/product_detail.php?ProId=54 and an "LM3671 5V to 3.3v buck converter":https://www.adafruit.com/product/2745 to power the board from mains (110v).

The FTDI connection is used to connect and "FTDI Basic board":https://www.sparkfun.com/products/9873 so that a the output from the ESP-01 can be viewed in a terminal program.

The ESP-01 has a Blue LED that is used to provide visual information using blink patterns.

h5. Config Button

This button has multiple uses, depending on where it is used.  

_AP Config Mode_

AP Config Mode means the device is running as an WiFi Access Point, allowing you to connect to it via a web browser to configure the device for use on a Monitor's Sensor network.

* AP Config mode is disabled by default, that is, when the Config Button is in the off position.

* If Config Button is ON at boot, pwrctrl enters AP config mode.  In this mode the LED will blink twice and then stop.  Once the device is connected to a Monitor's Sensor network it will blink 4 times.

* After configuration is complete, button must be set OFF and device power cycled.  At this point the pwrctrl device will be connected to the configured WiFi network.

_Pair Mode_

Pair Mode is used to pair the pwrctrl device with an Ironman Monitor.  Pairing involves the exchange of secret keys that will be used to encrypt messages between the Monitor and the pwrctrl device.

* The Config Button is OFF at boot.

* After boot, the Config Button is turned on and pwrctrl enters PAIR mode.  In this mode the blue LED stays on.

* After the device has paired with a Monitor the blue LED blinks.

* The Config Button must be turned off for normal operation.

h5. Blue LED Blink Patterns

A _blink_ implies the LED turns on and then off.

|_. LED State |_. Blink Speed |_. Blink Count |_. Device Mode |

|Blink        | 1/sec         | 2             | Entered AP Config Mode |

|Blink        | 1/sec         | 4             | Device is connected to monitor |

|Blink        | 1/.125 sec    | 5             | Device failed to connect to monitor |

|Solid On     | N/A           | N/A           | Entered Pair Mode |

|Blink        | 2/.150 sec then 1/.200 sec | continuous             | Waiting to Pair with Monitor|

|Blink        | 1/.100 sec    | 3             | Not currently paired with Monitor|

h5. Reset Button

The Reset Button is used to return the pwrctrl to it's initial state, prior to configuration and pairing.  If the device is reset it will need to be configured to use the network again as well as paired with an Ironman Monitor before it can be managed.

* The Reset Button is ON at boot.

* The device removes all configuration from itself.

* The Reset Button must be turned off, then the device can be rebooted and reconfigured.

table{border-collapse;width:100%}.

|={font-size:120%;margin-bottom:15px;background-color:#fdd}.  The Reset Button is not connected in code currently due to the limit on GPIO pins in the ESP-01.  To fully reset the ESP-01 you must compile the code with RESET=1, flash and run the code, then recompile with RESET=0 (or not specified on the command line) and flash again. |

h3. Setting up to use the code

h4. Prerequisites

* ESP-01 connected to your serial port using an FTDI board

** Try the one from "SparkFun":https://www.sparkfun.com/products/9873

* You have proper power to the ESP-01

** You need 3.3V for the ESP-01.

** You need 5V for the power relay.

** Try this board from "Amazon":https://smile.amazon.com/gp/product/B010UJFVTU/ref=oh_aui_detailpage_o03_s00?ie=UTF8&psc=1. It can supply both 3.3V and 5V power on a half size breadboard like this one from "Adafruit":https://www.adafruit.com/product/64

* Other parts you might want

** ESP-01 "breadboard adapter":https://www.addicore.com/ProductDetails.asp?ProductCode=AD-BB-ADTR

** "Logic Level Converter":https://www.sparkfun.com/products/12009

** "5V 1-Channel Relay":https://www.ebay.com/itm/5V-10A-one-1-Channel-Relay-Module-With-optocoupler-For-PIC-AVR-DSP-ARM-Arduino/310636242802?ssPageName=STRK%3AMEBIDX%3AIT&_trksid=p2057872.m2749.l2649 board

h4. Arduino Setup

This build is a wrapper around the Arduino-CLI.  It makes use of GNU Make targets with rules that call Arduino-CLI features to build the code.  It requires the "Arduino-CLI":https://docs.arduino.cc/arduino-cli/installation/ to have been previously installed.

h4. Required Libraries

This section describes required libraries.  However, it is no longer necessary to install these as the build system takes care of this automatically.

|_. Required Arduino libraries |_. URL |

|AES|            https://github.com/spaniakos/AES/|

|Timer|          https://github.com/JChristensen/Timer.git|

|WiFiManager|    https://github.com/tzapu/WiFiManager.git

                 tag: 0.12

                 commit: 04d47882a7d662b46bb1b1dbecfe786e5bc9efa4 |

|aJson|          https://github.com/interactive-matter/aJson.git

                 Requires patch in patch/ directory. |

|aREST|          https://github.com/marcoschwartz/aREST.git|

|arduino-base64| https://github.com/adamvr/arduino-base64

                 Requires patch in patch/ directory. |

Notes on libraries

* AES library:  Remove the examples or the build will probably fail.

h4. The pwrctrl Code

The code is required to do flash updates to the ESP-01.  Before starting, be sure to install "cdtools":https://gitlab.com/cdtools/cdtools.

* Clone the software: _git clone https://gitlab.com/xarduino/lightsw.git_

* Copy _lightsw/docs/arduino.sh_ to your cdtools directory (_~/bin/env_) and edit as appropriate.

* Setup your environment for the build:

**  _. cdtools_

**  _ard lightsw_

**  _cd?_ (to see what you can do with cdtools in this repository)

* Change to this repos directory: _cdx_

h3. Flashing the firmware

!>{width:300px}imlightsw-flasher.png(Ironman pwrctrl Flasher)!

This prototype pwrctrl (attachment:imlightsw-flasher.fzz) is used to program the ESP-01.  A separate flasher circuit like this is required due to the limited number of GPIO pins on the ESP-01.

The "FTDI Basic board":https://www.sparkfun.com/products/9873 is required to connect the ESP-01 to a computer over a USB port.  On Linux, the port will show up as /dev/ttyUSB0 or similar.  

The code must be built before it can be flashed to the ESP-01.

* _make pwrctrl_

** Binary is in ../bld/pwrctrl/*.bin

* _make RESET=1 pwrctrl_

** This causes stored data in the ESP-01 to be erased on power up.  After that, you need to reflash without this flag.

* _make SERIAL=1 pwrctrl_

** This causes the code to use the TX line for serial output for debugging purposes.  If this is not set then the blue LED is used instead and there is not serial console output.

Finally, to flash the updated image to the ESP-01 use the _upload_ target.

* _make pwrctrl-upload_

An IoT sensors must be configured to operate on the same network as the Monitor's Sensor Network.  Once this has been done the IoT sensor and the Monitor can be paired.  An IoT device can only be paired with a single Monitor.

h3. Connect Serial Terminal to IoT Device

!>{width:300px}minicom.png(Sample minicom session)!

It helps, at this stage of development, to see what the ESP-01 thinks is happening while configuring it.  This can be done by connecting the FTDI Basic connector to a USB connector on a laptop.  The pwrctrl code should have been built with the SERIAL=1 environment variable.

* Connect the FTDI Basic to a USB port on the laptop.

* Check the laptop for a port such as /dev/ttyUSB0 (this may be different on different Linux distributions).

* Use _minicom_ or a similar serial communication program and connect it to /dev/ttyUSB0

** Baud: 115200

** No parity

** 1 stop bit

** Terminal type should be set to ANSI (you might get garbage characters otherwise)

You can now watch the progress of the ESP-01 as it processes hardware and software changes in the following sections.

h3. Configuring the pwrctrl to connect to the Monitor's Sensor Network

!>{width:300px}iotwebui.png(IoT Device Configuration)!

The pwrctrl sensor has it's own WiFi Access Point at 192.168.4.1 with no password.  This is used to configure the device to connect to the Monitor's Sensor Network.

* Set the Mode button to Config. 

* Power on the pwrctrl sensor.  The device will start an access point (AP) and a web server for configuring the device to connect to another network.

* Connect a laptop or smartphone to the _imiot_ SSID.  An IP will be assigned automatically to the laptop or smartphone.

* If connecting to the _imiot_ SSID does not automatically open a browser page to the IoT device's WiFi configuration page, then manually open a browser to http://192.168.4.1.

The configuration page looks like the image to the right.  This page has multiple options.  Only the first is needed to configure to the Sensor Network.

* Click on ...tbd...

* A scan of local WiFi access points will be shown.

* Choose the SSID configured for the Monitor's Sensor Network.

* Type in the password configured for the Monitor's Sensor Network.

* Click on ...tbd...

At this point the device will attempt to connect to the Monitor and retrieve an IP address.  Wait about 1 minute for this to complete.  Once connected, it is safe to restart the pwrctrl sensor.

* Turn the sensor off.

* Turn the Mode button to Normal.

* Power on the sensor.

The device is now ready for pairing with the Monitor.

h3. Pairing with a Monitor

Pairing is the process where the sensor registers with the Ironman Monitor.  Registration establishes device-specific encryption between the sensor and the monitor and provides a means by which automated updates can be sent from the sensor to the monitor and the monitor can send commands for sensor changes.

!>{width:300px}iotpair.png(Device pairing in Minicom session)!

* With the Monitor running, set the Monitor Mode switch to Pair.

* Power on the pwrctrl sensor.

* Turn the Mode button on the sensor to Config.

* Wait for it to pair with the Monitor.  When pairing is completed the Monitor's Mode Button LED will flash for 1 second and the Blue LED on the pwrctrl sensor will light for 3 seconds.

** The Monitor's Sensor app will show a new device that can now be managed from the Monitor.

* Turn the Mode switch to Normal on the Monitor.

* Turn the pwrctrl sensor off.

* Turn the Mode button on the pwrctrl sensor to Normal.

* Power on the pwrctrl sensor.

The pwrctrl sensor can now be managed by the Monitor's Sensor App.

table{border-collapse;width:100%}.

|={font-size:140%;margin-bottom:15px;background-color:#fdd}. *WARNING!* |

|={font-size:120%;margin-bottom:15px;background-color:#fdd}.  Leaving the Mode switch turned to Pair will allow random devices to attempt to pair with the Monitor.  This is a security risk.  The Mode switch should only be set to Pair long enough to pair with an pwrctrl sensor. |

h2. Jarvis

h3. Prerequisites

h3. Pairing with a Monitor

* With the Monitor running, set the Monitor Mode switch to Pair.

* TBD

h3. Supported Commands

h2. Addendums

h3. Ironman Packages

|_. Package   |_. Repository |_. Description |

|imcore       |monitor       |Package that updates a PiBox Development Ssytem for use with Ironman.  Includes network configuration updates and other config files. |

|imwww        |www           |Provides network configuration interface for Monitor (to be replaced with PiNet) |

|imrest       |imrest        |Provides IoT/Jarvis REST API for registrations, status and command.|

|imgpio       |gpio          |Command line tool for querying GPIO pins using syfs interface. (Will be deprecated.)|

|launcher     |launcher      |Ironman uses the PiBox launcher with a custom configuration. |

|pisensor     |pisensor      |Provides UI for managing sensors.  Uses inotify to watch for changes to registration files, which contains status information. |

|picam        |picam         |Generic console camera interface (same as PiBox Media Systems and PiSentry) |

All packages are built via the metabuild repository using the _build.sh -m ironman_ command.

h3. Source Code Repositories

* PiBox

** "Development Platform":https://gitlab.com/pibox/pibox

** "appmgr":https://gitlab.com/pibox/appmgr

** "mjpg-streamer":https://gitlab.com/pibox/mjpg-streamer

** "omxplayer":https://gitlab.com/pibox/omxplayer

** "piboxd":https://gitlab.com/pibox/piboxd

** "picam":https://gitlab.com/pibox/picam

** "pmsui":https://gitlab.com/pibox/pmsui

** "psplash":https://gitlab.com/pibox/psplash

* Ironman

** "gpio":https://gitlab.com/xironman/gpio

** "launcher":https://gitlab.com/xironman/launcher

** "monitor":https://gitlab.com/xironman/monitor

** "pisensor":https://gitlab.com/xironman/sensors

** "www":https://gitlab.com/xironman/www

** "meta build":https://gitlab.com/xironman/meta

* Arduino

** "pwrctrl (imlightsw) and other sensors":https://gitlab.com/xarduino/lightsw

h3. Fritzing Models

* ESP-01 Flasher: attachment:imlightsw-flasher.fzz

* Light Switch: attachment:imlightsw-with-relay-2.fzz

** "ESP8266":https://github.com/ydonnelly/ESP8266_fritzing

** "Keyes_SRly":https://github.com/rwaldron/fritzing-components

** "Breadboard Power Supply":https://github.com/AchimPieters/Fritzing-Custom-Parts/blob/master/YwRobot%20Breadboard%20Power%20Supply.fzpz

** "Hilink HLK-PM01":http://forum.fritzing.org/t/hlk-pm01-ac-dc-220v-to-5v/381

* Monitor Switch: attachment:IronmanMonitorSwitch.fzz

h3. Networking Internals

<pre>

wlan0

* This interface is used for configuration of the Monitor.

* Configured on the 192.168.36.0 subnet.

** See /etc/network/dhcpd.conf.aponly

uap0

* This interface is used as an access point for IoT devices.

* Configured on the 192.168.3.0 subnet.

** See /etc/network/dhcpd.conf.uap and dhcpd.conf.uap.tmpl

** The template is used to change the base subnet through the web interface.

** The SSID is _ironman_.

</pre>

h3. Monitor Pair Button Usage

<pre>

Pair/Config button is GPIO 4 (RPi pin 7)

Pair/Config LED is GPIO 7 (RPi pin 13)

	LED should only be lit on boot if button is enabled (in Config mode).

		In this case, we're in Config Mode to configure the networks.

		The web server (imwww) is on SSID _ironman_ at 192.168.36.1:1337.

	LED is off on boot if button is disabled (in Pair Mode).

	If in Pair Mode

		Start hostapd for aponly

		Start dhcpd for aponly on wlan0

		Start imrest web service on port 8165 for IoT devices and Jarvis interfaces.

	If in Config Mode

		Start wpa_supplicant on wlan0

		Create uap0 device as virtual device on wlan0

		Start dhcpd on uap0

		Start hostapd on uap0

		Start imwww for network configuration of the Monitor.

</pre>

h3. Monitor IoT Directories

<pre>

/home/httpd/imrest/ironman/iot		Registration directory for IoT devices

/home/httpd/imrest/ironman/jarvis	Registration directgory for Jarvis interfaces

</pre>

h2. Privileged Apps

Some applications must be privileged in order to perform their functions, such as the camera.  The terminal application is not privileged by default.  It can be made privileged with the following steps.

# Power down the Monitor.

# Remove the SD card and mount it into your laptop or desktop computer.

# Edit this file on the SD card:  /etc/appmgr.priv

# Add this line:  /usr/bin/xterm

# Save the file and unmount the SD card.

# Remove the SD card from the laptop or desktop.

# Replace the SD card in the Monitor.

# Power up the Monitor.

The terminal application will now have privileged access on the monitor.

h2. File Attachments