Porting Linux Applications to VxWorks RTOS

Tips for Porting Linux Application to VxWorks: 

1. There is no notion of a process (in the POSIX sense), there is no notion of sharing of locks (mutexes) and condition variables between processes.  As a result, the POSIX symbol _POSIX_THREAD_PROCESS_SHARED is not defined in this implementation, and the routines pthread_condattr_getpshared( ), pthread_condattr_setpshared( ), pthread_mutexattr_getpshared( ) are not implemented.

2. There are NO processes in VxWorks, fork( ), wait( ), and pthread_atfork( ) are unimplemented. If you need to spawn a task for that using the 'taskSpawn' routine.

3. VxWorks does NOT have password, user, or group databases, therefore there are no implementations of getlogin( ), getgrgid( ), getpwnam( ), getpwuid( ), getlogin_r( ), getgrgid_r( ), getpwnam_r( ), and getpwuid_r( )

4. VxWorks programming discourages to use global variables and if in case you need to use the global variables ( global scope ,file scope ) make sure you initialize those before your application program starts and make sure use to use the unique variable names.This is because of the fact that vxWorks memory model is flat,so you need to be extra careful in using the global variables.

5. The 'main' routine does not work in vxWorks case, We need to write your own wrapper function to parse the command line arguments that you pass to your program from the interactive shell.

6. It is recommended to use the separate memory partition for your application if your application demands more frequent use of dynamic memory allocations and frees.

7. It is better to use the static memory for small memory allocations because vxWorks mem library does not use best fit  algorithm for its memory allocations and it can lead to memory fragmentation.

ref:

http://www.vxdev.com/docs/vx55man/vxworks/ref/pthreadLib.html

https://groups.google.com/forum/#!topic/comp.os.vxworks/PVGKsSaGxtw

Porting RTOS drivers to Linux - http://www.linuxjournal.com/article/7355

VxWorks API to Linux - http://v2lin.sourceforge.net/

Migrating legacy VxWorks applications to Linux - http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.466.7007&rep=rep1&type=pdf

OpenWrt Overview ..

OpenWrt is an embedded operating system based on Linux, primarily used on embedded devices to route network traffic. It can run on various types of devices, including CPE routers, residential gateways, smartphones, pocket computers (e.g. Ben NanoNote), and laptops. It is also possible to run OpenWrt on personal computers, which are most commonly based on the x86 architecture.

Instead of trying to create a single, static firmware, OpenWrt provides a fully writable filesystem with package management. This frees you from the application selection and configuration provided by the vendor and allows you to customize the device through the use of packages to suit any application. For developer, OpenWrt is the framework to build an application without having to build a complete firmware around it; for users this means the ability for full customization, to use the device in ways never envisioned.

OpenWrt Commands:

1. Kernel version => uname -a
2. OS version => cat /etc/banner
3. Show contents of syslog => logread
4. Install OpenWRT packages => https://downloads.openwrt.org/snapshots/trunk/ar71xx/generic/packages/packages/
opkg install kmod-bluetooth bluez-utils
opkg install libusb

OpenWRT BlueZ packages =>

bluelog-live_1.1.2-1_ar71xx.ipk 32868 18-Jun-2016 17:57
bluelog_1.1.2-1_ar71xx.ipk 10945 18-Jun-2016 17:57
bluez-daemon_5.38-1_ar71xx.ipk 488028 18-Jun-2016 17:52
bluez-examples_5.38-1_ar71xx.ipk 29941 18-Jun-2016 17:51
bluez-libs_5.38-1_ar71xx.ipk 48830 18-Jun-2016 17:51
bluez-utils_5.38-1_ar71xx.ipk 861936 18-Jun-2016 17:52

ref:

Official - https://openwrt.org/https://openwrt.org/

Wiki - https://en.wikipedia.org/wiki/OpenWrt

OpenWrt github - https://github.com/openwrt

Getting started with OpenWRT - http://www.cambus.net/getting-started-with-openwrt/

OpenWRT Build System - https://wiki.openwrt.org/doc/howto/build

