TS-TPC-7990
Known issues
This is a product still in the sample period, and so it has a few issues before it enters full production.
- Documentation is still in development
- Sleep mode not yet implemented
- REV 1 FPGA does not drive TOUCH_RESET for the PCAP display which can cause touch to fail. RMA to fix.
- PCAP touch occasionally sends multiple touch events for a single touch. This is being further investigated, but it will require an RMA.
If you would like to be notified when any of these issues are resolved, sign up for our notification system here.
{{Infobox
 | |
| Product Page | |
| Product Images | |
| Specifications | |
| Documentation | |
|---|---|
| Schematic | |
| Mechanical Drawing | |
| FTP Path | |
| Processor | |
| Freescale i.MX6 Quad core, or Solo | |
| i.MX6 Quad Product Page | |
| i.MX6 Solo Product Page | |
| IMX6Q Reference Manual | |
| IMX6S Reference Manual |
Overview
The TS-TPC-7990 is a TS-Socket Macrocontroller Computer on Module designed for high performance applications.
Getting Started
A Linux PC is recommended for development, and will be assumed for this documentation. For users in Windows or OSX we recommend virtualizing a Linux PC. Most of our platforms run Debian and if there is no personal distribution preference this is what we recommend for ease of use.
Virtualization
Suggested Linux Distributions
It may be possible to develop using a Windows or OSX system, but this is not supported. Development will include accessing drives formatted for Linux and often Linux based tools.
Booting up the board
| WARNING: | Be sure to take appropriate Electrostatic Discharge (ESD) precautions. Disconnect the power source before moving, cabling, or performing any set up procedures. Inappropriate handling may cause damage to the board. |
The TS-TPC-7990 accepts either 5VDC, or 8-28VDC. A power supply should be prepared to provide 20W, but the board power consumption will typically be around 8W on an idle quad core. See the #Specifications section for further details on power requirements, differences between builds, and options to reduce power.
Once you have applied power to either the 5VDC, or 8-28VDC you should look for console output. The next section of the manual provides information on getting the console connected. The first output is from U-Boot:
U-Boot 2015.04-07871-g805c369 (Aug 18 2016 - 10:20:55) CPU: Freescale i.MX6Q rev1.2 at 792 MHz CPU: Temperature 50 C Reset cause: WDOG Board: TS-TPC-7990 I2C: ready DRAM: 1 GiB MMC: FSL_SDHC: 0, FSL_SDHC: 1 SF: Detected N25Q64 with page size 256 Bytes, erase size 4 KiB, total 8 MiB auto-detected panel LXD-WSVGA Display: LXD-WSVGA (1024x600) In: serial Out: serial Err: serial FPGA Rev: 2 SilabRev: 33 Net: using phy at 7 FEC [PRIME] SF: Detected N25Q64 with page size 256 Bytes, erase size 4 KiB, total 8 MiB SF: 7655 bytes @ 0x200000 Read: OK
If JP2 is populated the board will check for USB updates, and then stop at a u-boot console. If it is not set the board will boot immediately to the selected device.
If JP3 is populated the board will boot to SD. If it is not set it will boot to eMMC.
| Note: | The "*** Warning - bad CRC, using default environment" can be safely ignored. If you "env save" this will use your environment on the disk, but on new boards the SPI flash is erased so it just doesn't have a modifed env saved. |
Get a Console
The TS-TPC-7990 includes a USB device port which can be used as a USB Serial console. Most Linux distributions include the cp210x driver and will register this as /dev/ttyUSB0. For other operating systems:
The serial console is provided through this port at 115200 baud, 8n1, with no flow control.
This is the Micro USB port (P2) next to a board mount.
Console from Linux
There are many serial terminal applications for Linux, three common used applications are picocom, screen, and minicom. These examples demonstrate all three applications and assume that the serial device is "/dev/ttyUSB0" which is common for USB adapters. Be sure to replace the serial device string with that of the device on your workstation.
picocom is a very small and simple client.
sudo picocom -b 115200 /dev/ttyUSB0
screen is a terminal multiplexer which happens to have serial support.
sudo screen /dev/ttyUSB0 115200
Or a very commonly used client is minicom which is quite powerful but requires some setup:
sudo minicom -s
- Navigate to 'serial port setup'
- Type "a" and change location of serial device to "/dev/ttyUSB0" then hit "enter"
- If needed, modify the settings to match this and hit "esc" when done:
E - Bps/Par/Bits : 115200 8N1
F - Hardware Flow Control : No
G - Software Flow Control : No
- Navigate to 'Save setup as dfl', hit "enter", and then "esc"
Console from Windows
Putty is a small simple client available for download here. Open up Device Manager to determine your console port. See the putty configuration image for more details.
U-Boot
This platform uses U-Boot as the bootloader to launch the full operating system. The i.MX6 processor loads U-Boot from the on-board 8 MiB SPI flash. U-Boot provides support for loading data from various mediums; this allows booting a kernel from SD, eMMC, SATA, NFS, or USB. U-Boot is a general purpose bootloader that is capable of booting into common Linux distributions, Android, Windows, or custom software OSes.
On a normal boot the output should be similar to the output below:
U-Boot 2015.04-07932-g68f7575230 (Apr 12 2017 - 10:16:39) CPU: Freescale i.MX6SOLO rev1.1 at 792 MHz CPU: Temperature 59 C Reset cause: WDOG Board: TS-TPC-7990 REV B I2C: ready DRAM: 1 GiB MMC: FSL_SDHC: 0, FSL_SDHC: 1 SF: Detected N25Q64 with page size 256 Bytes, erase size 4 KiB, total 8 MiB auto-detected panel LXD-WSVGA Display: LXD-WSVGA (1024x600) In: serial Out: serial Err: serial FPGA Rev: 8 SilabRev: 6 Net: using phy at 1 FEC [PRIME] SF: Detected N25Q64 with page size 256 Bytes, erase size 4 KiB, total 8 MiB SF: 7655 bytes @ 0x200000 Read: OK Booting from eMMC ...
By default the unit will boot to SD or eMMC depending on the status of the "SD boot" jumper on startup. If the jumper is set it boots to SD, otherwise the unit will boot to eMMC. Other boot options like SATA, Network, USB, will require customizing the U-Boot environment.
U-Boot Environment
The eMMC flash contains both the U-Boot executable binary and U-Boot environment. Our default build has 2 MiB of environment space which can be used for variables and boot scripts. The following commands are examples of how to manipulate the U-Boot environment:
# Print all environment variables
env print -a
# Sets the variable bootdelay to 5 seconds
env set bootdelay 5;
# Variables can also contain commands
env set hellocmd 'led red on; echo Hello world; led green on;'
# Execute commands saved in a variable
env run hellocmd;
# Commit environment changes to the SPI flash
# Otherwise changes are lost
env save
# Restore environment to default
env default -a
# Remove a variable
env delete emmcboot
U-Boot Commands
# The most important command is
help
# This can also be used to see more information on a specific command
help i2c
# This is a command added to U-Boot by TS to read the baseboard ID on our
# System on Module devices
bbdetect
echo ${baseboard} ${baseboardid}
# The echo will return something similar to:
# TS-8390 2
# Boots into the binary at $loadaddr. The loaded file needs to have
# the U-Boot header from mkimage. A uImage already contains this.
bootm
# Boots into the binary at $loadaddr, skips the initrd, specifies
# the FDT addrress so Linux knows where to find the device tree
bootm ${loadaddr} - ${fdtaddr}
# Boot a Linux zImage loaded at $loadaddr
bootz
# Boot in to a Linux zImage at $loadaddr, skip initrd, specifies
# the FDT address to Linux knows where to find the device tree
bootz ${loadaddr} - ${fdtaddr}
# Get a DHCP address
dhcp
# This sets ${ipaddr}, ${dnsip}, ${gatewayip}, ${netmask}
# and ${ip_dyn} which can be used to check if the dhcp was successful
# These commands are used for scripting:
false # do nothing, unsuccessfully
true # do nothing, successfully
# This command can set fuses in the processor
# Setting fuses can brick the unit, will void the warranty,
# and should not be done in most cases
fuse
# GPIO can be manipulated from U-Boot. Keep in mind that the IOMUX
# in U-Boot is only setup enough to boot the device, so not all pins will
# be set to GPIO mode out of the box. Boot to the full operating system
# for more GPIO support.
# GPIO are specified in bank and IO in this manual. U-Boot uses a flat numberspace,
# so for bank 2 DIO 25, this would be number (32*1)+25=89
# The formula thus being (32*(bank-1)+dio)=flattened_dio
# Note that on some products, bank 1 is the first bank
# Set 2_25 low
gpio clear 83
# Set 2_25 high
gpio set 83
# Read 2_25
gpio input 83
# Control LEDs
led red on
led green on
led all off
led red toggle
# This command is used to copy a file from most devices
# Load kernel from SD
load mmc 0:1 ${loadaddr} /boot/uImage
# Load Kernel from eMMC
load mmc 1:1 ${loadaddr} /boot/uImage
# Load kernel from USB
usb start
load usb 0:1 ${loadaddr} /boot/uImage
# Load kernel from SATA
sata init
load sata 0:1 ${loadaddr} /boot/uImage
# View the FDT from U-Boot
load mmc 0:1 ${fdtaddr} /boot/imx6q-ts4900.dtb
fdt addr ${fdtaddr}
fdt print
# It is possible to blindly jump to any memory location
# This is similar to bootm, but it does not require
# the use of the U-Boot header
load mmc 0:1 ${loadaddr} /boot/custombinary
go ${loadaddr}
# Browse fat, ext2, ext3, or ext4 filesystems:
ls mmc 0:1 /
# Access memory like devmem in Linux, read/write arbitrary memory
# using mw and md
# write
mw 0x10000000 0xc0ffee00 1
# read
md 0x10000000 1
# Test memory.
mtest
# Check for new SD card
mmc rescan
# Read SD card size
mmc dev 0
mmcinfo
# Read eMMC Size
mmc dev 1
mmcinfo
# The NFS command is like 'load', but used over the network
dhcp
env set serverip 192.168.0.11
nfs ${loadaddr} 192.168.0.11:/path/to/somefile
# Test ICMP
dhcp
ping 192.168.0.11
# Reboot
reset
# SPI access is through the SF command
# Be careful with sf commands since
# this is where U-Boot and the FPGA bitstream exist
# Improper use can render the board unbootable
sf probe
# Delay in seconds
sleep 10
# Load HUSH scripts that have been created with mkimage
load mmc 0:1 ${loadaddr} /boot/ubootscript
source ${loadaddr}
# Most commands have return values that can be used to test
# success, and HUSH scripting supports comparisons like
# test in Bash, but much more minimal
if load mmc 1:1 ${fdtaddr} /boot/uImage;
then echo Loaded Kernel
else
echo Could not find kernel
fi
# Commands can be timed with "time"
time sf probe
# Print U-Boot version/build information
version
Modify Linux Kernel cmdline
The Linux kernel cmdline can be customized by modifying the cmdline_append variable. The variable contents are clobbered when set, so be sure to specify the full desired cmdline string.
env set cmdline_append console=ttymxc0,115200 init=/sbin/init quiet
env save
The kernel command line can also be modified from from the on-board Linux. Debian (and other distributions) provide a U-Boot utilities package that contains the tools necessary to create a U-Boot script:
apt-get update && apt-get install u-boot-tools -y
echo "env set cmdline_append console=ttymxc0,115200 init=/sbin/init quiet" > /boot/boot.scr
mkimage -A arm -T script -C none -n 'tsimx6 boot script' -d /boot/boot.scr /boot/boot.ub
The boot.scr includes the plain text commands to be run in U-Boot on startup. The mkimage tool adds a checksum and header to this file which can be loaded by U-Boot. The .ub file should not be edited directly.
Booting From NFS
U-Boot includes support for NFS client which can be used to load the kernel, device tree binary, and root filesystem across the network. Our default environment contains the nfsboot command which can be updated to boot NFS on a custom network:
# Set this to your NFS server IP
env set nfsroot 192.168.0.36:/mnt/storage/imx6/
env save
# Boot to NFS once
run nfsboot;
# To make the NFS boot the persistent default
env set bootcmd run nfsboot;
env save
Booting From USB
On startup, U-Boot will attempt to load a script from USB if the U-Boot jumper is on. This can be used for reprogramming the board, or for booting to a kernel and/or filesystem on a USB drive. To make a bootable drive, create a single ext3 partition on a USB drive and copy over a rootfs (in the same manner as is done for an SD card. This is described in depth in the Debian and Yocto sections. Create the /tsinit.ub file in the root of the USB drive. Below is an example of booting to the filesystem on the USB drive:
# Prepare with:
# mkimage -A arm -T script -C none -n 'mx6 usb' -d tsinit.scr tsinit.ub
# DO NOT MANUALLY EDIT THE .UB FILE
if test ${model} = '7990'; then
if load usb ${bootpart} ${loadaddr} /boot/ts7990-fpga.vme; then
fpga load 0 ${loadaddr} ${filesize};
fi;
if test ${pcbrev} != 'a'; then
load usb ${bootpart} ${fdtaddr} /boot/imx6${cpu}-ts7990-${lcd}-revb.dtb;
else
load usb ${bootpart} ${fdtaddr} /boot/imx6${cpu}-ts7990-${lcd}.dtb;
fi;
load usb 0:1 ${loadaddr} ${uimage};
setenv bootargs root=/dev/sda1 rootwait rw ${cmdline_append};
bootm ${loadaddr} - ${fdtaddr};
fi
load usb 0:1 ${loadaddr} /boot/uImage;
setenv bootargs root=/dev/sda1 rootwait rw ${cmdline_append};
bootm ${loadaddr} - ${fdtaddr};
Generate the tsinit.ub file in the same directory, note that u-boot-tools or the equivalent package for a specific distribution will need to be installed:
mkimage -A arm -T script -C none -n 'mx6 usb' -d tsinit.scr tsinit.ub
Set the "U Boot" jumper, insert the USB drive to the device, and apply power.
Update U-Boot
| WARNING: | Installing a customer U-Boot binary is not recommended and may cause the unit to fail to boot. |
U-Boot requires a different build for Quad/Dual and Solo/Duallite. Flashing the wrong U-Boot image will cause the board to fail to properly boot. Recovery in this case would require submitting an RMA request.
On a booted unit at the U-Boot console, type "env print ${imx_type}" and this will return the U-Boot build that should be used. Copy the correct u-boot.imx file to the SD card, boot to the U-Boot shell, and run:
mmc dev 0
load mmc 0:1 ${loadaddr} /u-boot.imx
sf probe
sf erase 0 0x80000
sf write ${loadaddr} 0x400 $filesize
U-Boot Development
We do provide our U-Boot sources but we do not recommend rebuilding a custom U-Boot if it can be avoided. Custom built U-Boot binaries will not have the latest up to date settings. Specifically, the largest concern is with RAM timing settings. Memory technology is expanding rapidly and we may need to use different parts through the shipping lifetime of the device itself. If RAM timings change, then we update our factory shipped U-Boot to have the proper settings. A custom U-Boot would need to be re-built if any of these settings change.
Our U-Boot includes a variable "imx_type". If loading a custom U-Boot binary, make sure to check the value of this before writing. If we are forced to update the RAM configuration we will change this variable. We will also send out a product change to anyone who is subscribed to our PCS system.
If you still need to proceed with building a custom U-Boot, use the imx_v2015.04_3.14.52_1.1.0_ga branch from the github here: https://github.com/embeddedTS/u-boot-imx/
On a booted unit at the U-Boot console, type "env print ${imx_type}" and this will return the U-Boot build that should be used and the correct RAM timing.
After that, adjust the following commands to match the build configuration; these commands will build the u-boot.imx binary.
export ARCH=arm
export CROSS_COMPILE=arm-linux-gnueabihf-
export DATE=$(date +"%b-%d-%Y")
make ts7990-s-1g-800mhz-i_defconfig
make -j9 u-boot.imx
This will output a u-boot.imx file that can be written to the SPI flash following the instructions in the update U-Boot section.
U-Boot Recovery
We have several variations of the TS-TPC-7990's u-boot which include different RAM configurations for the Quad core, solo commercial, solo industrial, and a few older variants. On a functional board if you run "ech o ${imx_type}" this will show which variant you are running. To recover the system you must get it booting over the USB OTG port.
On startup, the i.MX6 checks the SPI flash for a valid boot header in SPI flash. If it is unable to locate a valid boot header, the CPU falls back to the "serial downloader" which allows the CPU to execute code sent via USB. If the unit has a valid but damaged or incorrect U-Boot binary programmed in to SPI flash, an RMA return will be required in order to properly recover it. Please contact us for assistance with this.
1) Download the U-Boot binary for the correct imx_type variant from the list here: https://files.embeddedTS.com/ts-arm-sbc/ts-7970-linux/u-boot/. See the U-Boot Changelog for information on the changes between released versions.
2) Download and build/install the "imx_usb" loader
3) Apply power to the device.
4) Plug a USB type B cable into the "Device" USB Micro connector on the device and connect it to a host PC.
5) Check 'dmesg' or 'lsusb' on the host PC for a new USB connection. This should show a HID device listing NXP or Freescale as the manufacturer. For example:
hid-generic 0003:15A2:0054.0006: hiddev0,hidraw3: USB HID v1.10 Device [Freescale SemiConductor Inc SE Blank ARIK] on usb-0000:00:14.0-6.4.2/input0
If it does not show the above output, an RMA return will be required in order to properly recover the unit. Please contact us for assistance with this.
6) Plug a USB type B cable into the "Console" USB Micro connector on the device and connect it to a host PC, and open your terminal emulator
7) Install the UBOOT jumper on the 7990 to stop at the u-boot prompt
8) Run 'imx_usb path/to/u-boot.imx' on the host PC
At this point, the USB serial device should show up on the host, opening it will reveal that the unit is stopped at the U-Boot prompt. Follow the steps in Update U-Boot to reinstall U-Boot on the SPI flash.
Yocto
Yocto is our recommended distribution for graphics packages as the software includes patches to support the GPU. X11 in Yocto includes drivers for providing 2D support as well. Support is also provided for OpenGLES 1&2, as well as GStreamer acceleration, included standalone or with Qt. Yocto also provides cross toolchains that include the rootfs. This toolchain allows integration with the Qt Creator IDE and Eclipse.
Yocto does not provide binary security updates. This distribution also does not have any remote repository of pre-built applications. For either of these we features we recommend using Debian.
Our current Yocto support is based off of Yocto 3.0 "Zeus".
Getting Started with Yocto
Yocto itself is a set of scripts and tools used to build a custom distribution. In our default images we try to include all the common utilities requested by users. Rebuilding Yocto should not be necessary for many users, but is possible if needed. See the Custom Build Yocto section for information on this process.
Our Yocto rootfs tarball is available here:
| Yocto Image | Download Link |
| ts-x11-image (Yocto Zeus) | Download |
To write this to an SD card, first partition the SD card to have one large ext3 partition. Most SD cards include one MBR partition by default. Cards can also be partitioned with fdisk, cfdisk, or the graphical gparted utility. This should be an MBR partition table, not GPT. Once it is partitioned, format the SD and extract this tar with:
# Assuming your SD card is /dev/sdc with one partition
mkfs.ext3 /dev/sdc1
mkdir /mnt/sd/
sudo mount /dev/sdc1 /mnt/sd/
sudo tar --numeric-owner -jxf ts-x11-image-tsimx6-latest.rootfs.tar.bz2 -C /mnt/sd
sudo umount /mnt/sd
sync
| Note: | The ext4 filesystem can be used instead of ext3, but it may require additional options. U-Boot does not support the 64bit addressing added as the default behavior in recent revisions of mkfs.ext4. If using e2fsprogs 1.43 or newer, the options "-O ^64bit,^metadata_csum" must be used with ext4 for proper compatibility. Older versions of e2fsprogs do not need these options passed nor are they needed for ext3. |
To rewrite the eMMC, boot to the SD card. You cannot rewrite the eMMC while it is mounted elsewhere, or used to currently boot the system. Once booted to the SD, run:
mkfs.ext3 /dev/mmcblk2p1
mkdir /mnt/emmc
mount /dev/mmcblk2p1 /mnt/emmc
wget -qO- https://files.embeddedTS.com/ts-socket-macrocontrollers/ts-4900-linux/distributions/yocto/zeus/ts-x11-image-tsimx6-latest.rootfs.tar.bz2 | tar --numeric-owner xj -C /mnt/emmc/
umount /mnt/emmc
sync
The same commands can be used to write SATA by substituting /dev/mmcblk2p1 with /dev/sda1.
First Boot
The stock Yocto image provides a single login of root with no password. With Zeus, the wired ethernet interface will attempt to acquire an IP address via DHCP automatically. However, it is not possible to log in via the network at this time due to security of the device requiring a password for SSH access. Initial login to the device must first be done on the serial console.
Yocto Networking
Our Yocto image uses systemd which stores its network files in /etc/systemd/network/. Yocto will automatically enable DHCP on its wired interfaces. This can be overridden to set a static IP or enable other options for DHCP. The only requirement is that this file is named /etc/systemd/network/XX-wired.network Where "XX" is a number smaller than 80, e.g. /etc/systemd/network/79-wired.network This format must be used for all eth* and en* named network interfaces. The lower file names will take priority.
An example of a static configuration would be:
/etc/systemd/network/42-wired.network
[Match]
Name=eth0
[Network]
Address=192.168.0.50/24
Gateway=192.168.0.1
DNS=192.168.0.1
DNS will be loaded from /etc/resolv.conf. To make this use a static DNS:
rm /etc/resolv.conf
echo "nameserver 8.8.8.8" > /etc/resolv.conf
echo "nameserver 8.8.4.4" >> /etc/resolv.conf
To use the DNS assigned by DHCP, run:
ln -s /run/systemd/resolve/resolv.conf /etc/resolv.conf
For more information on what options are available to configure the network, see the systemd network documentation.
Yocto Wireless
The Atmel driver needs to be loaded manually on units that include wifi. Run 'modprobe wilc3000' to manually load the driver once, or edit /etc/modules and add "wilc3000" on a new line to have the module automatically load on startup.
Yocto uses systemd to start wpa_supplicant, and systemd-networkd to set an IP address via a static setting or DHCP.
Scan for a network
ifconfig wlan0 up
# Scan for available networks
iwlist wlan0 scan
An example of connecting to an open network with an SSID of "default":
Cell 03 - Address: c0:ff:ee:c0:ff:ee
Mode:Managed
ESSID:"default"
Channel:2
Encryption key:off
Bit Rates:9 Mb/s
To connect to this open network manually for just this boot:
iwconfig wlan0 essid "default"
Use the 'iwconfig' command to determine authentication to an access point. Before connecting it will show something like this:
# iwconfig wlan0
wlan0 IEEE 802.11bgn ESSID:"default"
Mode:Managed Frequency:2.417 GHz Access Point: c0:ff:ee:c0:ff:ee
Bit Rate=1 Mb/s Tx-Power=20 dBm
Retry long limit:7 RTS thr:off Fragment thr:off
Encryption key:off
Power Management:off
Link Quality=70/70 Signal level=-34 dBm
Rx invalid nwid:0 Rx invalid crypt:0 Rx invalid frag:0
Tx excessive retries:0 Invalid misc:0 Missed beacon:0
If connecting using WEP, also specify a network key:
iwconfig wlan0 essid "default" key "yourpassword"
If connecting to a WPA network use wpa_passphrase and wpa_supplicant:
mkdir /etc/wpa_supplicant/
wpa_passphrase "ssid name" "full passphrase" >> /etc/wpa_supplicant/wpa_supplicant-wlan0.conf
After generating the configuration file the wpa_supplicant daemon can be started.
wpa_supplicant -iwlan0 -c/etc/wpa_supplicant/wpa_supplicant-wlan0.conf -B
This will return:
Successfully initialized wpa_supplicant root@ts-imx6-q:~# [ 306.924691] wlan0: authenticate with 28:cf:da:b0:f5:bb [ 306.959415] wlan0: send auth to 28:cf:da:b0:f5:bb (try 1/3) [ 306.968137] wlan0: authenticated [ 306.978477] wlan0: associate with 28:cf:da:b0:f5:bb (try 1/3) [ 306.988577] wlan0: RX AssocResp from 28:cf:da:b0:f5:bb (capab=0x1431 status=0 aid=9) [ 307.009751] wlan0: associated [ 307.012768] IPv6: ADDRCONF(NETDEV_CHANGE): wlan0: link becomes ready [ 307.047989] wlcore: Association completed.
Use 'iwconfig wlan0' to verify an "Access Point" is specified to verify a connection. This will also report the link quality to the AP.
Wireless may be associated, but this does not get an IP on the network. To connect to the internet or talk to the internal network first configure the interface. See configuring the network, but on many networks only a DHCP client is needed:
udhcpc -i wlan0
Systemd can also be configured to start wpa_supplicant on boot up.
# Assuming the same path for the wpa conf file as shown above
systemctl enable wpa_supplicant@wlan0
systemctl start wpa_supplicant@wlan0
Once this service is started it will bring up the wlan0 interface and associate it to the SSID that is noted in the wpa_supplicant.conf file. Configure the IP settings the same way as a wired network.
In /etc/systemd/network/wlan0.network
[Match]
Name=wlan0
[Network]
DHCP=yes
For a static configuration create a config file for that specific interface. /etc/systemd/network/wlan0.network
[Match]
Name=wlan0
[Network]
Address=192.168.0.50/24
Gateway=192.168.0.1
DNS=192.168.0.1
For more information on what options are available to configure the network, see the systemd network documentation.
Yocto Application Development
Yocto provides a cross toolchain including the native tools and required ARM libraries. The cross toolchain is only available for 64bit Linux host PCs. Download the toolchain by saving the following link:
In order to install the toolchain, use the following commands to run the installation script:
chmod a+x poky-*.sh
sudo ./poky-*.sh
In order to use the toolchain, the environment for it must be sourced to the current terminal before it can be used to build applications: To build an application first source the environment for the toolchain:
source /opt/poky/3.0.2/environment-setup-cortexa9t2hf-neon-poky-linux-gnueabi
# This command sets up paths for the shell along with a number of other
# environment variable. For example:
$ echo $CC
arm-poky-linux-gnueabi-gcc -march=armv7-a -marm -mthumb-interwork -mfloat-abi=hard -mfpu=neon -mtune=cortex-a9 --sysroot=/opt/poky/2.2.2/sysroots/cortexa9hf-vfp-neon-poky-linux-gnueabi
# Cross compiling a simple hello world program:
$CC hello.c -o hello
It is also possible to develop applications directly on the device via serial console or ssh. Yocto includes development tools such as vim, gcc, g++, gdb, make, autoconf, binutils, etc. See the next sections for using the cross toolchain with IDEs.
Configure Qt Creator IDE
| Note: | This guide is intended for our stock Yocto image using systemd. On custom images, the same instructions should apply if a cross toolchain is built. This can be built through Yocto with bitbake meta-toolchain-qt5. Be sure to update the paths if using a different distribution.
|
Install the qtcreator tool on a host Linux PC. Any recent version from a modern Linux distribution should be sufficient and work without issue. On a Debian/Ubuntu desktop, run:
sudo apt-get update && sudo apt-get install qtcreator -y
The SDK which includes the Qt support will also need to be downloaded. The cross toolchain is only available for 64-bit Linux host PCs:
In order to install the toolchain, use the following commands to run the installation script:
chmod a+x poky-*.sh
sudo ./poky-*.sh
These instructions assume the installation path will be the default at /opt/poky/3.0.2/
| Note: | An environment script has to be sourced before every execution of qtcreator. Without this, builds will fail. |
source /opt/poky/3.0.2/environment-setup-cortexa9t2hf-neon-poky-linux-gnueabi
qtcreator
Qt Creator needs to be configured to build using this toolchain. Once Qt Creator is launched, select Tools->Options->Devices Click Add, select Generic Linux Device, and then click Start Wizard
 |
