Tech Kaizen: 2014

Popular Open Source Tools: git, gerrit, jenkins, jira

git - source code repository tool
gerrit - code review tool
jenkins - build automation tool
jira - tool

Git is an designed to handle very large projects that are distributed over .

Gerrit is a for projects that use git. Gerrit encourages more by allowing all authorized users to submit changes, which are automatically merged if they pass code review. In addition, Gerrit makes reviewing easier by displaying changes side by side in-browser and enabling inline comments.

Jenkins is an written in . The project was forked from after a dispute with . Jenkins provides continuous integration services for software development. It is a server-based system running in a servlet container such as .

JIRA is a . It provides bug tracking, , and . The uses JIRA and . JIRA includes tools allowing migration from competitor Bugzilla.

ref:

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

(git, gerrit) - https://source.android.com/source/developing.html

Gerrit code review - https://review.openstack.org/Documentation/intro-quick.html

Jenkins - http://jenkins-ci.org/

- http://www.vogella.com/tutorials/Jenkins/article.html

- http://www.opensourcetesting.org/security.php

Image Processing Libraries: OpenCV, OpenMAX

OpenCV () is a library of programming functions mainly aimed at real-time computer vision. The library is cross-platform. It focuses mainly on real-time image processing. If the library finds on the system, it will use these proprietary optimized routines to accelerate itself.

OpenVX () is an open, royalty-free standard for cross platform acceleration of computer vision applications. It is designed by the to facilitate portable, optimized and power-efficient processing of methods for vision algorithms. This is aimed for embedded and real-time programs within computer vision and related scenarios. It uses a connected graph representation of operations.

OpenMAX Integration Layer (IL) is a standard API to access Multimedia Components on mobile platforms. It focuses mainly on audio, video, and still images processing. It has been defined by the Khronos group. By means of the , multimedia frameworks can access hardware accelerators on platforms that provide it. Bellagio is an opensource implementation of the OpenMAX IL API that runs on Linux.It is intended to show the usage of the IL API and to allow people to start developing components.This package provides the OpenMAX IL core shared library with a "reference" component.

OpenMAX DL is a OpenMAX DL () APIs contains a comprehensive set of audio, video and imaging functions that can be implemented and optimized on new CPUs, hardware engines, and DSPs and then used for a wide range of accelerated codec functionality such as , , , and .

Eigen is a C++ template library for linear algebra: matrices, vectors, numerical solvers, and related algorithms. They currently cover the two following feature sets, and more will come in the future: , . Eigenfaces is a popular .

Festival library(&) is a C++ Text to Voice generation library.

Digital Audio Programming

Digital Audio is the most commonly used method to represent sound inside a computer. In this method sound is stored as a sequence of samples taken from the audio signal using constant time intervals. The quality of digital audio signal depends on the time (recording rate) and voltage resolution (usually in an linear integer representation with basic unit one bit). A sample represents volume of the signal at the moment when it was measured. In uncompressed digital audio each sample require one or more bytes of storage. Number of bytes required depends on number of channels (mono, stereo) and sample format (8 or 16 bits, mu-Law, etc.). The length of this interval determines the sampling rate. Normally used sampling rates are between 8 kHz (telephone quality) and 48 kHz (DAT tapes).

Digital audio can be stored in a wide range of formats. Generally speaking, audio comes in two flavors: compressed and uncompressed. Compressed audio can further be subdivided into different kinds of compression: lossless, which preserves the original content exactly, and lossy which achieves more compression at the expense of degrading the audio. Uncompressed PCM audio, on the other hand, is defined by two parameters: the sample rate and the bit-depth. Loosely speaking, the sample rate limits the maximum frequency that can be represented by the format, and the bit-depth determines the maximum dynamic range that can be represented by the format. You can think of bit-depth as determining how much noise there is compared to signal.

In the Linux kernel, there have historically been two uniform sound APIs used. One is OSS(Open Sound System); the other is ALSA (Advanced Linux Sound Architecture). ALSA is available for Linux only, and as there is only one implementation of the ALSA interface, ALSA refers equally to that implementation and to the interface itself.

Android Native code makes uses of OpenSL ES (Open Sound Library for Embedded Systems) for handling Audio processing.

ref:

The ABCs of PCM (Uncompressed) digital audio - http://blog.bjornroche.com/2013/05/the-abcs-of-pcm-uncompressed-digital.html

WAVE PCM soundfile format - https://ccrma.stanford.edu/courses/422/projects/WaveFormat/

An introduction to Linux sound systems and APIs - http://archive09.linux.com/articles/113775

A Tutorial on Using the ALSA Audio API - http://equalarea.com/paul/alsa-audio.html

How to write ALSA driver - http://c-qs.blogspot.com/2014/05/writing-of-alsa-driver.html

alsa vs tinyalsa - http://blog.csdn.net/myzhzygh/article/details/8468210

Open Sound System(OSS) -

Advanced Linux Sound Architecture(ALSA) -

