The Wandboard is a ultra low power complete computer with high performance multimedia capabilities based around the new upcoming Freescale i.MX6 Cortex-A9 processor and comes with a dazzling 1Ghz processor HDMI display interface and gigabit ethernet. The dualcore version of the Wandboard (The Wandboard DUAL) not only features 1GB of memory but also has onboard Wi-Fi and Bluetooth.     Wandboard Solo Wandboard Dual Processor Freescale i.MX6 Solo Freescale i.MX6 Duallite Cores Cortex-A9 Single core Cortex-A9 Dual core Memory 512 MB DDR3 1 GB DDR3 Audio • • Optical S/PDIF • • HDMI • • Camera interface • • micro SD cardslot 2 2 Serial port • • Expansion Header • • USB • • USB OTG • • SATA connector Not populated Not populated Gigabit LAN • • WIFI (802.11n) • Bluetooth • 69 USD 89 USD   www.wandboard.org Contact person : wandboard@gmail.com

NOVPEK TM i.MX6Q/D System Download the NOVPEK i.MXQ/D Brochure Includes NOVPEK TM i.MX6Q/D Module 201 easily accessible IOMUX pins Arranged in 32x2 100mil pin headers Advanced Power Management (PM) development support via Add-on Card, various PM options available Multiple voltage settings for each peripheral voltage rail Accurate power consumption analysis framework for all 35 voltage rails on the i.MX6Q/D On-board debug ports: JTAG and 16bit ETM Bootable with terminal support RS232 and TTL interfaces, only uses two i.MX6Q/D pins All i.MX6Q/D boot options Simplified firmware/software development through 10/100 Ethernet port SPI based, doesn’t consume the built-in FEC USB HOST port and USBOTG port that can be forced to HOST mode HDMI video out port SATA interface LVDS interface PCI Express Mini PCIe with SIM slot MIPI/SDI interface Highly integrated NovTech PM solution Multiple power-on events Reprogrammable for configurability   For more information click here  

Hi all, Below is our press release for our i.MX6 solutions, i.e., kits and boards. emtrion GmbH, a company specialised in Embedded Systems design, hardware and software, Freescale Proven Partner, announces the availability of a new industrial processor module based on the multicore Cortex-A9 i.MX6 SoC family from Texas Instruments. This new module, called DIMM-MX6, extends the emtrion DIMM family and offers a full electrical and mechanical compatibility with the other modules of the emtrion DIMM series. emtrion guarantees the availability of its new module for at least 10 years. The DIMM-MX6 module from emtrion brings high computing capabilities with up to 10.000 DMIPS, multiple NEON SIMD and VPFU co-processors at a low power level, without requiring any active cooling system. The DIMM-MX6 module is available in several versions, with either i.MX6 Solo (1 core), Dual (2 cors) or Quad (4 cores) and on-board memories ranging from 512MB up to 8GB for the Flash (SLC NAND) and from 512MB up to 2GB RAM (DDR3). The new module is also qualified for an extended temperature range of -40°C to +85°C. In addition to boards and kits, emtrion offers support for a broad range of operating systems, board support packages (BSP) as well as engineering services. The DIMM-MX6 is available now with a BSP for Linux, that will be followed by additional BSP for Windows Embedded Compact 7 (WEC7), for QNX 6.5 and for Android 4.0. The BSP are available together with a developer kit. Each developer kit includes a DIMM-MX6 industrial module, a base board, a display and a development environment. All parts are mounted together and programmed by emtrion. The kits are shipped ready to use.