Building C++ code - http://www.black-swift.com/wiki/index.php?title=C/C%2B%2B_Building_Environment

OpenWRT SDK download - https://downloads.openwrt.org/

OpenWRT Custom Build - https://wiki.openwrt.org/doc/howto/build

OpenWrt BlueZ - https://forum.openwrt.org/viewtopic.php?id=1650

OpenWrt on x86 PC - https://forum.openwrt.org/viewtopic.php?id=20478, https://we.riseup.net/lackof/openwrt-on-x86-64

OpenWrt on VirtualBox - https://wiki.openwrt.org/doc/howto/virtualbox

Generic Basic Howtos for OpenWrt - https://wiki.openwrt.org/doc/howto/generic.overview

OpenWRT Mini Handbook - https://github.com/airplug/airplug/wiki/OpenWRT-Mini-Handbook

OpenWRT FAQ before installation - https://wiki.openwrt.org/doc/faq/before.installation

OpenWRT after installation - https://wiki.openwrt.org/doc/faq/after.installation

Image Generator (Image Builder) - https://wiki.openwrt.org/doc/howto/obtain.firmware.generate

USB Bluetooth support - https://wiki.openwrt.org/doc/howto/usb.bluetooth

Misc - https://forum.openwrt.org/viewtopic.php?id=1650

ThreadX RTOS ..

ThreadX is advanced Real-Time Operating System (RTOS) designed specifically for deeply embedded applications. ThreadX provides advanced scheduling facilities, message passing, interrupt management, and messaging services, as well as many others. ThreadX has many advanced features, including its picokernel™ architecture, preemption-threshold™ scheduling, event-chaining,™ and a rich set of system services. Combined with its superior ease-of-use, ThreadX is the ideal choice for the most demanding of embedded applications. ThreadX has been deployed in over over 2 billion electronic products in the areas of consumer devices, medical electronics, and industrial control equipment.Similar RTOSes are available from other vendors such as VxWorks, Nucleus RTOS, OSE, QNX, LynxOS, etc.

ThreadX is implemented as a C library. Only the features used by the application are brought into the final image. The minimal footprint of ThreadX is under 2KB on Microcontrollers.

• Minimal Kernel Size: Under 2K bytes
• Queue Services: 900 bytes
• Semaphore Services: 450 bytes
• Mutex Services: 1200 bytes
• Block Memory Services: 550 bytes
• Minimal RAM requirement: 500 bytes
• Minimal ROM requirement: 2K bytes

The name ThreadX is derived from the fact that threads are used as the executable modules and the letter "X" represents context switching, i.e., it switches threads. ThreadX can be seen as the "QThreads" of SystemC implemented in preemptive fashion. Like most RTOSes, ThreadX uses a multitasking kernel with preemptive scheduling, fast interrupt response, memory management, interthread communication, mutual exclusion, event notification, and thread synchronization features.

ThreadX is generally used in real-time embedded systems, especially in deeply embedded systems. Developing embedded systems using ThreadX is usually done on a host machine running Linux or Microsoft Windows, using cross-compiling target software to run on various target processor architectures. Several ThreadX-aware development tools are available, such as Wind River Workbench, ARM RealView, Green Hills Software's MULTI, Metrowerks CodeWarrior, IAR C-SPY, Lauterbach TRACE32, and visionCLICK.

ref:

http://en.wikipedia.org/wiki/ThreadX

http://rtos.com/products/threadx/

https://students.cs.byu.edu/~cs345ta/reference/RT%20Embedded%20Multithreading.pdf

http://amkamboh.seecs.nust.edu.pk/index_files/Multitasking%20Demo.pdf

http://rtos.com/products/guix/

ThreadX Application API - http://rtos.com/images/uploads/programmersguide_threadx.pdf

ThreadX to Linux porting -

• http://www.mapusoft.com/port-threadx-applications-to-linux/
• http://www.slideshare.net/MapuSoft/easy-way-to-port-thread-x-applications-to-linux
• http://info.mapusoft.com/Webinar3-29-11Webdnldpg.html