On the next page specify the IP address or hostname of the device running Yocto. In this example, the unit has an IP address of 192.168.2.45 obtained via DHCP. The default Yocto image will use the user root with no password to connect. Set the name to TSIMX6
 |
It will then verify connectivity. Click close and continue.
 |
| Note: | The paths given in the images below may not match the latest toolchain, but are meant to show where these values would go. Follow the text appropriate to the architecture of your host PC for the correct values |
In the left column of the Options menu, select Build & Run. On the Qt Versions tab, click Add in the upper right to configure the TS Kit. Qt Creator may see the qmake binary added to your path from the sourced environment script. If this is detected, add in the string TSIMX6 to the title as shown in the photo below. If it is not autodetected, add the full path and ensure the version name is set to TSIMX6 Qt 5.13.2. This will allow it to be recognized when setting the right binary for the kit.
/opt/poky/3.0.2/sysroots/x86_64-pokysdk-linux/usr/bin/qmake
 |
On the Compilers tab click Add, select GCC then C. Set the Name to TSIMX6 GCC. For the Compiler Path use the following:
/opt/poky/3.0.2/sysroots/x86_64-pokysdk-linux/usr/bin/arm-poky-linux-gnueabi/arm-poky-linux-gnueabi-gcc
Repeat the above steps for the g++ compiler; click Add, select GCC then C++. Set the name to TSIMX6 G++. And for the Compiler Path use the following:
/opt/poky/3.0.2/sysroots/x86_64-pokysdk-linux/usr/bin/arm-poky-linux-gnueabi/arm-poky-linux-gnueabi-g++
 |