This document will explain Cairo setup to draw something on screen with hardware accelerates using OpenGL ES 2.0 or OpenVG.   Introduction:   As you know you can use those libraries that I mentioned (OpenGL ES and OpenVG) to draw on frame buffer with hardware accelerate on imx6q but using those libraries are a little bit hard to deal what I mean is that using OpenGL or OpenVG  is a kind of tough job but why? Let me bring an example here to clarify it, Imagine you want to draw an attitude aircraft symbol, this symbol needs some of elements to be drawn to look like a complete attitude symbol it includes: 1-Circle 2-line 3-Text 4-Triangle 5-some custom shapes for instance two L like lines that draw horizontally   If you have an experience with OpenGL specially OpenGL ES you’ll realize that drawing circle, line, triangle and so forth doesn’t a really tough job, of course drawing these primitive in OpenGL needs more lines of code in contrast with Cairo API that you can draw them with just three lines of code but the most hard job is drawing TEXT in OpenGL when you want to draw a simple text you have to deal with extra libraries like freetype,… to fetch the glyph features and then you can using atlas approach to draw text in a bitmap texture then when you need a character in your app  you can access to the character’s position in previous stored glyph in the texture, fetch and use, also you need to work with two specific OpenGL ES shaders in this case.   So I think it’s ok to use OpenGL or OpenVG to draw shapes if you are really skilled with those or if you looking for trouble! 😄 personally I prefer to use a high level API and then focus on other aspect of my application.   Compiling Cairo:   This document doesn’t intend to configure or compile Cairo, I’m sure that you can easily configure and compile it with OpenGL ES backend with YOCTO, Buildroot or any other embedded Linux distribution builders (YOCTO and Buildroot aren’t an embedded Linux distributions they can make custom one for you) even you can compile it manually.   To configure: ./configure --prefix=/home/super/Desktop/ROOTFS/MY_ROOTFS/usr --host=${CROSS_COMPILE} CFLAGS="-I/home/super/Desktop/ROOTFS/MY_ROOTFS/usr/include/ -DLINUX -DEGL_API_FB" LIBS="-L/home/super/Desktop/ROOTFS/MY_ROOTFS/usr/lib/ -lz" --enable-xlib=no --enable-egl --enable-glesv2   To compile: make     By the way you can find your suitable configuration for your own board; Cairo has a lot of options.     How to make surface for Cairo:   If you have an experience drawing shapes with Cairo you know that you need a surface from cairo_t* type to drawing function API can work on and shapes appear on the screen. To create a Cairo surface that uses OpenGL ES you have to configure EGL (EGL is an interface between Khronos rendering APIs (such as OpenGL, OpenGL ES or OpenVG) and the underlying native platform windowing system)[1] correctly and then make a Cairo surface from it.                    EGLint config_attributes[] =                 {                                                EGL_RENDERABLE_TYPE,                                                EGL_OPENGL_ES2_BIT,                                                EGL_RED_SIZE, 8,                                                EGL_GREEN_SIZE, 8,                                                EGL_BLUE_SIZE, 8,                                                EGL_ALPHA_SIZE,EGL_DONT_CARE,                                                EGL_SURFACE_TYPE,EGL_WINDOW_BIT,                                                EGL_DEPTH_SIZE, 16,                                                EGL_SAMPLES,      4,                                                EGL_NONE                 };   When you want to change OpenGL ES v 2.0 with OpenVG it’s enough that change the parameter of EGL_RENDERABLE_TYPE (that is EGL_OPENGL_ES2_BIT) to EGL_OPENVG_BIT.   The below code will appear Figure 1 on screen:     Figure 1:Simple drawing by Cairo on IMX6Q     //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   //======================================================================== // Name        : testCairo.cpp // Author      : Ali Sarlak // Version     : 1.0 // Copyright   : GPL // Description : EGL+Cairo GLIB //========================================================================   #include <iostream> #include <stdio.h> #include <EGL/egl.h> #include <EGL/eglext.h> #include <EGL/eglplatform.h> #include <cairo/cairo-gl.h> #include <EGL/eglvivante.h> #include <stdlib.h>     #define DISPLAY_WIDTH 640 #define DISPLAY_HEIGHT 480 using namespace std;   int main() {     printf("START\n");     printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");     EGLContext eglContext;     EGLSurface eglSurface;     EGLBoolean resultB;       /* Get a display handle and initalize EGL */     EGLint major, minor;     EGLDisplay eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);       resultB = eglInitialize(eglDisplay, &major, &minor);       EGLint config_attributes[] =     {             EGL_RENDERABLE_TYPE,             EGL_OPENGL_ES2_BIT,             EGL_RED_SIZE, 8,             EGL_GREEN_SIZE, 8,             EGL_BLUE_SIZE, 8,             EGL_ALPHA_SIZE,EGL_DONT_CARE,             EGL_SURFACE_TYPE,EGL_WINDOW_BIT,             EGL_DEPTH_SIZE, 16,             EGL_SAMPLES,      4,             EGL_NONE     };       EGLint numberConfigs = 0;     EGLConfig* matchingConfigs=NULL;       if (EGL_FALSE             == eglChooseConfig(eglDisplay, config_attributes, NULL, 0, &numberConfigs))     {         printf("eglChooseConfig EROR\n");     }     if (numberConfigs == 0)     {         printf("eglChooseConfig EROR\n");     }       printf("number of configs = %d\n", numberConfigs);     /* Allocate some space to store list of matching configs... */     matchingConfigs = (EGLConfig*) malloc(numberConfigs * sizeof(EGLConfig));       if (EGL_FALSE  == eglChooseConfig(eglDisplay, config_attributes, matchingConfigs, numberConfigs, &numberConfigs))     {         printf("eglChooseConfig EROR\n");         if(matchingConfigs!=NULL)         {             free(matchingConfigs);             matchingConfigs=NULL;         }         return -1;     }       printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");       EGLint display_attributes[] =     {             EGL_WIDTH, DISPLAY_WIDTH,             EGL_HEIGHT, DISPLAY_HEIGHT,             EGL_NONE };       /*Window attributes*/     EGLint window_attribList[] =     {             EGL_NONE     };       EGLNativeDisplayType eglNativeDisplayType = fbGetDisplay(0);       EGLNativeWindowType eglNativeWindow = fbCreateWindow(eglNativeDisplayType,             0,             0,             DISPLAY_WIDTH,             DISPLAY_HEIGHT);       eglSurface = eglCreateWindowSurface(eglDisplay,matchingConfigs[0],eglNativeWindow,window_attribList);       if (eglSurface == EGL_NO_SURFACE)     {         printf("eglSurface = %x\n", eglGetError());     }       const EGLint attribListCtx[] =     {             // EGL_KHR_create_context is required             EGL_CONTEXT_CLIENT_VERSION, 2,             EGL_NONE     };       eglContext = eglCreateContext(eglDisplay, matchingConfigs[0], EGL_NO_CONTEXT,  attribListCtx);      //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~     if (eglContext == EGL_NO_CONTEXT)     {         printf("eglContext = %x\n", eglGetError());         return -1;     }       cairo_device_t* cdt = cairo_egl_device_create(eglDisplay, eglContext);       eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext);       cairo_surface_t *surface = cairo_gl_surface_create_for_egl(cdt, eglSurface,             DISPLAY_WIDTH,DISPLAY_HEIGHT);         cairo_t *cr = nullptr;     cr = cairo_create(surface);     if(!cr)     {         printf("Wrong cairo_t!\n");         return -1;     }     //*********************************************************************************************     for (int index = 0; index < 1; ++index) {         cairo_set_source_rgb (cr, 0, 0, 0);           cairo_move_to (cr, 0, 0);         cairo_line_to (cr, 200, 200);         cairo_move_to (cr, 200, 0);         cairo_line_to (cr, 0, 200);         cairo_set_line_width (cr, 1);         cairo_stroke (cr);           cairo_rectangle (cr, 0, 0, 100,100);         cairo_set_source_rgba (cr, 1, 0, 0, 0.8);         cairo_fill (cr);          cairo_rectangle (cr, 0, 100, 100, 100);         cairo_set_source_rgba (cr, 0, 1, 0, 0.60);         cairo_fill (cr);          cairo_rectangle (cr, 100, 0, 100, 100);         cairo_set_source_rgba (cr, 0, 0, 1, 0.40);         cairo_fill (cr);          cairo_rectangle (cr, 100, 100, 100, 100);         cairo_set_source_rgba (cr, 1, 1, 0, 0.20);         cairo_fill (cr);          cairo_surface_flush(surface);         eglSwapBuffers(eglDisplay,eglSurface);     }       //to check that cairo can make the photo from the surface, png file created     cairo_status_t s = cairo_surface_write_to_png(surface, "surface.png");     //it is a photo that made by cairo [OK]     cairo_destroy(cr);      if (CAIRO_STATUS_SUCCESS == s)     {         printf("Status = OK \n");     }     else     {         printf("Status = ERROR <ERROR_CODE->%d>\n", s);     }      if(matchingConfigs!=NULL)     {         free(matchingConfigs);         matchingConfigs=NULL;     }       cairo_surface_destroy(surface);     printf("END!\n");     return 0; }     How To Be Sure That My Application Using GPU:   If you have a look at https://community.nxp.com/thread/324670 you can profile a graphical application and investigate if it uses GPU or not, also you can measure the performance and analyze the application by vAnalyzer.       According to the link I’ve mentioned that’s enough to set galcore.gpuProfiler=1 in uboot and then check the /sys/module/galcore/parameters/gpuProfiler   file (read the file by cat, vi, nano, etc.) if the output is 1 all things is done in a right way the final step is that exporting some environment variables :   export VIV_PROFILE=1 export VP_OUTPUT=sample.vpd export VP_FRAME_NUM=1000 export VP_SYNC_MODE=1   VIV_PROFILE[0,1,2,3], VP_OUTPUT[any string], VP_FRAME_NUM[1,N], VP_SYNC_MODE[0,1]   Note: VIV_PROFILE[0] Disable vProfiler (default), VIV_PROFILE [1] Enable vProfiler, VIV_PROFILE [2] Control via application call, VIV_PROFILE [3]Allows control over which frames to profile with vProfiler by VP_FRAME_START and VP_FRAME_END.     If application uses GPU smaple.vpd file will create if not there isn't any vpd file. [1] - https://www.khronos.org/egl