ALSA pcm - http://www.alsa-project.org/alsa-doc/alsa-lib/pcm.html
ALSA - alsa-lib, libsound2.so - http://www.alsa-project.org/alsa-doc/alsa-lib/pcm.html
ALSA Pulse Audio - http://freedesktop.org/software/pulseaudio/doxygen/simple.html
Pulse Audio(libpulse.so) - http://freedesktop.org/software/pulseaudio/doxygen/simple.html
Linux sound drivers - http://www.tldp.org/HOWTO/Sound-HOWTO/

Introduction to Audio programming -

How Audio Data is Represented - http://blogs.msdn.com/b/dawate/archive/2009/06/22/intro-to-audio-programming-part-1-how-audio-data-is-represented.aspx
Demystifying the WAV Format - http://blogs.msdn.com/b/dawate/archive/2009/06/23/intro-to-audio-programming-part-2-demystifying-the-wav-format.aspx
An Introduction to Audio Processing Objects - http://msdn.microsoft.com/en-us/magazine/dn201755.aspx
Synthesizing Simple Wave Audio using C# - http://blogs.msdn.com/b/dawate/archive/2009/06/24/intro-to-audio-programming-part-3-synthesizing-simple-wave-audio-using-c.aspx
Algorithms for Different Sound Waves in C# - http://blogs.msdn.com/b/dawate/archive/2009/06/25/intro-to-audio-programming-part-4-algorithms-for-different-sound-waves-in-c.aspx

C/C++ wav processing sample code - https://android.googlesource.com/platform/frameworks/av/+/jb-dev/cmds/stagefright/

Linux pcm audio sample code - http://www.alsa-project.org/alsa-doc/alsa-lib/_2test_2pcm_8c-example.html

Android audio native programming using OpenSL ES - http://audioprograming.wordpress.com/2012/03/03/android-audio-streaming-with-opensl-es-and-the-ndk/

Android API for record/play audio(example: pcm): AudioRecord, AudioTrack -

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 is expected to usher in automation in nearly all fields.

(IoT) is the network of physical objects accessed through the Internet as defined by technology analysts and visionaries. These objects contain to interact with or the . 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 to .

The IoT needs . Popular are CoAP, MQTT, or . Two of the most promising for small devices are -

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 () . Like , CoAP is a document transfer protocol. Unlike HTTP, CoAP is designed for the needs of constrained devices. CoAP packets are much smaller than HTTP flows. 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 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 . CoAP allows UDP broadcast and multicast to be used for addressing. CoAP follows a . Clients make requests to servers, servers send back responses. Clients may resources. CoAP is designed to interoperate with HTTP and the at large through simple proxies. As CoAP is datagram based, it may be used on top of and other packet based communications protocols. tinydtls is a library for Datagram Transport Layer Security () 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 designed for lightweight M2M communications. It was originally developed by 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 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 . 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 -

ref:

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

() - http://openinterconnect.org/

- https://allseenalliance.org/

source code download - https://allseenalliance.org/developers/download

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

- iot.eclipse.org— Standards

- http://www.threadgroup.org/

- http://www.iiconsortium.org/

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

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

IoT overview -

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

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

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

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

- http://iot.eclipse.org/java/download/

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

- 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 , 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 , as well as 14 that accommodate various .

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

, avr-g++, , 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

- 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++ -

- http://www.visualmicro.com/

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

- 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

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

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

Arduino Cookbooks -

-

Functional Programming Overview

Functional programming is a style of programming which models computations as the evaluation of expressions. Functional Programming is when functions, not objects or procedures, are used as the fundamental building blocks of a program. Functions in this sense, not to be confused with 'C' language functions which are just procedures, are analogous to mathematical equations: they declare a relationship between two or more entities. Functional Programming, however, is not about mathematics but about abstraction and reducing complexity: as such, it provides a powerful paradigm in which to tackle complex, real-world programming tasks.

From pragmatic perspective, a beginner needs to understand only two concepts(Immutability and statelessness) in order to use it for everyday Functional Programming applications -

First, data in functional programs should be immutable, which sounds serious but just means that it should never change. At first, this might seem odd (after all, who needs a program that never changes anything?), but in practice, you would simply create new data structures instead of modifying ones that already exist. For example, if you need to manipulate some data in an array, then you’d make a new array with the updated values, rather than revise the original array. Easy!

Secondly, functional programs should be stateless, which basically means they should perform every task as if for the first time, with no knowledge of what may or may not have happened earlier in the program’s execution. Combined with immutability, this helps us think of each function as if it were operating in a vacuum, blissfully ignorant of anything else in the application besides other functions. In more concrete terms, this means that your functions will operate only on data passed in as arguments and will never rely on outside values to perform their calculations.