On the Debuggers tab click Add. For name, specify TSIMX6 GDB. For the path, specify the location of gdb with the following:
/opt/poky/3.0.2/sysroots/x86_64-pokysdk-linux/usr/bin/arm-poky-linux-gnueabi/arm-poky-linux-gnueabi-gdb
 |
On the Kits tab click Add. For Name, enter TSIMX6. Set device type to Generic Linux Device. Set the device to TSIMX6 (default for Generic Linux). Set Qt mkspec to the following (make sure there is no space at the end):
/opt/poky/3.0.2/sysroots/cortexa9t2hf-neon-poky-linux-gnueabi/usr/lib/mkspecs/linux-oe-g++
Set C Compiler to TSIMX6 GCC and C++ Compiler to TSIMX6 G++. Set Debugger to TSIMX6 GDB. Set the Qt version to TSIMX6 QT 5.13.2. Finally, click Apply.
 |
| Note: | If there is a red exclamation point over the kits icon, it indicates that the compiler ABI does not match. In this case, you will need to revisit the "Compiler", "Debugger", and "Qt Versions" tabs, and browse the host PC for these files manually rather than copy/pasting the paths from these instructions. This is a bug in Ubuntu 16.04's Qt Creator, and may be in later versions as well. |
At this point Qt Creator is set up to begin a hello world project.
Qt Creator Hello World
Open the Qt Creator IDE and click New Project.
 |
Qt provides multiple templates for application development. For this example select the default Qt Widgets Application.
 |
Specify the location for your project. Keep in mind that the compile process will create more build paths in the Create In: path.
 |
Next, select the kit. The TSIMX6 is the kit we set up in the last section, but you may have other kits pre-installed on your system. These can be used for testing graphical development on your PC. Keep in mind distribution versions may contain different functionality.
 |
Next select the class and filename information. This example will use the defaults.
 |
Select any version control for the project. The example will use none and finish the wizard. This will generate the new project.
 |
Click the button under Help on the left column, and select TSIMX6 debug. If there is only one kit selected, this will be default.
 |
Now return to edit, and open the Qt project file, qt5-helloworld.pro. Add in these lines anywhere after the target is specified:
linux-* {
target.path = /home/root
INSTALLS += target
}
 |
Last, the DISPLAY must be selected. This is done by setting a run environment variable that will be set when the application is run on the board.
 |
At this point click the green allow in the bottom left to run the application. This can also be launched from the menu at Build->Run.
 |