iWave, a reliable embedded solutions provider has now optimized the booting time of its Windows Embedded Compact 7 (WEC7) BSP for Freescale’s SABRE SDP/B platform. Now the WEC7 OS is booting in a short period of time  ~3 seconds for a small footprint OS image with display and touch drivers support, and boot time of ~8 to ~10 seconds for an OS image with basic drivers and OS components support. Why boot time optimization? WinCE7 is a real time OS which will be used in performance-critical applications such as automotive and healthcare units. In most of the cases, booting time will play important role, e.g. if the device is used in rear-view camera system in automotive field, the user needs the device to start working as soon as the reverse-gear is applied. This requirement needs the device to boot and start the camera application within few seconds. This demands a very short OS boot time. Some of the techniques which can be applied for efficient boot time optimization are discussed in this article. Boot phases in WEC7: Boot-loader (eboot) Copying of OS image from booting device (e.g. Micro-SD) to RAM OAL Layer Driver initializations and file system mounting Guidelines for reducing the boot time in different booting phases of WEC7: Boot-loader (eboot): Remove the code that initializes a hardware which is not required in boot-loader. E.g. If booting device is micro-SD, the initialization of NAND is not necessary. So, this redundant code needs to be removed. The eboot menu in eboot is important for debugging of WEC7 OS. But it is not needed in an end product. So, the delay for this eboot menu can be completely removed to reduce 3 seconds of time. In few platforms such as Freescale’s SABRE platform, a default splash screen is used, which updates continuously. This can be removed, and a static splash screen can be displayed, which can save a few milliseconds of time. Remove unnecessary serial debug prints. Copying of OS image from booting device (e.g. Micro-SD) to RAM: This time increases as the size of WEC7 OS image increases. So, select the OS components carefully and remove redundant components from OS image so that the OS image can be copied to RAM quickly. Also remove unnecessary registry keys, dlls and libraries to reduce the OS size. Optimize binary image builder (.bib) file to reduce the run-time image file. Implement Multi-BinFS OS binaries to reduce the OS copying size. As the functionalities/driver supports goes on increasing, WEC7 image size increases. So, the time required to copy the image increases, and RAM size needed to store the OS image increases. The Binary ROM Image File System (BinFS) can fix the two issues. In a BinFS file system, the WEC7 OS binary is divided into multi-binary Image files, and only the one binary (less than 5MBs) is copied into the RAM by the boot-loader. The components in the other binary files are copied into the RAM only when they are required to run. Links that can be referred to implement multi-BinFS in WinCE:      MSDN documentation: http://msdn.microsoft.com/en-us/library/aa516960.aspx; An implementation guide by Freescale: http://cache.freescale.com/files/dsp/doc/app_note/AN4137.pdf You can also include compressing-decompressing mechanisms in boot-loader to achieve even shorter copying time. OAL layer: Remove the code that does unnecessary hardware implementations. Skip the initializations that already done in eboot. Remove any wait/loop/delay if exists. Remove unnecessary serial debug prints. Driver initializations and file system mounting: Analyse and remove all the redundant drivers, check for any loop, wait or delay sequences in driver initialization code. Load any applicable drivers (e.g. USB, sensors) after the OS boot (i.e. after user sees a desktop/application). In WEC7 OS, a driver can be either loaded during booting using device manager/GWES, or can be loaded dynamically whenever necessary. This can be achieved easily by changing the registry key configurations to remove the driver from built-in drivers, a small application to load the driver after OS boot-up, and registry settings to launch this application automatically once the OS is booted. To decide the load order, it is important to check the dependencies of/on a driver. Use appropriate splash screen/progress bar while user waits for OS booting. Remove unnecessary serial debug prints. By effectively following the techniques mentioned, WEC7 based platforms can achieve reduced boot time for quick application access. iWave has optimized the WEC7 booting time on Freescale’s SABRE SDP platform. The booting time is as low as ~3 seconds for a WEC7 OS with standard shell, LCD display, DDraw, I2C and touch driver support, and ~8 to 10 seconds for WEC7 OS with following components: Standard shell Display DDRAW Capacitive touch screen MicroSD USB host – Mass storage and HID Ethernet GPU (OpenVG/GL) Multimedia codecs DirectShow Audio Video Playback Ambient Light Sensor Accelerometer SMP PWM Backlight I2C Debugging using KITL For further information or inquiries please write to mktg@iwavesystems.com or visit www.iwavesystems.com