Yocto Embedded Linux ..

The Yocto Project is an open source collaboration that provides standardized high-quality infrastructure, tools, and methodology to help decrease the complexity and increase the portability of Linux implementations. This open standard environment helps developers more easily create and maintain their own custom Linux distributions that can run across multiple hardware architectures and support different market segments.

The Yocto Project is an umbrella project. Poky is one of the the largest components of the Yocto Project, and Poky continues as an independent, open source project developing the build system used by the Yocto Project, as well as by other open source projects. Poky is a reference system of the Yocto Project. It is the platform-independent, cross-compiling integration layer that utilizes OpenEmbedded Core. It provides the mechanism to build and combine thousands of distributed open source projects together to form a fully customizable, complete, coherent Linux software stack.

The Yocto Project and OpenEmbedded share a core collection of metadata called openembedded-core. However, the two organizations remain separate, each with its own focus. OpenEmbedded provides a comprehensive set of metadata for a wide variety of architectures, features, and applications. The Yocto Project focuses on providing powerful, easy-to-use, interoperable, well-tested tools, metadata, and board support packages (BSPs) for a core set of architectures and specific boards.

The Yocto ADT (application developper tools) are based on the SDK (i.e. architecture-specific cross-toolchain and matching sysroot), but when talking about the ADT we also mean the Eclipse Yocto Plug-in, the Quick EMUlator (QEMU, which lets you simulate target hardware) and various user-space tools (e.g. for application profiling or latency measurements). The default development toolchain is based on GCC.

High-performance, flexible Wind River Linux delivers the power of the industry-standard Yocto Project infrastructure with better interoperability across many popular platforms. With the Yocto Project 1.7 open source development infrastructure as its core foundation, Wind River Linux uses the latest Linux kernel as its upstream source to ensure customers have commercially supported access to the newest advancements from the open source community. 

Intel's Edison computing module was built on Yocto-based Linux and the Intel Atom processor.

Wind River Linux Core Platform:

ref:

Yocto project - 

• http://en.wikipedia.org/wiki/Yocto_Project
• https://www.yoctoproject.org/
• http://www.aosabook.org/en/yocto.html

Yocto source repositories - https://git.yoctoproject.org/

Yocto Faq - https://wiki.yoctoproject.org/wiki/FAQ

WindRiver Linux - http://www.windriver.com/products/linux.html

Yocto project documentation - https://www.yoctoproject.org/documentation 

Yocto project development manual - http://www.yoctoproject.org/docs/current/dev-manual/dev-manual.html#usingpoky-extend-addpkg 

Yocto project Linux Kernel Development Manual - http://www.yoctoproject.org/docs/1.7/kernel-dev/kernel-dev.html

Intel Yocto Project - https://software.intel.com/en-us/search/site/language/en?query=Yocto%20Project

Architecture of opensource applications - http://www.aosabook.org/en/index.html

Miscellaneous:
http://www.linux.com/news/embedded-mobile/mobile-linux/788030-intels-edison-brings-yocto-linux-to-wearables

Internet of Things(IoT)

The Internet of Things (IoT) is the interconnection of uniquely identifiable embedded computing devices within the existing Internet infrastructure. Typically, IoT is expected to offer advanced connectivity of devices, systems, and services that goes beyond machine-to-machine communications(M2M) and covers a variety of protocols, domains, and applications. The interconnection of these embedded devices is expected to usher in automation in nearly all fields.

The Internet of Things (IoT) is the network of physical objects accessed through the Internet as defined by technology analysts and visionaries. These objects contain embedded technology to interact with internal states or the external environment. In other words, when objects can sense and communicate, it changes how and where decisions are made, and who makes them. A common first step toward the IoT is converting networks on proprietary protocols to IP-based networks.

The IoT needs standard protocols. Popular Open source IoT protocols are CoAP, MQTT, ETSI SmartM2M or LwM2M. Two of the most promising for small devices are -

• CoAP(Constrained Application Protocol)
• MQTT(Message Queuing Telemetry Transport)