From here, you can begin customizing your application. Refer to the official Qt documentation for more information
Yocto Hide Cursor
The default image includes the xcursor-transparent icon theme. This can hide the mouse pointer. To enable this, run these commands:
mkdir -p ~/.icons/default/
echo "[Icon Theme]" > ~/.icons/default/index.theme
echo "Inherits=xcursor-transparent" >> ~/.icons/default/index.theme
# Now reset x, or reset the unit and the cursor will be invisible.
Yocto Startup Scripts
To have a custom headless application start up at boot a systemd service needs to be created. Create the file /etc/systemd/system/yourapp.service with contents similar to below:
[Unit]
Description=Run an application on the i.MX6
[Service]
Type=simple
ExecStart=/usr/local/bin/your_app_or_script
[Install]
WantedBy=multi-user.target
If an application depends on networking, the systemd script will want to have After=network.target in the Unit section. Once this file is in place, it can be added to automatic startup with the following:
# Enable the application to be started on boot up
systemctl enable yourapp.service
# Start the application now, but will not affect automatic startup
systemctl start yourapp.service
| Note: | See the systemd documentation for in depth documentation on services. |
To set up a graphical application startup, modify the /usr/bin/mini-x-session file
At the end of the script replace matchbox-terminal with the desired application (absolute path may need to be specified):
matchbox-terminal &
exec matchbox-window-manager
The exec statement must be last in the script in order to take over this script's PID for correct operation.
Custom Build Yocto
If our stock Yocto distribution does not meet all of your needs, it is possible to re-build it with a custom set of features. Including less options for a smaller footprint, or more packages to add more features.
While we may provide guidance, our free support does not include every situation that can cause a build failure in generating custom images.
Debian
Debian is a community run Linux distribution. Debian provides tens of thousands of precompiled applications and services. This distribution is known for stability and large community providing support and documentation. This distribution does not include the same support as Yocto for the GPU. OpenGL ES, Gstreamer, or OpenCL are not supported in Debian. The framebuffer is supported so 2D applications such as browsers and typical simple interface will still run well. Debian is also very well suited for headless applications.
We provide Debian Jessie (8) and Debian Stretch (9). New development is recommended to use Debian Stretch (9) which will receive updates until June 2022, while Jessie is updated with at least until April 2020.
Debian Stretch(9)
We provide two images for Debian Stretch which apply to our TS-4900, TS-7970, and TS-TPC-7990. If you are unsure which image to pick, use the larger image which contains more development tools and drivers.
| Image | Size | Kernel config | Description |
|---|---|---|---|
| debian-armhf-stretch-latest.tar.bz2 | 1279MB | ts4900_defconfig | Contains gcc, vim, X11, slim, and will autologin to an xfce4 desktop. |
| debian-armhf-stretch-minimal-latest.tar.bz2 | 184MB | ts4900_tiny_defconfig | Stripped down Debian containing bare minimal hardware support, very limited peripheral support, and only the core debian packages. |
Once installed the default user on either image is "root" with no password.
To prepare an SD card, use partitioning tools such as 'fdisk' 'cfdisk' or 'gparted' in linux to create a single linux partition on the SD card. Once the partition is created and formatted, extract the above tarball with:
# Assuming your SD card is /dev/sdc with one partition
mkfs.ext3 /dev/sdc1
mkdir /mnt/sd/
sudo mount /dev/sdc1 /mnt/sd/
sudo tar --numeric-owner -xjf debian-armhf-stretch-latest.tar.bz2 -C /mnt/sd
sudo umount /mnt/sd
sync
| Note: | The ext4 filesystem can be used instead of ext3, but it may require additional options. U-Boot does not support the 64bit addressing added as the default behavior in recent revisions of mkfs.ext4. If using e2fsprogs 1.43 or newer, the options "-O ^64bit,^metadata_csum" must be used with ext4 for proper compatibility. Older versions of e2fsprogs do not need these options passed nor are they needed for ext3. |
To rewrite the eMMC the unit must be booted to SD or any other media that is not eMMC. Once booted, run the following commands.:
mkfs.ext3 /dev/mmcblk2p1
mkdir /mnt/emmc
mount /dev/mmcblk2p1 /mnt/emmc
wget -qO- ftp://ftp.embeddedTS.com/ts-socket-macrocontrollers/ts-4900-linux/distributions/debian/debian-armhf-stretch-latest.tar.bz2 | tar xj -C /mnt/emmc/
umount /mnt/emmc
sync
The same commands can be used to write a SATA drive by substituting /dev/mmcblk2p1 with /dev/sda1.
Debian Networking
Debian can automatically set up the networking based on the contents of "/etc/network/interfaces.d/" files. For example, to enable DHCP for "eth0" by default on startup:
echo "auto eth0
iface eth0 inet dhcp" > /etc/network/interfaces.d/eth0
To set up a static IP:
echo "auto eth0
iface eth0 inet static
address 192.168.0.50
netmask 255.255.255.0
gateway 192.168.0.1" > /etc/network/interfaces.d/eth0
echo "nameserver 1.1.1.1" > /etc/resolv.conf
To make this take effect immediately for either option:
service networking restart
To configure other interfaces, replace "eth0" with the other network device name. Some interfaces may use predictable interface names. For example, the traditional name for an ethernet port might be "eth1", but some devices may use "enp1s0" for PCIe, or "enx00D069C0FFEE" (the MAC address appended) for USB ethernet interfaces. Run 'ifconfig -a' or 'ip a' to get a complete list of interfaces, including the ones that are not configured.
Debian WIFI Client
The Atmel driver needs to be loaded manually on units that include wifi. Run "modprobe wilc3000" to loader the driver manually once, or edit /etc/modules and add "wilc3000" to the end to have the module automatically load on startup.
Wireless interfaces are also managed with configuration files in "/etc/network/interfaces.d/". For example, to connect as a client to a WPA network with DHCP. Note some or all of this software may already be installed on the target SBC.
Install wpa_supplicant:
apt-get update && apt-get install wpasupplicant -y
Run:
wpa_passphrase youressid yourpassword
This command will output information similar to:
network={
ssid="youressid"
#psk="yourpassword"
psk=151790fab3bf3a1751a269618491b54984e192aa19319fc667397d45ec8dee5b
}
Use the hashed PSK in the specific network interfaces file for added security. Create the file:
/etc/network/interfaces.d/wlan0
allow-hotplug wlan0
iface wlan0 inet dhcp
wpa-ssid youressid
wpa-psk 151790fab3bf3a1751a269618491b54984e192aa19319fc667397d45ec8dee5bTo have this take effect immediately:
service networking restart
For more information on configuring Wi-Fi, see Debian's guide here.
Debian WIFI Access Point
The Atmel driver needs to be loaded manually on units that include wifi. Run "modprobe wilc3000" to loader the driver manually once, or edit /etc/modules and add "wilc3000" to the end to have the module automatically load on startup.
First, hostapd needs to be installed in order to manage the access point on the device:
apt-get update && apt-get install hostapd -y
| Note: | The install process will start an unconfigured hostapd process. This process must be killed and restarted before a new hostapd.conf will take effect. |
Edit /etc/hostapd/hostapd.conf to include the following lines:
interface=wlan0 driver=nl80211 ssid=YourAPName channel=1
| Note: | Refer to the kernel's hostapd documentation for more wireless configuration options. |
To start the access point launch hostapd:
hostapd /etc/hostapd/hostapd.conf &
This will start up an access point that can be detected by WIFI clients. A DHCP server will likely be desired to assign IP addresses. Refer to Debian's documentation for more details on DHCP configuration.
Debian Application Development
Debian Stretch Cross Compiling
Debian Stretch provides cross compilers from the Debian apt repository archive for Debian Stretch. An install on a workstation can build for the same release on other architectures. A Linux desktop or laptop PC, virtual machine, or chroot will need to be used for this. Debian Stretch for a workstation can be downloaded from here.
From a Debian workstation (not the target), run these commands to set up the cross compiler:
# Run "lsb_release -a" and verify Debian 9.X is returned. These instructions are not
# expected to work on any other version or distribution.
su root
# Not needed for the immediate apt-get install, but used
# so we can install package:armhf for cross compiling
dpkg --add-architecture armhf
apt-get update
apt-get install curl build-essential crossbuild-essential-armhf -y
This will install a toolchain that can be used with the prefix "arm-linux-gnueabihf-". The standard GCC tools will start with that name, eg "arm-linux-gnueabihf-gcc".
The toolchain can now compile a simple hello world application. Create hello-world.c on the Debian workstation:
#include <stdio.h>
int main(){
printf("Hello World\n");
}
To compile this:
arm-linux-gnueabihf-gcc hello-world.c -o hello-world
file hello-world
This will return that the binary created is for ARM. Copy this to the target platform to run it there.
Debian Stretch supports multiarch which can install packages designed for other architectures. On workstations this is how 32-bit and 64-bit support is provided. This can also be used to install armhf packages on an x86 based workstation.
This cross compile environment can link to a shared library from the Debian root. The package would be installed in Debian on the workstation to provide headers and libraries. This is included in most "-dev" packages. When run on the arm target it will also need a copy of the library installed, but it does not need the -dev package.
apt-get install libcurl4-openssl-dev:armhf
# Download the simple.c example from curl:
wget https://raw.githubusercontent.com/bagder/curl/master/docs/examples/simple.c
# After installing the supporting library, curl will link as compiling on the unit.
arm-linux-gnueabihf-gcc simple.c -o simple -lcurl
Copy the binary to the target platform and run on the target. This can be accomplished with network protocols like NFS, SCP, FTP, etc.
If any created binaries do not rely on hardware support like GPIO or CAN, they can be run using 'qemu'.
# using the hello world example from before:
./hello-world
# Returns Exec format error
apt-get install qemu-user-static
./hello-world
Debian Installing New Software
Debian provides the apt-get system which allows management of pre-built applications. The apt tools require a network connection to the internet in order to automatically download and install new software. The update command will download a list of the current versions of pre-built packages.
apt-get update
A common example is installing Java runtime support for a system. Find the package name first with search, and then install it.
root@ts:~# apt-cache search openjdk default-jdk - Standard Java or Java compatible Development Kit default-jdk-doc - Standard Java or Java compatible Development Kit (documentation) default-jdk-headless - Standard Java or Java compatible Development Kit (headless) default-jre - Standard Java or Java compatible Runtime default-jre-headless - Standard Java or Java compatible Runtime (headless) jtreg - Regression Test Harness for the OpenJDK platform libreoffice - office productivity suite (metapackage) openjdk-8-dbg - Java runtime based on OpenJDK (debugging symbols) openjdk-8-demo - Java runtime based on OpenJDK (demos and examples) openjdk-8-doc - OpenJDK Development Kit (JDK) documentation openjdk-8-jdk - OpenJDK Development Kit (JDK) openjdk-8-jdk-headless - OpenJDK Development Kit (JDK) (headless) openjdk-8-jre - OpenJDK Java runtime, using Hotspot JIT openjdk-8-jre-headless - OpenJDK Java runtime, using Hotspot JIT (headless) openjdk-8-jre-zero - Alternative JVM for OpenJDK, using Zero/Shark openjdk-8-source - OpenJDK Development Kit (JDK) source files uwsgi-app-integration-plugins - plugins for integration of uWSGI and application uwsgi-plugin-jvm-openjdk-8 - Java plugin for uWSGI (OpenJDK 8) uwsgi-plugin-jwsgi-openjdk-8 - JWSGI plugin for uWSGI (OpenJDK 8) uwsgi-plugin-ring-openjdk-8 - Closure/Ring plugin for uWSGI (OpenJDK 8) uwsgi-plugin-servlet-openjdk-8 - JWSGI plugin for uWSGI (OpenJDK 8) java-package - Utility for creating Java Debian packages
In this case, the wanted package will likely be the "openjdk-8-jre" package. Names of packages can be found on Debian's wiki pages or the packages site.
With the package name apt-get install can be used to install the prebuilt packages.
apt-get install openjdk-8-jre
# More than one package can be installed at a time.
apt-get install openjdk-8-jre nano vim mplayer
For more information on using apt-get refer to Debian's documentation here.
Debian Setting up SSH
To install the SSH server, install the package with apt-get:
apt-get install openssh-server
Debian Stretch by default disallows logins directly from the user "root". Additionally, SSH will not allow remote connections without a password or valid SSH key pair. This means in order to SSH to the device, a user account must first be created, and a password set:
useradd --create-home --shell /bin/bash newuser
passwd newuser
After this setup it is now possible to connect to the device as user "newuser" from a remote PC supporting SSH. On Linux/OS X this is the "ssh" command, or from Windows using a client such as PuTTY.
Debian Starting Automatically
A systemd service can be created to start up headless applications. Create a file in /etc/systemd/system/yourapp.service
[Unit]
Description=Run an application on startup
[Service]
Type=simple
ExecStart=/usr/local/bin/your_app_or_script
[Install]
WantedBy=multi-user.target
If networking is a dependency add "After=network.target" in the Unit section. Once you have this file in place add it to startup with:
# Start the app on startup, but will not start it now
systemctl enable yourapp.service
# Start the app now, but doesn't change auto startup
systemctl start yourapp.service
| Note: | See the systemd documentation for in depth documentation on services. |
To start an application on bootup with X11 instead change the x-session-manager. By default the system starts xfce:
root@ts:~# ls -lah /usr/bin/x-session-manager
lrwxrwxrwx 1 root root 35 May 26 2015 /usr/bin/x-session-manager -> /etc/alternatives/x-session-manager
root@ts:~# ls -lah /etc/alternatives/x-session-manager
lrwxrwxrwx 1 root root 19 May 26 2015 /etc/alternatives/x-session-manager -> /usr/bin/startxfce4
The x-session can be modified to only start specified processes. Create the file /usr/bin/mini-x-session with these contents:
#!/bin/bash
matchbox-window-manager -use_titlebar no &
exec xfce4-terminal
You may need to "apt-get install matchbox-window-manager." first. This is a tiny window manager which also has a few flags that simplify embedded use. Now enable this session manager and restart slim to restart x11 and show it now.
chmod a+x /usr/bin/mini-x-session
rm /etc/alternatives/x-session-manager
ln -s /usr/bin/mini-x-session /etc/alternatives/x-session-manager
service slim restart
If the x-session-manager process ever closes x11 will restart. The exec command allows a new process to take over the existing PID. In the above example xfce4-terminal takes over the PID of x-session-manager. If the terminal is closed with commands like exit the slim/x11 processes will restart.
Debian Jessie(8)
Getting Started with Debian
Once installed, the default user is "root" with no password.
| Note: | This is a shared image that supports the TS-4900, TS-7970, and TS-TPC-7990. |
To prepare an SD card, use partitioning tools such as 'fdisk' 'cfdisk' or 'gparted' in linux to create a single linux partition on the SD card. Once the partition is set up and formatted, extract the above tarball with:
# Assuming your SD card is /dev/sdc with one partition
mkfs.ext3 /dev/sdc1
mkdir /mnt/sd/
sudo mount /dev/sdc1 /mnt/sd/
sudo tar --numeric-owner -xjf debian-armhf-jessie-latest.tar.bz2 -C /mnt/sd
sudo umount /mnt/sd
sync
| Note: | The ext4 filesystem can be used instead of ext3, but it may require additional options. U-Boot does not support the 64bit addressing added as the default behavior in recent revisions of mkfs.ext4. If using e2fsprogs 1.43 or newer, the options "-O ^64bit,^metadata_csum" must be used with ext4 for proper compatibility. Older versions of e2fsprogs do not need these options passed nor are they needed for ext3. |
To rewrite the eMMC the unit must be booted to SD or any other media that is not eMMC. Once booted, run the following commands.:
mkfs.ext3 /dev/mmcblk2p1
mkdir /mnt/emmc
mount /dev/mmcblk2p1 /mnt/emmc
wget -qO- https://files.embeddedTS.com/ts-socket-macrocontrollers/ts-4900-linux/distributions/debian/debian-armhf-jessie-latest.tar.bz2 | tar xj -C /mnt/emmc/
umount /mnt/emmc
sync
The same commands can be used to write a SATA drive by substituting /dev/mmcblk2p1 with /dev/sda1.
Debian Networking
From almost any Linux system you can use 'ip' command or the 'ifconfig' and 'route' commands to initially set up the network.
# Bring up the CPU network interface
ifconfig eth0 up
# Or if you're on a baseboard with a second ethernet port, you can use that as:
ifconfig eth1 up
# Set an ip address (assumes 255.255.255.0 subnet mask)
ifconfig eth0 192.168.0.50
# Set a specific subnet
ifconfig eth0 192.168.0.50 netmask 255.255.0.0
# Configure your route. This is the server that provides your internet connection.
route add default gw 192.168.0.1
# Edit /etc/resolv.conf for your DNS server
echo "nameserver 192.168.0.1" > /etc/resolv.conf
Most networks will offer a DHCP server, an IP address can be obtained from a server with a single command in linux:
Configure DHCP in Debian:
# To setup the default CPU ethernet port
dhclient eth0
# Or if you're on a baseboard with a second ethernet port, you can use that as:
dhclient eth1
# You can configure all ethernet ports for a dhcp response with
dhclient
Systemd provides a networking configuration option to allow for automatic configuration on startup. Systemd-networkd has a number of different configuration files, some of the default examples and setup steps are outlined below.
/etc/systemd/network/eth.network
[Match]
Name=eth*
[Network]
DHCP=yes
To use DHCP to configure DNS via systemd, start and enable the network name resolver service, systemd-resolved:
systemctl start systemd-resolved.service
systemctl enable systemd-resolved.service
ln -s /run/systemd/resolve/resolv.conf /etc/resolv.conf
For a static config create a network configuration for that specific interface.
/etc/systemd/network/eth0.network
[Match]
Name=eth0
[Network]
Address=192.168.0.50/24
Gateway=192.168.0.1
DNS=192.168.0.1
For more information on networking, see Debian and systemd's documentation:
Debian WIFI Client
If connecting to a WPA/WPA2 network, a wpa_supplicant config file must first be created:
wpa_passphrase yournetwork yournetworkpassphrase > /etc/wpa_supplicant/wpa_supplicant-wlan0.conf
Create the file /lib/systemd/system/wpa_supplicant@.service with these contents
[Unit]
Description=WPA supplicant daemon (interface-specific version)
Requires=sys-subsystem-net-devices-%i.device
After=sys-subsystem-net-devices-%i.device
[Service]
Type=simple
ExecStart=/sbin/wpa_supplicant -c/etc/wpa_supplicant/wpa_supplicant-%I.conf -i%I
[Install]
Alias=multi-user.target.wants/wpa_supplicant@%i.service
Create the file /etc/systemd/network/wlan0.network with:
[Match]
Name=wlan0
[Network]
DHCP=yes
See the systemctl-networkd example for setting a static IP for a network interface. The wlan0.network can be configured the same way as an eth.network.
To enable all of the changes that have been made, run the following commands:
systemctl enable wpa_supplicant@wlan0
systemctl start wpa_supplicant@wlan0
systemctl restart systemd-networkd
Debian WIFI Access Point
First, hostapd needs to be installed in order to manage the access point on the device:
apt-get update && apt-get install hostapd -y
| Note: | The install process will start an unconfigured hostapd process. This process must be killed and restarted before a new hostapd.conf will take effect. |
Edit /etc/hostapd/hostapd.conf to include the following lines:
interface=wlan0 driver=nl80211 ssid=YourAPName channel=1
| Note: | Refer to the kernel's hostapd documentation for more wireless configuration options. |
To start the access point launch hostapd:
hostapd /etc/hostapd/hostapd.conf &
This will start up an access point that can be detected by WIFI clients. A DHCP server will likely be desired to assign IP addresses. Refer to Debian's documentation for more details on DHCP configuration.
Debian Application Development
Debian Jessie Cross Compiling
Debian Jessie previously provided cross compilers via the Emdebian project. However, Emdebian has been unmaintained for a number of years and is no longer able to provide a viable install package. In order to cross compile from a Debian Jessie workstation, a third party cross compiler is required.
A Debian Jessie install on a workstation has the ability to build for the same release on other architectures using Debian binary libraries. A PC, virtual machine, or chroot will need to be used for this. Install Debian Jessie for your workstation here.
From a Debian workstation (not the target), run the following commands to set up the cross compiler. Note that this expects a 64-bit Debian Jessie install on the workstation. 32-bit installations are not supported at this time.
# Run "lsb_release -a" and verify Debian 8.X is returned. These instructions are not
# expected to work on any other version or distribution.
cd ~
wget http://ftp.embeddedTS.com/ftp/ts-arm-sbc/ts-7553-V2-linux/cross-toolchains/gcc-linaro-4.9-2016.02-x86_64_arm-linux-gnueabihf.tar.xz
# The above toolchain is from Linaro. Other cross compilers can be used but have not been tested.
mkdir cross_compiler
tar xvf gcc-linaro-4.9-2016.02-x86_64_arm-linux-gnueabihf.tar.xz -C ~/cross_compiler
export PATH=$PATH:~/cross_compiler/gcc-linaro-4.9-2016.02-x86_64_arm-linux-gnueabihf/bin/
# The 'export' command needs to be run every time the user logs in. It is possible to add this command to the user's ".bashrc" file
# in their home directory to ensure it is automatically run every time the user is logged in.
su root
dpkg --add-architecture armhf
apt-get update
apt-get install build-essential
This will install a toolchain that can be used with the prefix "arm-linux-gnueabihf-". The standard GCC tools will start with that name, eg "arm-linux-gnueabihf-gcc".
The toolchain can now compile a simple hello world application. Create hello-world.c on the Debian workstation:
#include <stdio.h>
int main(){
printf("Hello World\n");
}
To compile this:
arm-linux-gnueabihf-gcc hello-world.c -o hello-world
file hello-world
This will return that the binary created is for ARM. Copy this to the target platform to run it there.
Debian Jessie supports multiarch which can install packages designed for other architectures. On workstations this is how 32-bit and 64-bit support is provided. This can also be used to install armhf packages on an x86 based workstation.
This cross compile environment can link to a shared library from the Debian root. The package would be installed in Debian on the workstation to provide headers and ".so" files. This is included in most "-dev" packages. When run on the arm target it will also need a copy of the library installed, but it does not need the -dev package. Note that since the cross compiler used is 3rd party and not directly from Debian, some compile commands that include libraries will need additional arguments to tell the compiler and linker where on the workstation to find the necessary headers and libraries. Usually, the additional arguments will look like the following string, however adjustments may need to be made depending on the application.
-I/usr/include -L/usr/lib/arm-linux-gnueabihf -L/lib/arm-linux-gnueabihf -Wl,-rpath=/usr/lib/arm-linux-gnueabihf,-rpath=/lib/arm-linux-gnueabihf
apt-get install libcurl4-openssl-dev:armhf
# Download the simple.c example from curl:
wget https://raw.githubusercontent.com/bagder/curl/master/docs/examples/simple.c
# After installing the supporting library, curl will link as compiling on the unit.
arm-linux-gnueabihf-gcc -I/usr/include -L/usr/lib/arm-linux-gnueabihf -L/lib/arm-linux-gnueabihf -Wl,-rpath=/usr/lib/arm-linux-gnueabihf,-rpath=/lib/arm-linux-gnueabihf simple.c -o simple -lcurl
Copy the binary to the target platform and run on the target. This can be accomplished with network protocols like NFS, SCP, FTP, etc.
If any created binaries do not rely on hardware support like GPIO or CAN, they can be run using qemu.
# using the hello world example from before:
./hello-world
# Returns Exec format error
apt-get install qemu-user-static
./hello-world
Debian Installing New Software
Debian provides the apt-get system which allows management of pre-built applications. The apt tools require a network connection to the internet in order to automatically download and install new software. The update command will download a list of the current versions of pre-built packages.
Older Debian releases are moved to a different server to indicate it is no longer getting security updates. To download packages for these older distributions, edit /etc/apt/sources.list to only have the following lines:
Jessie:
deb http://archive.debian.org/debian/ jessie main deb-src http://archive.debian.org/debian/ jessie main
Wheezy:
deb http://archive.debian.org/debian/ wheezy main deb-src http://archive.debian.org/debian/ wheezy main
After modifying that file, be sure to update the package list:
apt-get update
A common example is installing Java runtime support for a system. Find the package name first with search, and then install it.
root@ts:~# apt-cache search openjdk
jvm-7-avian-jre - lightweight virtual machine using the OpenJDK class library
freemind - Java Program for creating and viewing Mindmaps
icedtea-7-plugin - web browser plugin based on OpenJDK and IcedTea to execute Java applets
default-jdk - Standard Java or Java compatible Development Kit
default-jdk-doc - Standard Java or Java compatible Development Kit (documentation)
default-jre - Standard Java or Java compatible Runtime
default-jre-headless - Standard Java or Java compatible Runtime (headless)
jtreg - Regression Test Harness for the OpenJDK platform
libreoffice - office productivity suite (metapackage)
icedtea-7-jre-jamvm - Alternative JVM for OpenJDK, using JamVM
openjdk-7-dbg - Java runtime based on OpenJDK (debugging symbols)
openjdk-7-demo - Java runtime based on OpenJDK (demos and examples)
openjdk-7-doc - OpenJDK Development Kit (JDK) documentation
openjdk-7-jdk - OpenJDK Development Kit (JDK)
openjdk-7-jre - OpenJDK Java runtime, using Hotspot Zero
openjdk-7-jre-headless - OpenJDK Java runtime, using Hotspot Zero (headless)
openjdk-7-jre-lib - OpenJDK Java runtime (architecture independent libraries)
openjdk-7-source - OpenJDK Development Kit (JDK) source files
uwsgi-app-integration-plugins - plugins for integration of uWSGI and application
uwsgi-plugin-jvm-openjdk-7 - Java plugin for uWSGI (OpenJDK 7)
uwsgi-plugin-jwsgi-openjdk-7 - JWSGI plugin for uWSGI (OpenJDK 7)
In this case you will want the openjdk-7-jre package. Names of packages are on Debian's wiki or the packages site.
With the package name apt-get install can be used to install the prebuilt packages.
apt-get install openjdk-7-jre
# More than one package can be installed at a time.
apt-get install openjdk-7-jre nano vim mplayer
For more information on using apt-get refer to Debian's documentation here.
Debian Setting up SSH
To install ssh, install the package as normal with apt-get:
apt-get install openssh-server
Make sure the device is configured on the network and set a password for the remote user. SSH will not allow remote connections without a password or a valid SSH key pair.
passwd root
| Note: | The default OpenSSH server will not permit root to login via SSH as a security precaution. To allow root to log in via ssh anyway, edit the /etc/ssh/sshd_config file and add the line PermitRootLogin yes in the authentication section. This change will take effect after reboot or after sshd service restart.
|
After this setup it is now possible to connect from a remote PC supporting SSH. On Linux/OS X this is the "ssh" command, or from Windows using a client such as PuTTY.
| Note: | If a DNS server is not present on the target network, it is possible to save time at login by adding "UseDNS no" in /etc/ssh/sshd_config. |
Debian Starting Automatically
A systemd service can be created to start up headless applications. Create a file in /etc/systemd/system/yourapp.service
[Unit]
Description=Run an application on startup
[Service]
Type=simple
ExecStart=/usr/local/bin/your_app_or_script
[Install]
WantedBy=multi-user.target
If networking is a dependency add "After=network.target" in the Unit section. Once you have this file in place add it to startup with:
# Start the app on startup, but will not start it now
systemctl enable yourapp.service
# Start the app now, but doesn't change auto startup
systemctl start yourapp.service
| Note: | See the systemd documentation for in depth documentation on services. |
To start an application on bootup with X11 instead change the x-session-manager. By default the system starts xfce:
root@ts:~# ls -lah /usr/bin/x-session-manager
lrwxrwxrwx 1 root root 35 May 26 2015 /usr/bin/x-session-manager -> /etc/alternatives/x-session-manager
root@ts:~# ls -lah /etc/alternatives/x-session-manager
lrwxrwxrwx 1 root root 19 May 26 2015 /etc/alternatives/x-session-manager -> /usr/bin/startxfce4
The x-session can be modified to only start specified processes. Create the file /usr/bin/mini-x-session with these contents:
#!/bin/bash
matchbox-window-manager -use_titlebar no &
exec xfce4-terminal
You may need to "apt-get install matchbox-window-manager." first. This is a tiny window manager which also has a few flags that simplify embedded use. Now enable this session manager and restart slim to restart x11 and show it now.
chmod a+x /usr/bin/mini-x-session
rm /etc/alternatives/x-session-manager
ln -s /usr/bin/mini-x-session /etc/alternatives/x-session-manager
service slim restart
If the x-session-manager process ever closes x11 will restart. The exec command allows a new process to take over the existing PID. In the above example xfce4-terminal takes over the PID of x-session-manager. If the terminal is closed with commands like exit the slim/x11 processes will restart.
Backup / Restore
MicroSD Card
These instructions assume you have an SD card with one partition. Most SD cards ship this way by default. If the card has had its partition table modified this can be corrected with a tool like 'gparted' or 'fdisk'.
Plug the SD card into a USB reader and connect it to a linux workstation PC. Newer distributions include a utility called 'lsblk' which lists all block devices like a USB SD card reader:
lsblk
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT sdY 8:0 0 400G 0 disk ├─sdY1 8:1 0 398G 0 part / ├─sdY2 8:2 0 1K 0 part └─sdY5 8:5 0 2G 0 part [SWAP] sr0 11:0 1 1024M 0 rom sdX 8:32 1 3.9G 0 disk ├─sdX1 8:33 1 7.9M 0 part ├─sdX2 8:34 1 2M 0 part ├─sdX3 8:35 1 2M 0 part └─sdX4 8:36 1 3.8G 0 part
In this case the SD card is 4GB, so sdX is the target device. Note that on your system, sdX will not be a real device, it could be sda, sdb, mmcblk0, etc. Technologic Systems is not responsible for any damages cause by using the improper device node for imaging an SD card.
After plugging in the device after Linux has booted you can use dmesg to print out the kernel log. When the USB drive is added it will append to the end of that file. Try running:
dmesg | tail -n 100
scsi 54:0:0:0: Direct-Access Generic Storage Device 0.00 PQ: 0 ANSI: 2 sd 54:0:0:0: Attached scsi generic sg2 type 0 sd 54:0:0:0: [sdX] 3862528 512-byte logical blocks: (3.97 GB/3.84 GiB)
In this case, sdXc is shown as a 3.97GB card. Note that on your system, sdX will not be a real device, it could be sda, sdb, mmcblk0, etc. Technologic Systems is not responsible for any damages cause by using the improper device node for imaging an SD card.
The following commands will reformat the first partition of the SD card, and unpack the latest filesystem on there:
# Verify nothing else has this mounted
sudo umount /dev/sdX1
sudo mkfs.ext3 /dev/sdX1
sudo mkdir /mnt/sd
sudo mount /dev/sdX1 /mnt/sd/
wget ftp://ftp.embeddedTS.com/ts-arm-sbc/ts-7990-linux/distributions/yocto/morty/ts-x11-image-tsimx6-latest.rootfs.tar.bz2
sudo tar -xf ts-x11-image-tsimx6-latest.rootfs.tar.bz2 -C /mnt/sd
sudo umount /mnt/sd
sync
| Note: | The ext4 filesystem can be used instead of ext3, but it may require additional options. U-Boot does not support the 64bit addressing added as the default behavior in recent revisions of mkfs.ext4. If using e2fsprogs 1.43 or newer, the options "-O ^64bit,^metadata_csum" must be used with ext4 for proper compatibility. Older versions of e2fsprogs do not need these options passed nor are they needed for ext3. |
Once written, the files on disk can be verified to ensure they are the same as the source files in the archive. Reinsert the disk to flush the block cache completely, then run the following commands:
mount /dev/sdX1 /mnt/sd
cd /mnt/sd/
sudo md5sum --quiet -c md5sums.txt
cd -
umount /mnt/sd
sync
The md5sum command will report what differences there are, if any, and return if it passed or failed.
eMMC
Pick the latest image to restore to here:
The simplest way to backup/restore the eMMC is through u-boot. If you boot up with JP2 connected and stop in u-boot you can run this command:
ums 0 mmc 1
Now plug in the P1 USB port and this will make the board act as a USB mass storage device with direct access to the eMMC disk. On a linux workstation, to backup the image:
dmesg | tail -n 30
# Look for the last /dev/sd* device connected. This should also match the eMMC
# size of around 3.78GiB. On my system, this is /dev/sdd.
sudo mkdir /mnt/emmc/
sudo mount /dev/mmcblk1p1 /mnt/emmc/
cd /mnt/emmc/
sudo tar -cjf /path/to/ts-backup-image.tar.bz2 .
cd ../
sudo umount /mnt/emmc/
sync
To write a new filesystem:
dmesg | tail -n 30
# Look for the last /dev/sd* device connected. This should also match the eMMC
# size of around 3.78GiB. On my system, this is /dev/sdd.
sudo mkdir /mnt/emmc/
sudo mkfs.ext3 /dev/mmcblk1p1
# If the above command fails, use fdisk or gparted to repartition the emmc
# to have one large partition.
sudo mount /dev/mmcblk1p1 /mnt/emmc/
sudo tar -xjf /path/to/ts-new-image.tar.bz2 -C /mnt/emmc
sudo umount /mnt/emmc/
sync
Note that this interface is limited to about 1MB/s. You can write the eMMC disk faster by booting to SD with access to the image and using the native SD linux install to rewrite eMMC.
Compile the Kernel
To add additional driver support, reduce the size of our stock kernel kernel, or to write custom kernel drivers the kernel can be compiled from our sources. The following steps walk through the kernel build process; they are compatible with most of our Linux distributions.
This device has multiple kernels released and available in our git repository:
Newer kernels are released on the linux-tsimx repository:
- embeddedTS/linux-tsimx
- The "ts-imx_4.9.11_1.0.0_ga" branch is the only one that should be used with our i.MX6 series.
For legacy kernels:
- embeddedTS/linux-3.10.17-imx6
- The "master" branch is 3.10.17 and is largely outdated and replaced with later kernels. This is used with the old Yocto Dora builds.
- The "imx_3.10.53_1.1.0_ga" kernel is a stable branch. Use this with Yocto Dizzy, Fido, or compatible with Debian Jessie.
- The "imx_3.14.52_1.1.0_ga" branch is compatible with Yocto Jethro, and Debian.
- The "imx_4.1.15_1.0.0_ga" branch is compatible with Yocto Jethro, Yocto Morty and Debian. Includes recent fixes not in older branches. This is recommended for most users.
The kernel can be rebuilt by cross compiling from an x86 or x86_64 Linux workstation. Our stock kernels are built with the toolchains built by Yocto. The appropriate cross toolchain for your Linux workstation can be downloaded here:
| Note: | Older kernels will require older toolchains. For older Yocto kernels use a matching Yocto toolchain. For Debian, the latest toolchain and kernel is recommended. |
chmod a+x poky*.sh
sudo ./poky*.sh
This will ask for the install directory for the toolchain. A custom location can be chosen, however the following instructions will assume the default installation location.
This process will also require several applications for the install/build process. These can be installed on an Ubuntu/Debian workstation with the following command:
sudo apt-get install git build-essential lzop u-boot-tools libncursesw5-dev fakeroot bc
Once those are installed:
git clone https://github.com/embeddedTS/linux-tsimx.git -b ts-imx_4.9.11_1.0.0_ga linux-tsimx6 --depth 1
# For legacy kernels instead:
# git clone https://github.com/embeddedTS/linux-3.10.17-imx6.git -b imx_4.1.15_1.0.0_ga linux-tsimx6 --depth 1
# If it is already cloned, the "git pull" command will download and merge the latest changes
# For WiFi support, download qcacld-2.0:
# This is only compatible with 4.1.15 or 4.9.11 kernels
git clone https://github.com/embeddedTS/qcacld-2.0.git -b caf-wlan/CNSS.LEA.NRT_3.1
cd linux-tsimx6
# These export commands must be run every time before any make commands
export ARCH=arm
# For 64-bit
export CROSS_COMPILE=/opt/poky/2.2.2/sysroots/x86_64-pokysdk-linux/usr/bin/arm-poky-linux-gnueabi/arm-poky-linux-gnueabi-
# For 32-bit
#export CROSS_COMPILE=/opt/poky/2.2.2/sysroots/i686-pokysdk-linux/usr/bin/arm-poky-linux-gnueabi/arm-poky-linux-gnueabi-
export LOADADDR=0x10008000
export TEMPDIR=$(mktemp -d)
make ts4900_defconfig
## Make any changes in "make menuconfig" or driver modifications, then compile
make -j8 all uImage zImage
mkdir "$TEMPDIR"/boot/
cp arch/arm/boot/uImage "$TEMPDIR"/boot/uImage
cp arch/arm/boot/zImage "$TEMPDIR"/boot/zImage
cp arch/arm/boot/dts/imx6*-ts*.dtb "$TEMPDIR"/boot/
INSTALL_MOD_PATH="$TEMPDIR" make modules_install
make headers_install INSTALL_HDR_PATH="$TEMPDIR"
# Compile wifi driver:
cd ../qcacld-2.0/
export KERNEL_SRC="../linux-tsimx6/"
make clean
CONFIG_CLD_HL_SDIO_CORE=y make -j8
INSTALL_MOD_PATH="$TEMPDIR" make modules_install
fakeroot sh -c "chmod 755 $TEMPDIR;
chown -R root:root $TEMPDIR;
tar cjvf kernel.tar.bz2 -C $TEMPDIR .;
rm -rvf $TEMPDIR"
This will generate "kernel.tar.bz2" which contains the kernel and necessary modules. It can be installed to the device by copying it to a running unit and executing:
# Only run this on a device! Not on a workstation!
tar -xf kernel.tar.bz2 -C /
This can also be extracted over existing images from a workstation, or removable media like SD cards. For example, assuming the SD card on a workstation is "/dev/sdc":
mkdir /mnt/sd/
mount /dev/sdc1 /mnt/sd/
tar -xf kernel.tar.bz2 -C /mnt/sd/
umount /mnt/sd/
Change Kernel Splash Screen
The TS-7990 uses two splash screens. By default they display the same image. U-Boot draws the very first splash screen, and the kernel the second. U-Boot's is only present for about a second while the kernel, device tree, and optionally the FPGA are loaded. The U-Boot splash can be disabled allowing only the kernel's splash screen to show up during boot. This change can be made with:
# This tells the splash command to just run "true" which returns immediately instead of
# drawing a splash screen
env set splash true
env save
To use a custom logo or splash screen in U-Boot, convert the file to a .bmp, and compress it with gz. The logo should be as small and simple as possible to compress well and load fast.
The imagemagick tool can be used on a host system to convert to the correct format.
convert yoursplash.png -colors 256 -depth 8 -compress none splash.bmp3
gzip splash.bmp3
# Write to SPI flash
dd if=splash.bmp3.gz of=/dev/mtdblock0 bs=1024 seek=2048
This is provided in U-Boot primarily for applications that may want to give some feedback to the user. For example, a developer may want to use this U-Boot splash as failed to boot screen or to show the user a message while updating from custom U-Boot scripts. In the default configuration when booting off of eMMC or SD the splash screen from U-Boot will only be shown for about 1-3 seconds until the OS kernel is started.
After U-Boot runs, the Linux kernel is typically started which will set up the clock tree and reinitialize hardware. It is not possible for the U-Boot splash to persist through this, but the kernel can redraw the splash a second later which will appear as a short flicker.
The kernel splash screen allows 224 colors. It also allows up to the full screen resolution, but for fastest boot speed it should be kept as small as possible. The image will be centered around a black background.
To convert an image to be compatible with the Linux splash screen, for example, "mylogo.png":
convert mylogo.png mylogo.ppm
ppmquant 224 mylogo.ppm > mylogo-224.ppm
pnmnoraw mylogo-224.ppm > logo_user_clut224.ppm
cp logo_user_clut224.ppm <kernel build sources>/drivers/video/logo/
In order for this to take effect on boot, the kernel must be re-compiled.
As another option the Linux kernel logo can be disabled completely with "logo.nologo" in the kernel cmdline.
Features
Bluetooth
The WIFI option on the board also includes a bluetooth 4.0 LE module. This is supported in Linux using the Bluez stack.
# First bring up wifi. This loads the firwmare for
# both WIFI and Bluetooth
modprobe wilc3000
ifconfig wlan0 up
# WIFI can optionally be brought back down
# ifconfig wlan0 down
hciattach /dev/ttymxc1 any 115200 noflow
hciconfig hci0 up
hcitool cmd 0x3F 0x0053 00 10 0E 00 01
stty -F /dev/ttymxc1 921600 crtscts
# If your board is REV A use this setup instead:
echo 237 > /sys/class/gpio/export
echo low > /sys/class/gpio/gpio237/direction
echo high > /sys/class/gpio/gpio237/direction
sleep .1
hciattach /dev/ttymxc1 texas 3000000
hciconfig hci0 up
Now you may scan for available devices with:
hcitool scan
This will return a list of devices such as:
14:74:11:AB:12:34 SAMSUNG-SM-G900A
You may request more information from a detected device like so:
hcitool info 14:74:11:AB:12:34
This will produce lots of details about the device, for example:
Requesting information ...
BD Address: 14:74:11:AB:12:34
OUI Company: Samsung Electronics Co.,Ltd (4C-A5-6D)
Device Name: SAMSUNG-SM-G900A
LMP Version: 4.1 (0x7) LMP Subversion: 0x610c
Manufacturer: Broadcom Corporation (15)
Features page 0: 0xbf 0xfe 0xcf 0xfe 0xdb 0xff 0x7b 0x87
.
.
.
Bluez has support for many different profiles for HID, A2DP, and many more. Refer to the Bluez documentation for more information.
CAN
The TS-7990 CAN bus is located on COM2 and COM3 headers. A jumper can be shorted between DIO header pins 21/22 to add 120ohm termination to the can0 on the COM3 header. The CAN bus on COM2 always has 120ohm termination present.
The i.MX6 includes 2 CAN controllers which support the SocketCAN interface. Before proceeding with the examples, see the Kernel's CAN documentation here.
This board comes preinstalled with can-utils. These can be used to communicate over a CAN network without writing any code. The candump utility can be used to dump all data on the network
## First, set the baud rate and bring up the device:
ip link set can0 type can bitrate 250000
ip link set can0 up
## Dump data & errors:
candump can0 &
## Send the packet with:
#can_id = 0x7df
#data 0 = 0x3
#data 1 = 0x1
#data 2 = 0x0c
cansend can0 -i 0x7Df 0x3 0x1 0x0c
## Some versions of cansend use a different syntax. If the above
## commands gives an error, try this instead:
#cansend can0 7DF#03010C
The above example packet is designed to work with the Ozen Elektronik myOByDic 1610 ECU simulator to read the RPM speed. In this case, the ECU simulator would return data from candump with:
<0x7e8> [8] 04 41 0c 60 40 00 00 00 <0x7e9> [8] 04 41 0c 60 40 00 00 00
In the output above, columns 6 and 7 are the current RPM value. This shows a simple way to prove out the communication before moving to another language.
The following example sends the same packet and parses the same response in C:
#include <stdio.h>
#include <pthread.h>
#include <net/if.h>
#include <string.h>
#include <unistd.h>
#include <net/if.h>
#include <sys/ioctl.h>
#include <assert.h>
#include <linux/can.h>
#include <linux/can/raw.h>
int main(void)
{
int s;
int nbytes;
struct sockaddr_can addr;
struct can_frame frame;
struct ifreq ifr;
struct iovec iov;
struct msghdr msg;
char ctrlmsg[CMSG_SPACE(sizeof(struct timeval)) + CMSG_SPACE(sizeof(__u32))];
char *ifname = "can0";
if((s = socket(PF_CAN, SOCK_RAW, CAN_RAW)) < 0) {
perror("Error while opening socket");
return -1;
}
strcpy(ifr.ifr_name, ifname);
ioctl(s, SIOCGIFINDEX, &ifr);
addr.can_family = AF_CAN;
addr.can_ifindex = ifr.ifr_ifindex;
if(bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
perror("socket");
return -2;
}
/* For the ozen myOByDic 1610 this requests the RPM guage */
frame.can_id = 0x7df;
frame.can_dlc = 3;
frame.data[0] = 3;
frame.data[1] = 1;
frame.data[2] = 0x0c;
nbytes = write(s, &frame, sizeof(struct can_frame));
if(nbytes < 0) {
perror("write");
return -3;
}
iov.iov_base = &frame;
msg.msg_name = &addr;
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = &ctrlmsg;
iov.iov_len = sizeof(frame);
msg.msg_namelen = sizeof(struct sockaddr_can);
msg.msg_controllen = sizeof(ctrlmsg);
msg.msg_flags = 0;
do {
nbytes = recvmsg(s, &msg, 0);
if (nbytes < 0) {
perror("read");
return -4;
}
if (nbytes < (int)sizeof(struct can_frame)) {
fprintf(stderr, "read: incomplete CAN frame\n");
}
} while(nbytes == 0);
if(frame.data[0] == 0x4)
printf("RPM at %d of 255\n", frame.data[3]);
return 0;
}
See the Kernel's CAN documentation here. Other languages have bindings to access CAN such as Python, Java using JNI.
In production use of CAN we also recommend setting a restart-ms for each active CAN port.
ip link set can0 type can restart-ms 100
This allows the CAN bus to automatically recover in the event of a bus-off condition.
COM Ports
All of these UARTs are accessed using the standard /dev/ interfaces. See these resources for information on programming with UARTs in Linux.
All of the CPU uarts go through the FPGA Crossbar to select where UARTs are routed, or to bring out flow control instead of UARTs. These mappings can be chagned by adjusting the crossbar, but these are the default mappings:
| Name | Mux output | Mux input | Def. Assign. | Def. Type | Def. TX / + | Def. RX / - |
|---|
CPU
The i.MX6 is an armv7a Cortex-A9 by NXP. The CPU itself is available in 792MHz, 996MHz, and 1.2GHz with a solo, dual, or quad core processor.
Refer to NXP's documentation for in depth documentation on these CPU cores:
eMMC
This board includes a Micron eMMC. Our default builds are 4 GiB, but up to 64 GiB devices are available for custom builds. The eMMC flash appears to Linux as an SD card at /dev/mmcblk2. Our default programming will include one partition programmed with our Yocto image.
The eMMC devices are like SD cards in that they should not be powered down during a write/erase cycle. This eMMC device includes support for setting a fuse for a "Write Reliability" mode, and a "psuedo SLC" mode. When both of these are enabled all writes will be atomic to 512 B. If a sector is being written during a power loss, a block is guaranteed to have either the old or new data. This scheme is far more resilient to power loss than more traditional flash media. In cases of old 512 B data, fsck will likely be able to recover a mountable filesystem. In cases where the corrupted file is a database it may still require a separate mechanism for recovery.
When the pSLC mode is turned on it will reduce the available space to under half, and reduce the write speed.
See our post on preventing filesystem corruption.
The mmc-utils package is used to enable these modes. First determine the exact size of the flash you're using:
mmc extcsd read /dev/mmcblk2 | grep MAX_ENH_SIZE_MULT -A 1
Max Enhanced Area Size [MAX_ENH_SIZE_MULT]: 0x0001cd i.e. 1888256 KiB
So in this case, 1888256 KiB is the max size of the enhanced partition. This number should be used for the enh_area command:
mmc write_reliability set -n 0 /dev/mmcblk2
mmc enh_area set -y 0 1888256 /dev/mmcblk2
| WARNING: | Setting either of those modes is permanent. Using the wrong value it is possible to brick eMMC which will not be covered by the warranty. Evaluation units with fuses set will not be accepted through returns. |
After this is run, reboot the whole unit. On all future boots the eMMC will be detected at the smaller size. Changing the enhanced area will erase the drive. After these mmc commands the disk will need to be rewritten.
Ethernet Port
The i.MX6 includes a 10/100/1000 Ethernet (near the speaker). In Linux this is the eth0 interface. The MAC address uses the technologic systems 00:d0:69:00:00:00, and the last 3 octets are assigned from our pool. The MAC address is burned into the CPU's fuses during production, and will be read back automatically by software in Linux or U-Boot. Freescale has a published erratum regarding the maximum Ethernet speed. The default kernel can achieve about 400 Mb/s.
The second Ethernet 10/100 port (near USB) is an SMSC/LAN9514 USB ethernet. This is also assigned a MAC address of eth0+1.
FPGA
The Lattice MachXO2 FPGA provides auto TX enable for RS-485 half duplex, additional DIO, a crossbar MUX, and it can generate four preset clocks. Most of these registers are controlled using the 'tshwctl' utility. The source for 'tshwctl' and other utilities we provide can be found in the ts4900-utils repository. The DIO can be manipulated using the sysfs GPIO interface. See the GPIO section for more information on the recommended GPIO access patterns.
Usage: tshwctl [OPTIONS] ...
Technologic Systems i.mx6 FPGA Utility
-m, --addr <address> Sets up the address for a peek/poke
-v, --poke <value> Writes the value to the specified address
-t, --peek Reads from the specified address
-i, --mode <8n1> Used with -a, sets mode like '8n1', '7e2', etc
-x, --baud <speed> Used with -a, sets baud rate for auto485
-a, --autotxen <uart> Enables autotxen for supported CPU UARTs
Uses baud/mode if set or reads the current
configuration of that uart
-c, --dump Prints out the crossbar configuration
-g, --get Print crossbar for use in eval
-s, --set Read environment for crossbar changes
-q, --showall Print all possible FPGA inputs and outputs.
-h, --help This message
The GPIO registers below include a crossbar, output enable, and data bit. The crossbar selects between GPIO and all other modes described in the FPGA Crossbar table. When a pin MUX is set to GPIO, bit 0 is used as an output enable and bit 1 is used as a value. When bit 0 is set to 0 (output disabled), bit 1 reflects the input value. When bit 0 is set to 1 (output enabled), bit 1 reflects the value that will be output on the pin.
| Addr | Bits | Function |
|---|---|---|
| 00 | 7:2 | TTYMXC2_RXD Crossbar |
| 1 | TTYMXC2_RXD Output Data | |
| 0 | Reserved (Output only) | |
| 01 | 7:2 | TTYMXC4_RXD Crossbar |
| 1 | TTYMXC4_RXD Output Data | |
| 0 | Reserved (Output only) | |
| 02 | 7:2 | TTYMXC2_CTS Crossbar |
| 1 | TTYMXC2_CTS Data | |
| 0 | TTYMXC2_CTS Output Enable | |
| 03 | 7:2 | TTYMXC3_RXD Crossbar |
| 1 | TTYMXC3_RXD Output Data | |
| 0 | Reserved (Output Only) | |
| 04 | 7:2 | TTYMXC1_CTS Crossbar |
| 1 | TTYMXC1_CTS Output Data | |
| 0 | Reserved (Output Only) | |
| 05 | 7:2 | TTYMXC2_RTS Crossbar |
| 1 | TTYMXC2_RTS Data | |
| 0 | TTYMXC2_RTS Output Enable | |
| 06 | 7:2 | DIO_8 Crossbar |
| 1 | DIO_8 Data | |
| 0 | DIO_8 Output Enable | |
| 07 | 7:2 | DIO_9 Crossbar |
| 1 | DIO_9 Data | |
| 0 | DIO_9 Output Enable | |
| 08 | 7:2 | TXD1_485 Crossbar |
| 1 | TXD1_485 Output Data | |
| 0 | Reserved (Output Only) | |
| 09 | 7:2 | TXD2_485 Crossbar |
| 1 | TXD2_485 Output Data | |
| 0 | Reserved (Output Only) | |
| 10 | 7:2 | TXD3_485 Crossbar |
| 1 | TXD3_485 Output Data | |
| 0 | Reserved (Output Only) | |
| 11 | 7:2 | TXEN1_485 (ttymxc1) Crossbar |
| 1 | TXEN1_485 (ttymxc1) Output Data | |
| 0 | Reserved (Output Only) | |
| 12 | 7:2 | TXEN2_485 (ttymxc3) Crossbar |
| 1 | TXEN2_485 (ttymxc3) Output Data | |
| 0 | Reserved (Output Only) | |
| 13 | 7:2 | Reserved |
| 1 | WIFI_RESET# Output data | |
| 0 | Reserved | |
| 14 | 7:2 | Reserved |
| 1 | EN_WIFI_PWR Output data | |
| 0 | Reserved | |
| 15 | 7:2 | BT_RTS Crossbar |
| 1 | BT_RTS Data | |
| 0 | BT_RTS Output Enable | |
| 16 | 7:2 | BT_CTS Crossbar |
| 1 | BT_CTS Data | |
| 0 | BT_CTS Output Enable | |
| 17 | 7:2 | BT_TXD Crossbar |
| 1 | BT_TXD Output Data | |
| 0 | Reserved (Output Only) | |
| 18 | 7:2 | TTYMXC1_RXD Crossbar |
| 1 | Reserved | |
| 0 | Reserved (Output Only) | |
| 19 | 7:2 | DIO_0 Crossbar |
| 1 | DIO_0 Data | |
| 0 | DIO_0 Output Enable | |
| 20 | 7:2 | DIO_1 Crossbar |
| 1 | DIO_1 Data | |
| 0 | DIO_1 Output Enable | |
| 21 | 7:2 | DIO_2 Crossbar |
| 1 | DIO_2 Data | |
| 0 | DIO_2 Output Enable | |
| 22 | 7:2 | DIO_3 Crossbar |
| 1 | DIO_3 Data | |
| 0 | DIO_3 Output Enable | |
| 23 | 7:2 | DIO_4 Crossbar |
| 1 | DIO_4 Data | |
| 0 | DIO_4 Output Enable | |
| 24 | 7:2 | DIO_5 Crossbar |
| 1 | DIO_5 Data | |
| 0 | DIO_5 Output Enable | |
| 25 | 7:2 | DIO_6 Crossbar |
| 1 | DIO_6 Data | |
| 0 | DIO_6 Output Enable | |
| 26 | 7:2 | DIO_7 Crossbar |
| 1 | DIO_7 Data | |
| 0 | DIO_7 Output Enable | |
| 27 | 7:2 | FPGA_IRQ_1 Crossbar Value |
| 1 | FGPA_IRQ_1 Output Data | |
| 0 | Reserved (Output Only) | |
| 28 | 7:0 | Reserved |
| 29 | 7:0 | Reserved |
| 30 | 7:2 | Reserved |
| 1 | Reboot (on 1) [1] | |
| 0 | Reserved | |
| 31 | 7:0 | Reserved |
| 32 | 7:0 | RS485_CNT0 [23:16] |
| 33 | 7:0 | RS485_CNT0 [15:8] |
| 34 | 7:0 | RS485_CNT0 [7:0] |
| 35 | 7:0 | RS485_CNT1 [23:16] |
| 36 | 7:0 | RS485_CNT1 [15:8] |
| 37 | 7:0 | RS485_CNT1 [7:0] |
| 38 | 7:0 | RS485_CNT2 [23:16] |
| 39 | 7:0 | RS485_CNT2 [15:8] |
| 40 | 7:0 | RS485_CNT2 [7:0] |
| 41 | 7:0 | RS485_CNT3 [23:16] |
| 42 | 7:0 | RS485_CNT3 [15:8] |
| 43 | 7:0 | RS485_CNT3 [7:0] |
| 44 | 7:2 | TTYMAX0_RXD Crossbar |
| 1 | TTYMAX0_RXD Output Data | |
| 0 | Reserved (Output Only) | |
| 45 | 7:2 | TTYMAX1_RXD Crossbar |
| 1 | TTYMAX1_RXD Output Data | |
| 0 | Reserved (Output Only) | |
| 46 | 7:2 | TTYMAX2_RXD Crossbar |
| 1 | TTYMAX2_RXD Output Data | |
| 0 | Reserved (Output Only) | |
| 47 | 7:2 | TXEN3_485 Crossbar |
| 1 | TXEN3_485 Output Data | |
| 0 | Reserved (Output Only) | |
| 48 | 7:2 | COM1_TXD_232_3V Crossbar |
| 1 | COM1_TXD_232_3V | |
| 0 | Reserved (Output Only) | |
| 49 | 7:2 | COM2_TXD_232_3V Crossbar |
| 1 | COM2_TXD_232_3V Output Data | |
| 0 | Reserved (Output Only) | |
| 50 | 7:2 | COM3_TXD_232_3V Crossbar |
| 1 | COM3_TXD_232_3V Output Data | |
| 0 | Reserved (Output Only) | |
| 51 | 7:4 | FPGA Revision |
| 3 | P13 Input Value | |
| 2 | L14 Input Value | |
| 1 | G12 Input Value | |
| 0 | H12 Input Value | |
| 52 | 7:2 | COM1_RTS_3V Crossbar |
| 1 | COM1_RTS_3V Output Data | |
| 0 | Reserved (Output Only) | |
| 53 | 7:2 | TTYMAX0_CTS Crossbar |
| 1 | TTYMAX0_CTS Output Data | |
| 0 | Reserved (Output Only) | |
| 54 | 7:2 | TTYMAX1_CTS Crossbar |
| 1 | TTYMAX1_CTS Output Data | |
| 0 | Reserved (Output Only) | |
| 55 | 7:2 | TTYMAX2_CTS Crossbar |
| 1 | TTYMAX2_CTS Output Data | |
| 0 | Reserved (Output Only) | |
| 56 | 7:0 | DIO 7:0 Input Data |
| 57 | 7:5 | Reserved |
| 4 | LXD_PRESENT | |
| 3 | OKAYA_PRESENT | |
| 2:1 | DIO 9:8 Input Data | |
| 0 | CN99_BOOT_SEL_PAD [2] | |
| 58 | 7:2 | Reserved |
| 1 | XBEE Power Enable (1 = on) | |
| 0 | XBEE Power select (3.3V = 0, 4V = 1) [3] | |
| 59 | 7:6 | Reserved |
| 5 | XBEE_RESET# | |
| 4 | EN_LCD_POWER | |
| 3 | LCD_RESET# | |
| 2 | EN_LCD_11V# | |
| 1 | EN_LCD_NEG_7V | |
| 0 | EN_LCD_20V | |
| 60 | 7:2 | Reserved |
| 1 | MT_LCD_PRESENT | |
| 0 | Reserved | |
| 61 | 7:2 | Reserved |
| 1 | EN_SPKR Output Data | |
| 0 | Reserved | |
| 62 | 7:2 | XBEE_TXD Crossbar |
| 1 | XBEE_TXD Output Data | |
| 0 | Reserved (Output Only) |
FPGA Crossbar
The FPGA crossbar allows almost any of the FPGA pins to be rerouted. All of the FPGA registers that have a crossbar mux value can be written with these values to change the output value. When using the crossbar pins that are outputs, bit 1 should also be set to allow output enables.
| Crossbar Value | Selected Function |
|---|---|
| 0 | Do not change |
| 1 | BT_RTS |
| 2 | BT_RXD |
| 3 | TTYMXC4_TXD |
| 4 | TTYMXC2_TXD |
| 5 | TTYMXC2_CTS |
| 6 | TTYMXC1_RTS |
| 7 | TTYMXC2_RTS |
| 8 | RXD1_485_3V |
| 9 | RXD2_485_3V |
| 10 | RXD3_485_3V |
| 11 | COM1_RXD_232_3V |
| 12 | COM2_RXD_232_3V |
| 13 | COM3_RXD_232_3V |
| 14 | TTYMXC3_TXD |
| 15 | TTYMXC1_TXD |
| 16 | TTYMAX0_TXD |
| 17 | TTYMAX0_TXEN |
| 18 | TTYMAX0_RTS |
| 19 | TTYMAX1_TXD |
| 20 | TTYMAX1_TXEN |
| 21 | TTYMAX1_RTS |
| 22 | TTYMAX2_TXD |
| 23 | TTYMAX2_TXEN |
| 24 | TTYMAX2_RTS |
| 25 | TTYMXC1_TXEN |
| 26 | TTYMXC3_TXEN |
| 27 | CLK_12MHZ |
| 28 | CLK_14MHZ |
| 29 | FPGA_24MHZ_CLK |
| 30 | CLK_28MHZ |
| 31 | GPIO [1] |
| 32 | DIO_0 |
| 33 | DIO_1 |
| 34 | DIO_2 |
| 35 | DIO_3 |
| 36 | DIO_4 |
| 37 | DIO_5 |
| 38 | DIO_6 |
| 39 | DIO_7 |
| 40 | DIO_8 |
| 41 | DIO_9 |
| 42 | XBEE_RXD |
- ↑ This mode enables the use of the GPIO bits in the register, Data and Output Enable
For example, we can remap three ttyMAX ports to the HD1 GPIO.
| Pin | Function |
|---|---|
| HD1_DIO_1 | ttyMAX0 txd |
| HD1_DIO_2 | ttyMAX0 rxd |
| HD1_DIO_3 | ttyMAX1 txd |
| HD1_DIO_4 | ttyMAX1 rxd |
| HD1_DIO_5 | ttyMAX2 txd |
| HD1_DIO_6 | ttyMAX2 rxd |
tshwctl --dump
This will return the mapping of all of the pins as they are currently set. These are the relevant pins:
FPGA Pad (DIR) (VAL) FPGA Output
MB_TXD ( in) ( 0) TTYMAX1_TXD
STC_TXD_485 ( in) ( 0) TTYMAX0_TXD
RTS_232_COM ( in) ( 0) TTYMAX2_TXD
HD1_DIO_1 ( in) ( 0) GPIO
HD1_DIO_2 ( in) ( 0) GPIO
HD1_DIO_3 ( in) ( 0) GPIO
HD1_DIO_4 ( in) ( 0) GPIO
HD1_DIO_5 ( in) ( 0) GPIO
HD1_DIO_6 ( in) ( 0) GPIO
TTYMAX0_RXD ( in) ( 0) STC_RXD_485_3V
TTYMAX1_RXD ( in) ( 0) MB_RXD_485
TTYMAX2_RXD ( in) ( 0) CTS_232_COM
...
The tshwctl tool uses the bash environment to set/get pin status. To remap these pins:
eval $(tshwctl --get)
export HD1_DIO_1=TTYMAX0_TXD
export HD1_DIO_3=TTYMAX1_TXD
export HD1_DIO_5=TTYMAX2_TXD
export TTYMAX0_RXD=HD1_DIO_2
export TTYMAX1_RXD=HD1_DIO_4
export TTYMAX2_RXD=HD1_DIO_6
# These last 3 aren't required, but this will disable ttyMAX pins on
# their default locations. Without this, writes to /dev/ttyMAX0
# would go to both STC_TXD_485 and to HD1_DIO_1.
export MB_TXD=GPIO
export STC_TXD_485=GPIO
export RTS_232_COM=GPIO
# This will read the environment and look for the PAD names
# for any changes and apply them.
tshwctl --set
# The TTY_MAX*_TXD lines will only output data
# if they pins are outputs, so set these pins
echo 243 > /sys/class/gpio/export # HD1_DIO_1
echo high > /sys/class/gpio/gpio243/direction
echo 245 > /sys/class/gpio/export # HD1_DIO_3
echo high > /sys/class/gpio/gpio245/direction
echo 247 > /sys/class/gpio/export # HD1_DIO_5
echo high > /sys/class/gpio/gpio247/direction
GPIO
The i.MX6 and FPGA GPIO are accessed using the kernel's sysfs GPIO interface. See the kernel's documentation here for more detail. This interface provides a set of files and directories for interacting with GPIO which can be used from any language that can write files.
To interact with a pin, first export it to userspace:
echo "48" > /sys/class/gpio/export
If you receive a permission denied on a pin that means it is claimed by another kernel driver. In this case, you can "cat /sys/kernel/debug/gpio" to see what driver has claimed it. If it succeeds you will have a /sys/class/gpio/gpio48/ directory. The relevant files in this directory are:
direction - "in", "out" (out = low), "low", "high" value - write "1" or "0", or read "1" or "0" if direction is in edge - write with "rising", "falling", or "none"
With direction you can set it as an output and set the direction at the same time with high/low. If you just specify out this is the same as low.
# Set as a low output
echo "out" > /sys/class/gpio/gpio48/direction
# Set GPIO 48 high
echo "1" > /sys/class/gpio/gpio48/value
# Set GPIO 48 low
echo "0" > /sys/class/gpio/gpio48/value
# Read the value of GPIO 48
echo "in" > /sys/class/gpio/gpio48/direction
cat /sys/class/gpio/gpio48/value
# You can set it as a high output by setting the direction:
echo "high" > /sys/class/gpio/gpio48/direction
As an output, the in can be written to 0 for low (GND), or 1 for high (3.3V). The GPIO pins directly off of the i.MX6 processor support an absolute maximum of -0.5 to 3.6V. It is also possible to use any processor GPIO as an interrupt by writing the edge value, and then using select() or poll() on the value file for changes.
Interrupts
The i.MX6 CPU GPIO are also able to function as interrupts on rising and falling edges. This is accessible from the kernel as well as userspace. Userspace IRQs are exposed through the sysfs gpio mechanism. This example will trigger on a falling edge for GPIO 48:
echo "48" > /sys/class/gpio/export
echo "in" > /sys/class/gpio/gpio48/direction
echo "falling" > /sys/class/gpio/gpio48/edge
From here, an application can poll() or select() on the "/sys/class/gpio/gpio48/value" file and will return when the edge setting has been triggered:
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/select.h>
#include <sys/stat.h>
#include <unistd.h>
int main(int argc, char **argv)
{
char gpio_irq[64];
int ret, irqfd = 0, i = 0;
fd_set fds;
FD_ZERO(&fds);
int buf;
if(argc < 2) {
printf("Usage: %s <gpio number>\n", argv[0]);
return 1;
}
snprintf(gpio_irq, sizeof(gpio_irq), "/sys/class/gpio/gpio%d/value", atoi(argv[1]));
irqfd = open(gpio_irq, O_RDONLY, S_IREAD);
if(irqfd == -1) {
printf("Could not open IRQ %s\n", argv[1]);
printf("Make sure the GPIO is already exported", argv[1]);
return 1;
}
// Read first since there is always an initial status
ret = read(irqfd, &buf, sizeof(buf));
while(1) {
FD_SET(irqfd, &fds);
// See if the IRQ has any data available to read
ret = select(irqfd + 1, NULL, NULL, &fds, NULL);
if(FD_ISSET(irqfd, &fds))
{
FD_CLR(irqfd, &fds); //Remove the filedes from set
printf("IRQ detected %d\n", i);
fflush(stdout);
i++;
/* The return value includes the actual GPIO register value */
read(irqfd, &buf, sizeof(buf));
lseek(irqfd, 0, SEEK_SET);
}
//Sleep, or do any other processing here
usleep(100000);
}
return 0;
}
This example can be run as "./irqtest 48" which will echo every time the pin changes but not consume any CPU time while waiting for an edge to occur.
LCD Interface
LVDS
The TS-TPC-7990 includes one LVDS output from the i.MX6 processor. This interface can provide a pixel clock up to 85MHz supporting displays up to 1366x768 at 60hz. The LVDS pairs are available on these pins:
| Pin | Signal |
|---|---|
| LVDS CLK- | CN2_41 |
| LVDS CLK+ | CN2_43 |
| LVDS TX0+ | CN2_22 |
| LVDS TX0- | CN2_24 |
| LVDS TX1+ | CN2_48 |
| LVDS TX1- | CN2_46 |
| LVDS TX2+ | CN2_16 |
| LVDS TX2- | CN2_18 |
| LVDS TX3+ | CN2_10 |
| LVDS TX3- | CN2_12 |
After being connected the device tree in Linux will need to be created for your carrier board which will specify the LCD timing. See the file imx6qdl-tsTPC-7990-14.dtsi for an example that includes the LVDS setup.
In the LVDS bridge you will need to specify the LCD timing. As an example, this is for the 10" Hantronix display used on the TS-TPC-8950:
&ldb {
status = "okay";
lvds-channel@0 {
fsl,data-mapping = "spwg";
fsl,data-width = <18>;
status = "okay";
primary;
crtc = "ipu1-di0";
display-timings {
native-mode = <&timing0>;
timing0: hantronix-svga1 {
clock-frequency = <40000000>;
hactive = <800>;
vactive = <600>;
hback-porch = <46>;
hfront-porch = <210>;
vback-porch = <23>;
vfront-porch = <12>;
hsync-len = <20>;
vsync-len = <10>;
de-active = <1>;
hsync-active = <1>;
vsync-active = <1>;
pixelclk-active = <0>;
};
};
};
};
LEDs
The kernel provides access to control the LEDs using the sysfs:
# Set Red led on
echo 1 > /sys/class/leds/red-led/brightness
# Set Red led off
echo 0 > /sys/class/leds/red-led/brightness
# Set Green led on
echo 1 > /sys/class/leds/green-led/brightness
# Set Green led off
echo 0 > /sys/class/leds/green-led/brightness
The kernel provides various triggers that can be useful for debugging purposes. The trigger for a given LED is in its directory:
echo "heartbeat" > /sys/class/leds/red-led/trigger
| Trigger value | LED toggles on |
|---|---|
| none | Default, no action |
| mmc0 | MicroSD card activity |
| mmc1 | eMMC activity |
| mmc2 | WIFI SDIO activity |
| timer | 2hz blink |
| oneshot | Blinks after delay. [1] |
| heartbeat | Similar to timer, but varies the period based on system load |
| backlight | Toggles on FB_BLANK |
| gpio | Toggle based on a specified gpio. [2] |
| cpu0 | Blink on CPU core 0 activity |
| cpu1 | Blink on CPU core 1 activity |
| cpu2 | Blink on CPU core 2 activity |
| cpu3 | Blink on CPU core 3 activity |
| default-on | Only turns on by default. Only useful for device tree. |
| transient | Specify on/off with time to turn off. [3] |
| flash/torch | Toggle on Camera activation. Not currently used. |
- ↑ See the Kernel documentation for more details
- ↑ When this trigger is set, a "gpio" file appears in the same directory which can be used to specify what GPIO to follow when it blinks
- ↑ See the Kernel documentation for more details
MicroSD Card Interface
The i.MX6 SDHCI driver supports MicroSD (0-2GB), MicroSDHC (4-32GB), and MicroSDXC(64GB-2TB). The cards available on our website on average support up to 16MB/s read, and 22MB/s write using this interface. The linux driver provides access to this socket at /dev/mmcblk1 as a standard Linux block device.
See chapter 67 of the i.MX6 reference manual for the specific CPU variant for more information on the mmc controller.
We have performed compatibility testing on the Sandisk MicroSD cards we provide. We do not suggest switching brands/models without your own qualification testing. While SD cards specifications are standardized, in practice cards behave very differently. We do not recommend ATP or Transcend MicroSD cards due to known compatibility issues.
Our testing has shown that on average microSD cards will last between 6-12TB. After this cards can begin to experience corruption, or stop being recognized by the host PC. This may be enough storage for many applications to write for years without problems. For more reliable storage consider using the eMMC. Our endurance testing showed a write lifetime on average of about 123 TiB.
MicroSD cards should not have power removed during a write or they will have disk corruption. Keep the filesystem mounted read only if this is a possibility. It is not always possible for fsck to recover from the types of failures that will be seen with SD power loss. Consider using the eMMC for storage instead which is far more resilient to power loss.
PCIe
Power Consumption
The power consumption of the platform can vary depending on the build configuration and run time application/peripheral use. The majority of power savings occur when the CPU and GPU are idle. It is also possible to disable the Ethernet PHY for additional savings. The backlight intensity can be reduced for significant power savings as well.
# Put ETH PHY in reset
echo 116 > /sys/class/gpio/export
echo high > /sys/class/gpio/gpio116/direction
# Put USB hub in reset
echo 43 > /sys/class/gpio/export
echo low > /sys/class/gpio/gpio43/direction
# Lower backlight to 50%
echo 4 > /sys/class/backlight/backlight_local_lcd/brightness
# Disable backlight
echo 0 > /sys/class/backlight/backlight_local_lcd/brightness
In the measurements below, Ethernet is not connected unless otherwise specified and USB serial is disconnected during the measurement. The CPU test is 5x parallel processes of "openssl speed", and the GPU test is Qt5CinematicExperience in the Yocto image.
These tests are performed powering the unit through 5 VDC.
| Test | Max Watts | Average Watts |
|---|---|---|
| CPU 100% + GPU loaded (LCD 100%) + IO + Ethernet | 12.00 (2.40 A) | 8.95 (1.79 A) |
| CPU 100% (LCD 100%) | 8.90 (1.78 A) | 7.80 (1.56 A) |
| CPU Idle (LCD 100%) | 8.35 (1.67 A) | 7.20 (1.44 A) |
| CPU Idle (LCD 50%) | 8.60 (1.72 A) | 6.10 (1.22 A) |
| CPU Idle (LCD 0%) | 4.75 (0.95 A) | 3.90 (0.78 A) |
| CPU Idle (LCD 0%), USB HUB off | 4.10 (0.82 A) | 3.35 (0.67 A) |
| CPU Idle (LCD 0%), USB HUB off, Ethernet PHY in reset | 4.05 (0.81 A) | 2.95 (0.59 A) |
| CPU Idle (LCD 100%) + CPU Ethernet | 9.20 (1.84 A) | 5.70 (1.14 A) |
| CPU Idle (LCD 100%) + USB Ethernet | 5.85 (1.70 A) | 5.70 (1.14 A) |
| Test | Max Watts | Average Watts |
|---|---|---|
| CPU 100% + GPU loaded (LCD 100%) + IO + Ethernet | 18.85 (3.77 A) | 11.25 (2.25 A) |
| CPU 100% (LCD 100%) | 12.20 (2.44 A) | 8.65 (1.73 A) |
| CPU Idle (LCD 100%) | 11.50 (2.30 A) | 9.70 (1.94 A) |
| CPU Idle (LCD 50%) | 11.40 (2.28 A) | 7.90 (1.58 A) |
| CPU Idle (LCD 0%) | 4.65 (0.93 A) | 3.90 (0.78 A) |
| CPU Idle (LCD 0%), USB HUB off | 5.55 (1.11 A) | 3.50 (0.70 A) |
| CPU Idle (LCD 0%), USB HUB off, Ethernet PHY in reset | 4.90 (0.98 A) | 3.05 (0.61 A) |
| CPU Idle (LCD 100%) + CPU Ethernet | 11.20 (2.24 A) | 6.60 (1.32 A) |
| CPU Idle (LCD 100%) + USB Ethernet | 11.60 (2.32 A) | 6.70 (1.34 A) |
The on-board microcontroller is able to disable power to the rest of the platform and restore power after a specified number of seconds or if the touchscreen receives a touch event. The CPU variants will all draw the same amount of power while in sleep mode, however the touchscreen used will impact overall power draw during sleep. These tests are both at 5 VDC.
| Test | Max | Average |
|---|---|---|
| Resistive touch (Okaya or microtips) | 90mW | 20mW |
| Capacitive touch (LXD) | 125mW | 26mW |
RTC
This board uses a M41T00S STMicro Battery Backed RTC using an external and replaceable coin cell battery. This RTC is connected to the CPU via I2C and is handled by the kernel and is presented as a standard RTC device in linux.
With the provided battery this is expected to last 6 years. The RTCs are tested by the manufacturer to +-35ppm at 25C, which is about 1.53 minutes per month.
USB
USB OTG
The TS-7990 brings out a USB device port on P1 which can allow the board to act as a USB device. Several gadget device drivers are compiled into the default kernel. Additional devices can be compiled into the kernel by following the section here.
USB Serial
modprobe g_serial use_acm=1
This will create a /dev/ttyGS0 immediately after this modprobe is run. When this USB is connected to another Linux system this will show up as /dev/ttyACM0. See the kernel documentation for more information:
USB Ethernet
modprobe g_ether
This provides a usb0 network interface which simulates an ethernet network connection between the host pc and the i.MX6. This uses the Ethernet CDC driver on the host system where it is connected. Under Windows the inf file will be needed:
USB Host
The TS-7990 provides 4 standard USB 2.0 host supporting 480Mb/s. Two are on the Type A connector, one is on the XBEE module for use with cellular MODEM modules, and one is on the mini PCIe header. Most commonly USB drivers built into Linux handle the USB communication but low level USB communication is possible using libusb.
A GPIO is available to toggle power to USB devices. This can be used to save power, or to reset USB devices that get stuck in a bad state.
# Power disabled
echo 0 > /sys/class/leds/en-usb-5v/brightness
sleep 2 # let any devices reset
# Enable power
echo 1 > /sys/class/leds/en-usb-5v/brightness
SATA
| Note: | SATA is functional on Rev. B or newer PCBs. |
SATA is located on the mini PCIe header on the TS-7990. This is intended to be used with mSATA style drives to provide fast embedded storage.
The i.MX6 Quad and Dual include integrated SATA II support. This interface has been tested to provide 135MiB/s write, and 170MiB/s read in sequential accesses. In linux this is accessed through the /dev/sda device:
[ 1.768036] ata1: SATA link up 3.0 Gbps (SStatus 123 SControl 300) [ 1.785377] ata1.00: ATA-8: MKNSSDAT30GB-DX, 507ABBF0, max UDMA/133 [ 1.791716] ata1.00: 58626288 sectors, multi 16: LBA48 NCQ (depth 31/32) [ 1.805380] ata1.00: configured for UDMA/133 [ 1.810320] scsi 0:0:0:0: Direct-Access ATA MKNSSDAT30GB-DX 507A PQ: 0 ANSI: 5 [ 1.819459] sd 0:0:0:0: [sda] 58626288 512-byte logical blocks: (30.0 GB/27.9 GiB) [ 1.827427] sd 0:0:0:0: [sda] Write Protect is off [ 1.832812] sd 0:0:0:0: [sda] Write cache: enabled, read cache: enabled, doesn't support DPO or FUA [ 1.843621] sda: sda1 [ 1.847381] sd 0:0:0:0: [sda] Attached SCSI dis
U-Boot includes a script to boot off of a SATA drive. The SATA drive should be formatted just like the SD card examples. In U-Boot run:
env set bootcmd 'run sataboot;'
env save
This will ignore the SD boot jumper and boot directly to SATA.
SPI
SPI is located on the DIO header and is available in software via /dev/spidev1.2
This platform includes one SPI interface which is accessible through either kernel drivers or userspace using the /dev/spi interface.
Developing or implementing kernel SPI drivers are beyond the scope of this document, but the build environment is described in the kernel compile guide.
The /dev/spidev1.2 interface can be accessed using the userspace API. For more information see the documentation and sample code:
Onboard SPI Flash
This board includes 8 MiB of SPI flash using a Micron N25Q064A13ESE40F. The CPU uses this for the initial boot to load U-Boot, as well as the U-Boot environment. In Linux this is accessed with the /dev/mtdblock devices.
| Bytes | Size | Description |
|---|---|---|
| 0x000000-0x0003FF | 1 KB | Unused |
| 0x000400-0x0FFFFF | 0.999 MiB | U-Boot |
| 0x100000-0x101FFF | 8 KiB | U-Boot environment #1 |
| 0x102000-0x17FFFF | 504 KiB | Unused |
| 0x180000-0x181FFF | 8 KiB | U-boot environment #2 |
| 0x182000-0x1FFFFF | 504 KiB | Unused |
| 0x200000-0x201DE7 | 7655 B | Splash Screen |
| 0x201DE8-0x700000 | 4.993 MiB | Unused |
TWI
The i.MX6 CPU implements a standard I2C interface at 100khz that is compatible with fast mode for 400khz operation. The CPU has 2 I2C buses used on the TS-7990.
I2C 0 is used for many onboard peripherals only, but I2C 1 is unused and brought out to the DIO header pins 1 (DAT) and 3 (CLK).
| Address | Device |
|---|---|
| 0x0A | SGTL5000 audio codec |
| 0x1C | Accelerometer |
| 0x28-0x2F | FPGA |
| 0x4A | Supervisory Microcontroller |
| 0x5C [1] | Capacitive Touch Controller |
| 0x68 | RTC |
- ↑ LXD option only
The kernel I2C device node is available at /dev/i2c-<bus number>. The i2c-tools (i2cdetect, i2cget, i2cset) suite can be used to manipulate the bus. It is also possible to create a custom application using the I2C device interface API.
Watchdog
The kernel provides an interface to the watchdog driver at /dev/watchdog. Refer to the kernel documentation for more information:
WIFI
This board uses an ATWILC3000-MR110CA IEEE 802.11 b/g/n Link Controller Module With Integrated Bluetooth® 4.0. Linux provides support for this module using the wilc3000 driver.
Summary features:
- IEEE 802.11 b/g/n RF/PHY/MAC SOC
- IEEE 802.11 b/g/n (1x1) for up to 72 Mbps PHY rate
- Single spatial stream in 2.4GHz ISM band
- Integrated PA and T/R Switch Integrated Chip Antenna
- Superior Sensitivity and Range via advanced PHY signal processing
- Advanced Equalization and Channel Estimation
- Advanced Carrier and Timing Synchronization
- Wi-Fi Direct and Soft-AP support
- Supports IEEE 802.11 WEP, WPA, and WPA2 Security
- Supports China WAPI security
- Operating temperature range of -40°C to +85°C
External Interfaces
Displays
The TS-TPC-7990 includes support for three different displays. U-boot will print out the detected display during startup:
Display: LXD-WSVGA (1024x600)
LXD Display
Okaya Display
Microtips Display
Audio
By default the board provides audio from the AC97 audio header, and the speaker. You can disable the onboard speaker to just have output from the external interface with:
echo 0 > /sys/class/leds/en-speaker/brightness
As a simple example to test audio you can use "aplay" to play .wav files, and arecord to use the mic input to create a wav file
arecord -d 5 recording.wav
aplay recording.wav
Audio Header
The TS-TPC-7990 includes a 2x5 0.1" pitch header including the speaker, microphone, and headphones. This header is compatible with AC97 which is commonly found on desktop motherboards. Third party cabling can bring this into 3.5mm headers.
|
|
Speaker
The onboard speaker provides up to 82db output.
COM1
The COM ports all use 0.1" pitch 2x5 headers. You can use the RC-DB9 cable in the accessories section to bring this to a DB9 cable.
|
COM2
|
COM3
|
LCD Headers
Mini PCIe
Power Connector
DIO Header
|
|
USB Header
|
| Note: | The USB on even pins 2-10 are shared with the mini pcie connector. Both of these ports cannot operate at once. |
USB Ports
Revisions and Changes
TS-TPC-7990 PCB Revisions
| Revision | Changes |
|---|---|
| A |
|
| B |
|
| C |
|
| E |
* ST Microelectronics ISM330DLCTR 6-axis sensor (Accelerometer/Gyroscope) * ST Microelectronics IIS2MDCTR 3-axis Magnetoresistive sensor
|
U-Boot Changelog
| May-09-2016 |
|
| Nov-16-2016 |
|
| Jan-13-2017 |
|
| Feb-03-2017 |
|
| Feb-17-2017 |
|
| Mar-06-2017 |
|
| Apr-12-2017 |
|
| Jun-07-2017 |
|
| Jul-28-2017 |
|
| Aug-03-2017 |
|
| Nov-14-2018 |
|
| Aug-02-2023 |
|
FPGA Changelog
Check the FPGA rev with:
echo $(($(tshwctl --peek --addr 51)>>4))
| Rev | Changes |
|---|---|
| 1 |
|
| 2 |
|
| 3 |
|
| 4 |
|
| 5 |
|
| 6 |
|
| 7 |
|
| 8 |
|
| 9 |
|
You can reload the FPGA during startup for custom FPGAs. If /boot/ts7990-fpga.vme is present during startup you will see u-boot reload this file:
Bytes transferred = 56341 (dc15 hex) VME file checked: starting downloading to FPGA Diamond Deployment Tool 3.5 CREATION DATE: Wed Oct 07 11:38:24 2015 Downloading FPGA 53248/56341 completed FPGA downloaded successfully
Software Images
Yocto Changelog
Debian Changelog
Android Changelog
Arch Linux Changelog
TS-TPC-7990 Arch Linux Changelog
Product Notes
FCC Advisory
This equipment generates, uses, and can radiate radio frequency energy and if not installed and used properly (that is, in strict accordance with the manufacturer's instructions), may cause interference to radio and television reception. It has been type tested and found to comply with the limits for a Class A digital device in accordance with the specifications in Part 15 of FCC Rules, which are designed to provide reasonable protection against such interference when operated in a commercial environment. Operation of this equipment in a residential area is likely to cause interference, in which case the owner will be required to correct the interference at his own expense.
If this equipment does cause interference, which can be determined by turning the unit on and off, the user is encouraged to try the following measures to correct the interference:
Reorient the receiving antenna. Relocate the unit with respect to the receiver. Plug the unit into a different outlet so that the unit and receiver are on different branch circuits. Ensure that mounting screws and connector attachment screws are tightly secured. Ensure that good quality, shielded, and grounded cables are used for all data communications. If necessary, the user should consult the dealer or an experienced radio/television technician for additional suggestions. The following booklets prepared by the Federal Communications Commission (FCC) may also prove helpful:
How to Identify and Resolve Radio-TV Interference Problems (Stock No. 004-000-000345-4) Interface Handbook (Stock No. 004-000-004505-7) These booklets may be purchased from the Superintendent of Documents, U.S. Government Printing Office, Washington, DC 20402.
Limited Warranty
See our Terms and Conditions for more details.