NXP i.MX8M Mini SoC, quad-core ARM Cortex-A53, 1.8GHz Integrated 2D/3D GPU and 1080p VPU Up to 4GB LPDDR4 and 64GB eMMC Certified dual-band WiFi 802.11ac, BT 4.2 GbE, PCIe, 2x USB, 4x UART, 60x GPIO Tiny size and weight - 28 x 38 x 5 mm, 7 gram Yocto Linux and Android - BSPs and ready-to-run images Industrial temperature range: -40° to 85° C 10-year availability CompuLab's UCM-iMX8M-Mini is a miniature System-on-Module board designed for integration into industrial embedded applications. Measuring just 28 x 38 mm, UCM-iMX8M-Mini is an ideal solution for space constrained and portable systems. UCM-iMX8M-Mini Detailed Spec UCM-iMX8M-Mini Development Kit UCM-iMX8M-Mini Online Pricing

iMX6Q SABRE Lite WEC2013 Solution from Adeneo Embedded

Measuring only 70mm by 55mm, the MYS-6ULX designed by MYIR is a high-performance low-cost Single Board Computer (SBC) specially designed for industry and Internet of Things (IoT) applications. It is based on NXP i.MX 6UL/6ULL processor family which features the most efficient ARM Cortex-A7 core and can operate at speeds up to 528 MHz. The MYS-6ULX Single Board Computer supports Yocto and Debian OS. Here we take Debian OS as an example.   The programming procedure:      Prepare an SD card. Open the image file of OS “mys6ull-debian8.rootfs.sdcard” with Win32Disk Imager, then program it into the SD card.      Power on the MYS-6ULX board. Insert the SD card to the slot, set the dip switch to 0101. Connect the serial port cable and USB power cable to the board, then power on the board.      Login in the system. The user name is root and the pass word is 123456. View the system information with command cat/etc/issue, the system version is Debian8 as shown below, which means the OS has been programmed into the SD card successfully. The develop environment I work on PC is Ubuntu VMS, ARMGCC compiler is needed to be installed in the Ubuntu VMS. We can check if the compiler is available with instruction arm-linux-gnueabihf-gcc–v. Ubuntu16 comes with a 5.4 version compiler as below: We need to install a compiler if the system doesn’t come with one. The toolkit MYIR provided contains that compiler. Open the folder 03-Tools\Toolchain, there is a package named “gcc-linaro-4.9-2014.11-x86_64_arm-linux-gnueabihf.tar.xz”. Copy this package into a folder of VMS and use commands below to extract it. xz -dgcc-linaro-4.9-2014.11-x86_64_arm-linux-gnueabihf.tar.xz tar -xfgcc-linaro-4.9-2014.11-x86_64_arm-linux-gnueabihf.tar We would have a file named gcc-linaro-4.9-2014.11-x86_64_arm-linux-gnueabihf after unpacking, then use instruction below to set the compiler: export PATH= $PATH:$DEV_ROOT/\gcc-linaro-4.9-2014.11-x86_64_arm-linux-gnueabihf/bin exportCROSS_COMPILE=arm-linux-gnueabihfexport ARCH=arm View the compiler version again, the information printed on the screen should be: We can see the compiler version is 4.9.3. Then all the settings of develop environment has been completed.