CoAP is designed for interoperability with the web. MQTT gives flexibility in communication patterns and acts purely as a pipe for binary data.

CoAP

CoAP is the Constrained Application Protocol from the CoRE (Constrained Resource Environments) IETF group. Like HTTP, CoAP is a document transfer protocol. Unlike HTTP, CoAP is designed for the needs of constrained devices. CoAP packets are much smaller than HTTP TCP flows. Bitfields and mappings from strings to integers are used extensively to save space. Packets are simple to generate and can be parsed in place without consuming extra RAM in constrained devices.

CoAP runs over UDP not TCP. Clients and servers communicate through connectionless datagrams. Retries and reordering are implemented in the application stack. Removing the need for TCP may allow full IP networking in small microcontrollers. CoAP allows UDP broadcast and multicast to be used for addressing. CoAP follows a client/server model. Clients make requests to servers, servers send back responses. Clients may GET, PUT, POST and DELETE resources. CoAP is designed to interoperate with HTTP and the RESTful web at large through simple proxies. As CoAP is datagram based, it may be used on top of SMS and other packet based communications protocols. tinydtls is a library for Datagram Transport Layer Security (DTLS) covering both the client and the server state machine. It is implemented in C and provides support for the mandatory cipher suites specified in CoAP.

MQTT

MQTT is a publish/subscribe messaging protocol designed for lightweight M2M communications. It was originally developed by IBM and is now an open standard. MQTT has a client/server model, where every sensor is a client and connects to a server, known as a broker over TCP. MQTT is message oriented. Every message is a discrete chunk of data, opaque to the broker. Every message is published to an address, known as a topic. Clients may subscribe to multiple topics. Every client subscribed to a topic receives every message published to the topic.

Popular Open Source IoT Operating Systems -

• Contiki
• TinyOS
• RIOT
• mbedOS
• FreeRTOS
• Google Brillo

ref:

Wiki - http://en.wikipedia.org/wiki/Internet_of_Things

Open Interconnect Consortium(OIC) - http://openinterconnect.org/

AllSeen Alliance - https://allseenalliance.org/

Qualcomm Allseen Alliance source code download - https://allseenalliance.org/developers/download

Intel iotivity source code download - https://www.iotivity.org/downloads

IoT standards - iot.eclipse.org— Standards

Google Thread IoT - http://www.threadgroup.org/

Industrial Internet Consortium - http://www.iiconsortium.org/

Google Nest and others group - http://www.threadgroup.org/

Apple HomeKit - https://developer.apple.com/homekit/

IoT overview -

• http://www.cisco.com/web/solutions/trends/iot/overview.html
• http://www.microsoft.com/windowsembedded/en-us/internet-of-things.aspx
• http://www-01.ibm.com/software/info/internet-of-things/
• http://www.businessinsider.com/enterprise-growth-in-the-internet-of-things-market-2014-8
• http://www.mckinsey.com/insights/high_tech_telecoms_internet/the_internet_of_things

IoT protocols(MQTT, CoAP) - http://www.eclipse.org/community/eclipse_newsletter/2014/february/article2.php

libcoap: CoAP implementation in C - http://sourceforge.net/projects/libcoap/

tinyDtls - https://projects.eclipse.org/projects/iot.tinydtls

micro-ecc - https://github.com/kmackay/micro-ecc

jCoAP: CoAP implementation in Java - https://code.google.com/p/jcoap/

CoAP.net: CoAP implementation in C# - http://sourceforge.net/projects/coapnet/

CoRE (Constrained Resource Environments) - https://datatracker.ietf.org/doc/charter-ietf-core/

Open IoT stack for Java - http://iot.eclipse.org/java/download/

Intel IoT developer kit - https://software.intel.com/en-us/blogs/2014/09/08/announcing-intel-iot-developer-kit

Eclipse C/C++ IDE for Intel Galileo/Edison - https://software.intel.com/en-us/getting-started-for-c-c-plus-plus-eclipse-galileo-and-edison

Arduino Development