The special characteristics and advantages of functional programming are often summed up more or less as follows. Functional programs contain no assignment statements, so variables, once given a value, never change. More generally, functional programs contain no side-effects at all. A function call can have no effect other than to compute its result. This eliminates a major source of bugs, and also makes the order of execution irrelevant — since no side effect can change an expression’s value, it can be evaluated at any time. This relieves the programmer of the burden of prescribing the flow of control. Since expressions can be evaluated at any time, one can freely replace variables by their values and vice versa - that is, programs are “referentially transparent”.

Prominent functional programming languages are Scheme, Haskell, OCaml, Erlang, Clojure, Racket, F#, Common Lisp, Scala ..

ref:

Functional Programming - http://en.wikipedia.org/wiki/Functional_programming

Introduction to Functional programming - http://www.smashingmagazine.com/2014/07/02/dont-be-scared-of-functional-programming/

Why Functional Programming matters - http://www.cse.chalmers.se/~rjmh/Papers/whyfp.pdf, http://worrydream.com/refs/Hughes-WhyFunctionalProgrammingMatters.pdf

Conception, Evolution, and Application of Functional Programming Languages - http://www.utdallas.edu/~kXh060100/cs6301fa14/p359-hudak.pdf

Functional programming: A step backward - http://www.javaworld.com/article/2078610/java-concurrency/functional-programming--a-step-backward.html

erlang documentation - http://www.erlang.org/doc/pdf/otp-system-documentation.pdf

Haskell - http://www.haskell.org/haskellwiki/Haskell

Misc -

Bluetooth Technology Overview

Bluetooth is a wireless technology for creating personal networks operating in the , with a range of 10 meters. Networks are usually formed ad-hoc from portable devices such as cellular phones, handhelds, and laptops. Unlike , Bluetooth offers higher level service profiles, such as FTP-like file servers, , voice transport, serial line emulation, and more. RFCOMM(Radio Frequency Communication) protocol provides emulation of serial ports over the . RFCOMM is a simple transport protocol, with additional provisions for emulating the 9 circuits of RS-232 (EIATIA-232-E) serial ports. It supports up to 60 simultaneous connections (RFCOMM channels) between two Bluetooth devices. RFCOMM is intended to cover applications that make use of the serial ports of the devices in which they reside. The communication segment is a direct connect Bluetooth link from one device to another.

Bluetooth Low Energy(BLE) or Bluetooth LE, marketed as Bluetooth Smart, is a wireless personal area network technology designed and marketed by the . Compared to , Bluetooth Smart is intended to provide considerably reduced power consumption and cost while maintaining a similar communication range. Bluetooth Smart uses the same 2.4 GHz radio frequencies as Classic Bluetooth, which allows dual-mode devices to share a single radio antenna. LE does, however, use a simpler modulation system. is the creation of dual-mode capabilities that allow for classic Bluetooth operation as well as Bluetooth low energy support – the best of both worlds. The latest Bluetooth specification uses a service-based architecture based on the attribute protocol (ATT). All communication in low energy takes place over the Generic Attribute Profile (GATT). An application or another profile uses the GATT profile so a client and server can interact in a structured way.The server contains a number of attributes, and the GATT Profile defines how to use the Attribute Protocol to discover, read, write and obtain indications. These features support a service-based architecture. The services are used as defined in the profile specifications. GATT enables you to expose service and characteristics defined in the profile specification.The GATT profile is also part of the core and defined in the core specification.

BlueZ: BlueZ is the Bluetooth stack for Linux kernel-based family of operating systems.

BlueZ BLE "C" API:

hci_le_set_scan_enable

hci_le_set_scan_parameters

hci_open_dev

BlueZ Bluetooth "C" API:

hci_inquiry

hci_open_dev

BLE "C" Programming Overview:

Call hci_le_set_scan_parameters to set options, setsockopt(SOL_HCI, HCI_FILTER, filter) to just get LE scan events and then callhci_le_set_scan_enable to turn on scanning(there's a function called hci_get_route to get an available device number). Each device connection was made with a socket(AF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP) which you then tell to connect to a particular device by calling connect on the socket with a struct sockaddr_l2 that has the particular device address in it.

ref:

Bluetooth specifications -

Bluetooth SIG(Special Interest Group) - https://www.bluetooth.org/en-us

Bluetooth developer portal - https://developer.bluetooth.org/TechnologyOverview/Pages/RFCOMM.aspx

BLE(Bluetooth Low Energy) - http://en.wikipedia.org/wiki/Bluetooth_low_energy

Bluetooth libraries - http://www.jenkinssoftware.com/raknet/manual/bluetooth.html

Linux Bluetooth library , BlueZ - http://www.bluez.org/

Introduction to Bluetooth programming - http://people.csail.mit.edu/albert/bluez-intro/

Best Practices for Bluetooth Development - http://commondatastorage.googleapis.com/io-2013/presentations/129%20-%20Bluetooth%20Best%20Practices.pdf

Bluetooth Specification RFCOMM with Application - http://hccc.ee.ccu.edu.tw/courses/bt/vg/rfcomm.pdf

Linux Bluetooth code -