iWave Systems Technologies Pvt. Ltd., a leading innovative Embedded Product Engineering Services company headquartered in Bangalore, launches “i.MX 6 SBC - Industry's latest Pico ITX Board around Freescale Semiconductor’s i.MX 6 Solo/Dual Lite processor which is iWave’s 4th i.MX 6 based design” on 26-02-2013 in Embedded World 2013 Nuremberg Germany. Measuring just 10cm x 7.2cm, iWave’s i.MX6 SBC is a highly integrated platform for increased performance in “Intelligent Industrial Control Systems, Industrial Human Machine Interface, Ultra Portable Devices, Home Energy Management Systems and Portable Medical Devices”. The i.MX 6 Solo/Dual Lite with ARM Cortex™-A9 single/dual cores running up to 1.0 GHz includes 2D and 3D graphics processors, 1080p video processing, and integrated power management. Each processor provides 32/64-bit DDR3/LVDDR3/LPDDR2-800 memory interface and a number of other interfaces for connecting peripherals, such as WLAN, Bluetooth™, GPS, hard drive, displays, and camera sensors. iWave’s new i.MX6 Solo/ Dual Lite based Pico ITX SBC integrates all standard interfaces into a single board with ultra-compact platform that can be utilized across multiple embedded PCs, systems and industrial designs. The i.MX6 SBC from iWave with its features like DDR3 RAM, Dual Display, Dual camera inputs, Gigabit Ethernet, Micro SD & SD slots, Dual USB 2.0 hosts, USB 2.0 OTG, Audio Out/In & serial interfaces, enables developers/users to quickly develop/implement their application needs around i.MX6 processor and optimize the “development effort and time to market” of their products. The i.MX6 SBC from iWave helps to reduce system cost, supports ultra-small form factor, wide operating temperature range from -20 0 C to +85 0 C and is backed with a minimum five years longevity support. Highlights of iWave’s i.MX6 SBC: ARM Cortex A9@ 1GHz Dual Lite/Solo core 10cm x 7.2cm Pico-ITX form factor Single Board Computer HD 1080p encode and decode,3D video playback in high definition Includes HDMI v1.4, MIPI and LVDS display ports, MIPI camera, Gigabit Ethernet, multiple USB 2.0 and PCI Express Comprehensive security features include cryptographic accelerators, high-assurance boot and tamper protection Technical &quick customization support with 5+ years, Long term support About iWave Systems: iWave has been an innovator in the development of “Highly integrated, high-performance, low-power and low-cost i.MX6/i.MX50/i.MX53/i.MX51/i.MX27 SOMs”. iWave helps its customers reduce their time-to-market and development effort with its products ranging from System-On-Module to complete systems. The i.MX6 Pico ITX SBC is brought out by iWave in a record time of just 5 weeks. Furthermore, iWave’s i.MX6/i.MX50/i.MX53/i.MX51/i.MX27 SOMs have been engineered to meet the industry demanding requirements like various Embedded Computing Applications in Industrial, Medical & Automotive verticals. iWave provides full product design engineering and manufacturing services around the i.MX SOMs to help customers quickly develop innovative products and solutions. For more details, please visit: http://www.iwavesystems.com/product/development-platform/i-mx6-pico-itx-sbc/i-mx6-pico-itx-sbc.html email: mktg@iwavesystems.com