Arduino is an open-source electronics prototyping platform based on flexible, easy-to-use hardware and software. It's intended for artists, designers, hobbyists, and anyone interested in creating interactive objects or environments.

Arduino is a single-board microcontroller, intended to make building interactive objects or environments more accessible. The hardware consists of an open-source hardware board designed around an 8-bit Atmel AVR microcontroller, or a 32-bit Atmel ARM. Current models feature a USB interface, 6 analog input pins, as well as 14 digital I/O pins that accommodate various extension boards.

Arduino can sense the environment by receiving input from a variety of sensors and can affect its surroundings by controlling lights, motors, and other actuators. The microcontroller on the board is programmed using the Arduino programming language and the Arduino development environment. Arduino projects can be stand-alone or they can communicate with software on running on a computer (e.g. Flash, Processing, MaxMSP. The boards can be built by hand or purchased preassembled; the software can be downloaded for free. The hardware reference designs (CAD files) are available under an open-source license, you are free to adapt them to your needs.

avr-gcc, avr-g++, avr-objcopy, avrdude are the tools used in compiling 'C' code on arduino.

ref:

wiki - http://en.wikipedia.org/wiki/Arduino

Arduino website - http://www.arduino.cc/

Opensource Hardware Group(All about Arduino) - http://opensourcehardwaregroup.com/

Arduino IDE - http://arduino.cc/en/main/software

Arduino development environment - http://arduino.cc/en/guide/Environment

Arduino Development tools - http://playground.arduino.cc/Main/DevelopmentTools

Arduino library - https://github.com/arduino/Arduino/tree/master/hardware/arduino/cores/arduino

Arduino Makefile - https://github.com/sudar/Arduino-Makefile

Programming Arduino Uno in pure C/C++ - 

• https://code.google.com/p/arduino/wiki/BuildProcess
• https://balau82.wordpress.com/2011/03/29/programming-arduino-uno-in-pure-c/
• https://www.ashleymills.com/node/327
• http://www.wikihow.com/Write-Arduino-Software-in-C

Arduino IDE for Microsoft Visual Studio and Atmel Studio - http://www.visualmicro.com/

Introduction to Arduino - http://www.instructables.com/id/Intro-to-Arduino/

Intel Arduino compatible Galileo board - http://www.intel.com/content/www/us/en/do-it-yourself/galileo-maker-quark-board.html

Arduiono IDE and sketch development overview - http://opensourcehardwaregroup.com/tutorial-3-arduino-ide-and-sketch-overview/

Arduino boards summary - http://www.hobbytronics.co.uk/arduino-summary

Advanced Arduino Hacking - https://pragprog.com/magazines/2011-04/advanced-arduino-hacking

Arduino Books(https://drive.google.com/folderview?id=0B5BO97vHUkN2VzEzTXFtRS1tSXc&usp=sharing_eid) -

• Beginning Arduino, 2nd Edition: https://drive.google.com/file/d/0B_hC-3L4eq17T0tsMmxwSk1fUVk/view?usp=sharing_eid
• Getting Started with Arduino v2: https://drive.google.com/file/d/0B_hC-3L4eq17aTdtWUxsRm85Wm8/view?usp=sharing_eid
• Exploring Arduino: Tools and Techniques for Engineering Wizardry: https://drive.google.com/file/d/0B_hC-3L4eq17NzdxSmZTbVk1dE0/view?usp=sharing_eid
• Arduino - A Quick Start Guide Quick Start Guide: https://drive.google.com/file/d/0B_hC-3L4eq17NjR4U1NaWktqMEk/view?usp=sharing_eid

Arduino Cookbooks -

Arduino Cookbook 2nd edition - 

• https://drive.google.com/file/d/0B_hC-3L4eq17cVdwTTlDMUFCM1k/view?usp=sharing_eid
• http://www.mogi.bme.hu/letoltes/MECHATRONIKAI%20&%20IR%C3%81NY%C3%8DT%C3%81STECHNIKAI%20T%C3%81RGYAK/MECHATRONIKAI%20SZIMULACIOK/Ardunio/Arduino_CookBook_2nd_edition.pdf

Arduino Cookbook 1st edition - 

• https://drive.google.com/file/d/0B_hC-3L4eq17djIyeGttX1p1bXc/view?usp=sharing_eid
• http://juniorfall.files.wordpress.com/2011/11/arduino-cookbook.pdf

Linux Device Drivers: Kernel to User Space communication

Inside Kernel space code:

To convert data from User space to Kernel space => copy_from_user

To send data from Kernel space to User space => copy_to_user

To read/write data to IO device below Device Driver(Firmware) => ioread32/iowrite32

The file_operations structure is defined in linux/fs.h, and holds pointers to functions defined by the driver that perform various operations on the device. Each field of the structure corresponds to the address of some function defined by the driver to handle a requested operation.

C99 way of assigning to elements of a structure.  You should use this syntax in case someone wants to port your driver. It will help with compatibility:

    struct file_operations fops = {

       .read = device_read,

       .write = device_write,

       .open = device_open,

       .release = device_release

    };

debugfs is a special filesystem (technically referred as a kernel space-user-space interface) available in Linux kernel since version 2.6.10-rc3. It is a simple to use RAM-based file system specially designed for debugging purposes. debugfs exists as a simple way for kernel developers to make information available to user space.

Inside User space code:

Open device directly from User space and read/write. 

example: open(“/dev/device_name”, O_RDWR);

Shared Memory:

Shared memory in user space => mmap(), munmap()

Shared memory in kernel space => remap_pfn_range()

PCI Device Drivers:

pci_register_driver - register a new pci driver
pci_unregister_driver - unregister a new pci driver

register_netdev - network device drivers
misc_register - char device drivers
register_blkdev - block device drivers 

module_init - driver initialization entry point
module_exit - driver exit entry point

Miscellaneous commands:

lspci –k => lists all pci device drivers

lsmod => lists all Loadable kernel modules(LKM)

modprobe => add/remove a kernel module

ref:

User space memory access from Kernel => http://www.ibm.com/developerworks/library/l-kernel-memory-access/

Linux Kernel to User space communication(copy_from-user, copy_to_user) -  http://www.makelinux.net/ldd3/chp-3-sect-7

Google Research(papers ...) - http://research.google.com/

Kernel to User space communication - http://people.ee.ethz.ch/~arkeller/linux/multi/kernel_user_space_howto-2.html

Use mmap() shared memory instead of copy_to_user => http://www.linuxforums.org/forum/kernel/158548-avoid-memory-copying-between-user-space-kernel-space.html

Debugfs - 

• http://en.wikipedia.org/wiki/Debugfs, 
• http://www.linuxforu.com/2010/10/debugging-linux-kernel-with-debugfs/

Debugfs Sample Code -  

• http://people.ee.ethz.ch/~arkeller/linux/code/mmap_simple_kernel.c
• http://people.ee.ethz.ch/~arkeller/linux/code/mmap_user.c

Debugging Kernel with debgufs - 

• http://www.linuxforu.com/2010/10/debugging-linux-kernel-with-debugfs/
• http://www.tldp.org/LDP/lkmpg/2.4/html/c577.htm 

Miscellaneous Character Drivers - 

• http://www.linuxjournal.com/article/2920
• http://syprog.blogspot.com/2011/10/hijack-linux-system-calls-part-ii.html
• http://www.embeddedlinux.org.cn/EssentialLinuxDeviceDrivers/final/ch05lev1sec7.html

Linux Device Driver Overview - http://inbasudhakar.blogspot.com/2011/08/pci-driver-flow.html

Practical and effective sandboxing for non-root users -  http://people.csail.mit.edu/nickolai/papers/kim-mbox.pdf

packetdrill: Scriptable Network Stack Testing, from Sockets to Packets - http://static.googleusercontent.com/external_content/untrusted_dlcp/research.google.com/en/us/pubs/archive/41316.pdf

http://linuxforthenew.blogspot.com/2013/01/why-doshould-we-use-copyfromuser-or.html