Freescale i.MX6 UltraLite processor, 528MHz Up to 1GB DDR3 and 32GB on-board eMMC Dual-band 802.11a/b/g/n WiFi and BT 4.1 BLE Ethernet, 5x USB, 8x UART, 2x CAN, SDIO, 78x GPIO Miniature size - 36 x 68 x 5 mm               CL-SOM-iMX6UL​ is a tiny System-on-Module (SoM) / Computer-on-Module (CoM) board designed to serve as a building block in embedded applications. CL-SOM-iMX6UL is build around the Freescale i.MX6 UltraLite system-on-chip featuring an advanced Cortex-A7 ARM CPU. The SoC is coupled with up-to 1GB DDR3 and 32GB of on-board eMMC storage. The processor is supplemented with up-to 4GB DDR3 and 32GB of on-board SSD. Measuring only 36 x 68 x 5 mm CL-SOM-iMX6UL features a wide range of industry standard interfaces - Ethernet, WiFi 802.11, Bluetooth, USB, CAN bus, serial ports, I/O lines and ADC inputs. Low price makes CL-SOM-iMX6UL an ideal selection for cost-sensitive systems, while its small size and low power consumption facilitate integration into portable and space-constrained designs. CL-SOM-iMX6UL is provided with comprehensive documentation​ and full ready-to-run SW support for Linux operating system. CL-SOM-iMX6UL Detailed Spec​ CL-SOM-iMX6UL Block Diagram​ CL-SOM-iMX6UL Development Kit​ CL-SOM-iMX6UL Online Pricing​

iWave Systems, AI/ML demo shows a low power smart door running eIQ heterogeneously on NXP i.MX 8M Mini Development kit. The demo application is built around the Django framework running on the board. In addition to face recognition, the MPUs are able to run a Django server to manage the user’s database, a QT5 application for the graphical interface, and perform training on the edge.

ConnectCore® i.MX53 / Wi-i.MX53 Freescale i.MX53 Cortex A8 system-on-module The network-enabled ConnectCore for i.MX53 is a highly integrated and future-proof system-on-module (SoM) solution based on the new Freescale i.MX53 application processor with a high performance 1 GHz ARM Cortex-A8 core, wired and wireless connectivity, powerful 1080p/720p video encoding/decoding capabilities, dual-CAN bus interface and a complete set of peripherals.   The ConnectCore for i.MX53 family builds on the successful ConnectCore for i.MX51 modules by providing a form factor compatible option with significantly improved processing, memory, video and connectivity capabilities. It is a scalable and energy-efficient module family that is ideal for medical devices, security/surveillance equipment, industrial applications, kiosk systems and digital signage integration. Modules in the ConnectCore i.MX family feature the design, development and administrative advantages offered by the iDigi® Device Cloud™. This secure, highly scalable platform seamlessly ties enterprise applications and remote devices together.   iDigi Manager Pro empowers IT, network operations and customer support organizations to conquer the challenges of managing equipment in their device networks. Network managers can remotely configure, upgrade, monitor and troubleshoot remote devices, and create applications that improve productivity, speed and efficiency.   Integrated secure wireless 802.11a/b/g/n Wi-Fi WLAN Powerful 2D/3D graphics, 1080p video Support for Embedded Linux, Microsoft Windows Compact 7 and Android Industrial operating temperature system-on-module (SoM) Secure, anywhere management using iDigi Manager Pro™   http://www.digi.com/products/wireless-wired-embedded-solutions/solutions-on-module/connectcore/connectcore-wi-mx53#overview

e-con Systems announces the launch of eSOMiMX7 System on Module. The eSOMiMX7 is based on NXP/Freescale i.MX7 processor. eSOMiMX7 is a ready to use System-On-Module using Solo / Dual core ARM® Cortex™ A7 @ 1GHz along with dedicated real time ARM® Cortex™ - M4 MCU. It encompasses eMMC Flash whose capacity ranges from 4GB to 64GB, LPDDR3 with capacity as high as 2GB. To cater to the customer's demand of a small SOM for building IoT Applications, Industrial HMI, Test and Measurement, Industrial HMI, eBook Reader and  Wearables, eSOMiMX7 is launched with a small form factor of 55mm x30mm. eSOMiMX7 is an ultra-low power system on module which consumes only 3mA current during the deep sleep mode. eSOMiMX7 System-On-Module is available with latest Linux Kernel version v4.9.11, latest Yocto rootfs version 2.2 and Free RTOS version 8. Pricing and Availability: The eSOMiMX7 at volumes is available at USD34 onwards and samples can be bought from the Webstore. Evaluation kit: Customers  willing to evaluate the eSOMiMX7, can evaluate using the EVM, Acacia - eSOMiMX7 development kit from e-con Systems' Webstore.

We are delighted to announce the launch of a very special Micro SOM, eSOMiMX6-micro. This high performance system on module is based on NXP i.MX6 Quad/Dual ARM Cortex-A9 Processor. Meissa-I, the evaluation kit for this iMX6 Micro SOM is also the smallest RDK in the industry. The customer who wanted a low power micro SOM for building their ultra-compact devices like Wearables, Medical Imaging, Handhelds etc, we have our eSOMiMX6-micro system on module which based on NXP i.MX6 Quad/Dual Core ARM Cortex-A9 processor in a small form factor of 54mm x 20mm with 10mA in suspend current. eSOMiMX6-micro: iMX6 Micro System-on-Module To get more details on this product, please visit: https://www.e-consystems.com/iMX6-micro-som-system-on-module.asp

NXP MCU-level face recognbition solution is implemented by using i.MX RT106F, which makes the developers add face recognition capabilities to their MCU-based IoT products. This ultra-small size, integrated software algorithm and hardware solution can facilitate developers for rapid evalution and proof of concept development. This solution minimizes time to market, reduces risk and reduces development work, which can make it easier for many OEMs to add face recogtion functions. It provides advanced user interface and access control functions for smart homes, smart appliances, smart toys and smart industries without the need for Wi-Fi and cloud connectivity, solving the privacy issues of many consumers. i.MX RT106F is a member of the i.MX RT1060 series. It will be officially mass-produced in April 2020. It is mainly aimed at low-cost face recognition applications. It is based on the Arm Coretx-M7 core and a high-performance real-time processor with a frequency up to 600MHz. In addition to the face recognition function, the i.MX RT106F also has a large number of available peripherals, which can be used as the main chip for a variety of applications. i.MX RT106F has been licensed to run NXP OASIS runtime for face recognition, including: ● Camera Driver ● Image capture and preprocessing ● Face Detection ● Face Tracking; ● Face Contrast; ● Face Recognition; ● Anti-fraud; ● Face Configuration; ● Confidence; ● Face recognition authenticat results; ● Built-in secure bootloader, application verification; ● Automatic Verification Script; ● Support MCUXpresso SDK, IDE and configuration tools. Hardware Framework Software Framework Core Process of Software

NXP’s i.MX6UL3 Cortex A7 based power efficient CPU integrates comprehensive security features such as TRNG, Crypto Engine (AES with DPA, TDES/SHA/RSA), Tamper Monitor, Secure Boot, SIMV2/EVMSIM interfaces, OTF DRAM Encryption, PCI4.0 pre-certification etc. This makes the i.MX6UL3 CPU as very ideal solution for the electronic point of sale (ePOS) applications. iWave Systems being one of the early adaptor of the i.MX6UL CPU, launched cost effective i.MX6UL3 based SOM for POS applications where power consumption, small form factor and security features are very critical. The IMX6UL3 SOM module is equipped with 256MB of DDR3 RAM, which is expandable up to 1GB. 256MB of NAND flash is supported on the SOM which is also expandable higher memory configuration. All the IO peripheral interfaces supported by imx6 ultra lite CPU is available through 200 pin SODIMM edge connector. i.MX6UL SODIMM Module By using the proven i.MX6UL3 SOM, a POS unit can be quickly realized by developing an application specific base board with the following features; EMV compliant Smart card, magnetic swipe reader, Thermal Printer, key pad, Finger print sensor, TFT display, 2G/3G module, Wi-Fi/BT modules, NFC reader, Micro SD card, USB OTG and battery support. iWave’s i.MX6UL development board can be used for quick POS prototyping and application development. The development kit includes Imx6ul3 SOM module,base board with multiple USB ports, Micro SD, RGB display, camera port, audio In/Out, multiple UARTs, PWM interface, I2C, GPIOs etc.This is ideal starter kit for connecting all the necessary POS specific interface modules and quick prototyping of POS application. You can kick start your POS product design with this Industry latest i.MX6UL3 SOM now by ordering the i.MX6UL development board from the following link; http://www.iwavesystems.com/product/development-platform/i-mx6ul-development-kit.html​

i.MX6 quad-core Cortex-A9 CPU, 1.2GHz Up to 4GB DDR3 and 32GB on-board SSD storage Integrated GPU and 1080p VPU, dual display support WiFi, BT 3.0, GbE, PCIe, SATA, 5x USB, 5x UART, 2x CAN Linux, Android ICS and Windows Embedded Compact 7 Miniature size - 75 x 65 x 6 mm CM-FX6-iMX6 is a tiny System-on-Module (SoM) / Computer-on-Module (CoM) designed to serve as a building block in embedded applications. CM-FX6 is based on the i.MX6 application processor featuring a highly scalable single/dual/quad core Cortex-A9 CPU at up to 1.2GHz coupled with powerful graphics and video processing units. The processor is supplemented with up-to 4GB DDR3 and 32GB of on-board SSD. In addition, CM-FX6 features a wide range of industry standard interfaces – Gigabit Ethernet, WiFi 802.11, Bluetooth, PCIe, SATA, USB, RS232 and CAN bus. CM-FX6 is provided with comprehensive documentation and full ready-to-run SW support for Linux, Android and Windows Embedded Compact 7 operating systems. CM-FX6-iMX6 Detailed Spec CM-FX6-iMX6 Block Diagram CM-FX6-iMX6 Development Kit CM-FX6-iMX6 Online Pricing

This post is about adding cellular modem support on the Boundary Devices i.MX6 boards under Ubuntu.  Many customers have requested cellular modem support on our i.MX6 boards (BD-SL-i.MX6, Nitrogen6X, Nitrogen6_Lite and Nitrogen6_MAX).  Since most cell modems are USB or PCIe devices, configuration is a software task, and mostly done in userspace. The steps are also different for Android, embedded Linux and desktop distributions.  In other words, its complicated. In this post, we’ll walk through all of the steps needed to configure a specific set of modems under Ubuntu as a reference. If you’re using another modem or another userspace, the details may be different, but the fundamentals will be the same. We used the Huawei E3131 USB dongle , and Huawei MU609 Mini-PCIe during this process, and will be adding them to our default kernels going forward. As you can see in this patch, we did have to add some USB device ids and make minor updates to the kernel as provided by the vendor. In the process, we should now also support the following Huawei models for various regions and carriers: MC323   CDMA: Downlink:153.6 kbps, Uplink: 153.6 kbps MU509   WDCMA: Downlink:3.6 Mbps, Uplink: 384 kbps MC509   EVDO: Downlink:3.1 Mbps, Uplink: 1.8 Mbps MU609   HSPA+: Downlink:14.4 Mbps, Uplink: 5.76 Mbps MU709   HSPA+: Downlink:21.6 Mbps, Uplink: 5.76 Mbps ME906   LTE: Downlink:100 Mbps, Uplink: 50 Mbps ME909   LTE: Downlink:100 Mbps, Uplink: 50 Mbps ME936   LTE: Downlink:100 Mbps, Uplink: 50 Mbps For more details including links to images as well as detailed descriptions on how to implement, please visit this blog post:  http://boundarydevices.com/cellular-modems-on-i-mx6-boards/

Connect any Android-based M2M device seamlessly with Device Cloud by Etherios and instantly build solutions for the Internet of Things (IoT). This set of libraries, plug-ins, samples and tools simplifies the development of Device Cloud applications for Android devices (Android version 2.2 and later). Easy and immediate integration of IoT cloud connectivity into applications Supports any Android device version 2.2 and greater Two-way messaging for full cloud-to-device messaging and control Device management and troubleshooting tools including configuration edits, firmware updates and device reboots Application development tools Remote file system management Secure connections Installation via Eclipse Update Manager The download includes:  Eclipse plug-ins that extend the functionality of the IDE, simplifying development Cloud Connector for Android library, including an API that allows Device Cloud communication with just a few lines of code Examples and demos (Android and Web applications), with source code included Comprehensive documentation, including a Getting Started Guide, a General Users Manual and an API reference Visit Cloud Connector for Android and download the free Cloud Connector for Android. For an overview of the Device Cloud by Etherios IoT solution, please also take a look at Device Cloud: Driving the Internet of ANYthing