Mcu category

ICP12 USBSTICK, A New Tool for Signals Control & Monitoring

iCircuit Technologies had produced the iCP12 usbStick, a mini size 28 pin USB PIC IO development board and a good tool for signal monitoring (as oscilloscope), data acquisition and circuit troubleshooting at 1mSec/Samples period.

The iCP12 usbStick is a PIC18F2550 based USB development board that comes preloaded with Microchip’s USB HID bootloader which allows users to upload an application firmware directly through a PC’s USB port without any external programmer. It provides access to its I/O pins through 0.1″ pitch headers. A slide switch is also provided on board to select the operation of the board in Bootloader or Normal mode.

The features of iCP12 are listed as following:

  • Mini size, easy interfacing, high performance and user friendly device
  • Used with PIC18F2553 28-Pin Flash USB PIC MCU
  • Excellent flexibility that allows user to expand the board with plug and play modules
  • Peripheral Features:
    • 13x IO Port (6x 12bit ADC pins, 2x 10 bit PWM/Freq/DAC pins)
    • Serial port emulation (UART Baud Rates: 300 bps to 115.2 kbps)
    • Supported operating systems (32bit/64bit): Windows XP ,Windows Vista, Windows 7, Windows 8, Windows 10, Linux, Mac OS X and Raspberry Pi
    • Maximum Voltage: 5Vdc
    • 100mA current output at VDD pin with over-current protection
    • 20MHz oscillator
    • Green LED – power on indicator
    • 2x LEDs (Green, Red) – status indicator
    • ICSP Connector – on-board PIC programming
    • Switch Mode Selection – Boot or Normal mode

The iCP12 usbStick board is shipped with a preloaded data acquisition firmware that emulates as a virtual COM port to PC. Thereafter, the communication between the PC and usbStick is serial. The firmware also supports basic I/O control and data logging feature. They provide a PC application named SmartDAQ that is specially developed to communicate with the usbStick and control its I/O pins, PWM outputs, and record ADC inputs.

SmartDAQ has a very friendly GUI with real-time waveform displays for 6 analog input channels. The time and voltage axes scales are adjustable. SmartDAQ can log the ADC data in both text and graphic form concurrently. One can utilize this feature to construct a low-cost data acquisition system for monitoring multiple analog sensor outputs such as temperature, accelerometer, gyroscope, magnetic field sensor, etc.

SmartDAQ v1.3 Features:

  • Sampling channel: 6x Analogs (12bits ADC/1mV Resolution) + 7x Digitals (Input/Output)
  • Maximum Sampling rate: 1KHz or 1mSec/Samples
  • Sampling voltage: 0V – 5V (scalable graph) at 5mV Resolution
  • Sampling period:
  • mSec: 1, 2, 5, 10, 20, 50, 100, 200, 500
  • Sec: 1, 2, 5, 10, 20, 30
  • Min: 1, 2, 5, 10, 20, 30, 60
  • Trigger Mode: Larger [>], Smaller [<], Positive edge [↑], Negative edge [↓]
  • Sampling Mode: Continuous, Single
  • Logging Function:
  • Save Format: Text, Graphic, Both
  • Start Time: Normal, Once Trigger, 24-Hour Clock (Auto Run)
  • End Time: Unlimited, Data Size, 24-Hour Clock (Auto Stop)
  • Recorded Data format: Graphic | text | excel

iCP12 is available with the PIC18F2550 for $15, and with the PIC18F2553 for $24.5. You can order it through the official page where you can also get more details about iCP12 and its source files.

You can also see this product preview to know more about its functionality.

Easy ARM Programming With 1Bitsy & Black Magic Probe

1 Bit Squared executes hardware and software design, development and manufacturing for a wide range of micro to nano UAV systems available on the market: from quadcopters to multicopters as well as airplanes, helicopters and transitioning vehicles. A Kickstarter campaign was launched to unveil  the new Black Magic Probe V2.1 with its companion demo platform 1Bitsy V1.0.

The Black Magic Probe is a JTAG and SWD Adapter used for programming and debugging ARM Cortex MCUs. It’s the best friend of any ARM microcontroller developer. It works like a brain tap, it allows you to inspect and affect any aspect of the program you are running on your 1Bitsy without having to add special code. 1Bitsy is a user friendly open-source ARM Cortex-M4F Development Platform.

Check the campaign video to know more about the new products.

The Plug & Play JTAG/SWD ARM debugger features:

  • On board implementation of JTAG (Joint Test Access Group) protocol
  • On board implementation of the SWD (Serial Wire Debug) protocol
  • High speed data interface to the Device Under Test 4.5MBit
  • On board implementation of the GNU Debugger Server protocol (no need for OpenOCD) works with stock arm-none-eabi-gdb (no patches or plugins needed)
  • Automatic detection of the Device Under Test (no need for config files)
  • Frontend Level shifter. Usable with targets that run on voltages as low as 1.7V and as high as 5V.

In efforts to demystify ARM programming, you are now able to do the following applications while using a Black Magic Probe:

  • Interrupt program
  • Inspect and modify registers and variables
  • Watch variables (the program gets interrupted and reports a variable value change)
  • Breakpoints (you can set a point in your code that will cause the program to stop as soon as it is reached)
  • Call stack and backtrace (you can see what functions, with which parameters brought us to the current point and state of the program)
  • Disassembly (see the machine code and find out exactly what your program is doing)
  • Dump memory (download the RAM and/or flash content to a file)

1Betsy & Black Magic was available as an early bird combo for $65. The campaign has exceeded its $10,000 goal with $47,841 and should be delivering rewards now. More technical details can be reached at the campaign and the official website.

SimpleLink MCU platform Launched By TI For Scalable Product Development

Texas Instruments has announced the SimpleLink MCU platform, which is transforming the pace of product proliferation by uniting a robust set of hardware, software and tools under a single development environment.

The SimpleLink MCU platform offers a new software development kits (SDKs) based on a shared foundation of drivers, frameworks and libraries to enable scalability with 100% code reuse, which will reduce design time and allow makers to invest once and leverage across multiple products.

Developers will be able to choose from any of the 32-bit wired and wireless ARM-based MCU devices, making their products easily adapted to changing design or application requirements.

Features of SimpleLink SDK:

  • 100 percent code compatibility across SimpleLink MCU portfolio
  • TI Drivers offers standardized set of functional APIs for integrated peripherals
  • Integrated TI-RTOS, a robust, intelligent kernel for complete, out-of-the-box development
  • POSIX-compatible APIs offer flexible OS/kernels support
  • Encryption-enabled security features
  • IoT stacks and plugins to add functionality to your design

At the same time, TI also announced a new generation of Wi-Fi chips and modules, the SimpleLink Wi-Fi CC3220 wireless MCU and CC3120 wireless network processor.

The CC3220 features a 80MHz Cortex-M4 application processor, with 256k of RAM and 1Mbyte of flash, and a network processor with a hardware crypto engine. While the CC3220 supports Wi-Fi, the range will be extended in the coming months with devices supporting Bluetooth Low Energy and sub GHz communications, as well as a Bluetooth LE/sub GHz dual band part.

“Developers need to ask what needs to be protected, what they are protecting against and what are the exposure points. The CC3220 provides more than 25 security enablers to handle such aspects as key management and code protection.” Mattias Lange, general manager of embedded connectivity solutions, noted.

The SimpleLink platform delivers the most security features, along with the broadest connectivity protocol support and advanced analog integration, combined with the industry’s lowest power wireless MCUs. Bringing together all of TI’s low-power, connected ARM MCUs, including MSP432™ devices, the platform offers:

  • Bluetooth® low energy: CC2640R2F and CC2640R2F-Q1 wireless MCUs
  • Dual-band (Sub-1 GHz and Bluetooth low energy): CC1350 wireless MCU
  • Host MCU: MSP432 MCU
  • Sub-1 GHz: CC1310 wireless MCU
  • Wi-Fi: CC3220 wireless MCU, CC3120 wireless network processor

The CC3220 wireless MCU LaunchPad development kit [CC3220SF-LAUNCHXL] is available for $49.99 and the CC3120 wireless network processor BoosterPack plug-in module [CC3120BOOST] is available for $29.99. The CC3220 will be priced at $4.99 in 1,000-unit quantities.

SimpleLink Microcontrollers and Network Processors

You can learn more details and discover all SimpleLink processors, development kits and tools at the official website.

Robust C Library and Utility for GPIO sysfs Interface in Linux

by Derek Hildreth – Technologic Systems

This comprehensive and easy to read example C code is designed to work alone or included as a library for dealing with general purpose I/O via the sysfs interface in Linux.  It can easily be applied to any computer which utilizes the GPIO sysfs interface (both pro and maker boards).  Getting started is a breeze.  You just need to decide if you’re going to use it as a library (including it into your existing code) or as a stand-alone utility.  We’ll talk about  in this article, but first and foremost, here’s the source code we’ll be working with:

https://github.com/embeddedarm/gpio-sysfs-demo

To get started, download or clone this repository to your board, extract it, and change your directory to it, like so:

wget https://github.com/embeddedarm/gpio-sysfs-demo/archive/master.zip
unzip master.zip
cd gpio-sysfs-demo-master/

The two important files in this repository came from Technologic System’s GitHub pages:

The included Makefile makes quick work out of compiling the example code mentioned in the sections below, as you’ll see soon enough.

Stand-Alone Utility

As a stand-alone utility, you can easily copy the resulting gpioctl program to a directory in your current PATH and include in a script or use it for those one-off commands.

To do this, we’ll simply run sudo make install.  The Makefile will compile the standalone utility using (essentially) gcc -D CTL gpiolib.c -o gpioctl and then automatically copy it to /usr/local/bin, which is popularly included in PATH.  Then, you can run gpioctl –help for instructions on how to use it.  For example, say you want to output logical high on DIO #59.  You would first set the DIO to be an output, and then you’d set it.  Here’s an example of toggling it:

gpioctl –ddrout 59

gpioctl –setout 59

gpioctl –clrout 59

That’s it!  If, say, DIO #59 was tied to an LED, you should see the LED turn on and off again.

 

Now you can easily include these commands into a bash shell script or Python system call or, well, you get the point.

Pro Tip: Keep in mind, the LED may be active low, so you might actually see the opposite (logic high output turns the LED off, logic low output turns the LED on).

Include as Library

Okay, so if you wanted to use this as a library, giving our own C program access to the helpful functions included in gpioctl.c, we need to include it as a source when compiling our program.  You’ll find the example source code gpiodemo.c included in the repository you downloaded earlier:

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include "gpiolib.h"

int main(int argc, char **argv)  {
    int gpio_pin = 59;
    gpio_export(gpio_pin);
    gpio_direction(gpio_pin, 1);

    for(int i = 0; i < 5; i++) {
        printf(">> GPIO %d ON\n", gpio_pin);
        gpio_write(gpio_pin, 1);

        sleep(1);

        printf(">> GPIO %d OFF\n", gpio_pin);
        gpio_write(gpio_pin, 0);   

        sleep(1);
    }                                                                                                                                                      
    return 0;
}

If you simply run make, you’ll get a compiled gpiodemo binary which simply toggles DIO #59, which is connected to an LED on a breadboard.  Referring to the Makefile, you’ll see it’s compiling the example code by running gcc -o gpiodemo gpiolib.c gpiodemo.c.  Now, you can take this knowledge and example and apply it to your own project.

Bonus: Very Fast GPIO

The sysfs API allows for very simple IO access, but it is not very fast.  For example, on the TS-4900 sending out a square wave on a single CPU GPIO through the sysfs API will toggle at around 160 – 170 KHz.  The same IO accessed through registers will toggle at 1.66 – 1.74 MHz.  FPGA GPIO will always be slow at around 700hz.  If you’re needing higher performance GPIO programming in order to meet very specific timing requirements, you might want to take a look at the gpiolib-fast.c solution.  Basically, instead of going through sysfs, you’ll be using the GPIO memory registers directly.  Take care in doing so, as the operations aren’t atomic and can therefore foul things up in unexpected ways.  Kernel drivers or other processes accessing GPIO in the same bank performing a read/modify/write can rewrite the same register with old values causing unexpected results.  Source code can be found here:

Conclusion

You should now be able to control GPIO through the sysfs interface like a boss!  We hope this article was helpful in getting your project off the ground quickly.  If it made your day, please consider sharing it!  If you have questions, please use the comments below.

Esp8266 WebServer farm

An Esp8266 WebServer farm project by Eldon Brown’s (a.k.a WA0UWH)

After several long months, I have reactivated my Esp8266 WebServer Farm.
Currently, one of my WebServers can be accessed as: esp.wa0uwh.com:8154

Esp8266 WebServer farm – [Link]

Tiny ESP8266 Breakout Board

Stavros made a very small ESP8266 breakout board:

A very small breakout for the ESP8266. Includes all necessary pullups/pulldowns for it to boot to your code, a LDO regulator, a 3V3 output pin and enough breadboard space for one row on each side on a standard breadboard.

Tiny ESP8266 Breakout Board – [Link]

FONA808 USB Interface

Jesus @ jechavarria.com tipped us with his latest project. He writes:

For several months I’m working with FONA808 modules from Adafruit to make a portable, web-based locating system. This modules are based on the SIM808 module from SIMCOM manufacturer, and integrates both GSM and GPS transceivers in one 24x24mm package.  The Adafruit board includes this module and also some electronics for choosing voltage levels, battery connection and charger. Because I need to test and programming some of this modules, I decide to make an specific PCB for it, allowing the programming and debugging via PC, wich is more comfortable that use a microcontroller for all these tasks.

FONA808 USB Interface – [Link]

Installing The Micronucleus Bootloader To An ATtiny Via Arduino

In order to be able to upload Arduino sketches directly to the ATtiny84 over USB without the need to use a programming device, Shawn Hymel, an electrical engineer at Sparkfun Electronics, had published a guide showing how to install the micronucleus bootloader, which supports virtual USB (V-USB), onto an ATtiny84 using Arduino.

The Atmel AVR ATtiny84 is a $3 tiny 8-bit processor with 8K of program space, 12 I/O lines, and 8-channel 10 bit ADC. It will run up to 20MHz with an external crystal and can be programmed in circuit.

To start following the tutorial, you will need these parts:

Micronucleus is a bootloader designed for AVR ATtiny microcontrollers with a minimal usb interface, cross platform libusb-based program upload tool, and a strong emphasis on bootloader compactness. It has a built in V-USB so that you can send compiled firmware over a virtual USB connection.

The process will use an Arduino as a programmer by loading an Arduino ISP to install the micronucleus bootloader on the ATtiny84. The next step is allowing USB programming on ATtiny84 by manually change fuses, then creating a board definition for ATtiny84 and installing any necessary USB drivers.

The hardware components should be connected as shown in the above circuit. At first you have to remove the capacitor and connect a FTDI breakout to the Arduino Pro Mini and upload the Arduino ISP firmware.

Before installing Micronucleus, a 10μF capacitor is added between the RESET and GND pins of the Arduino. It will prevent the Arduino from entering bootloader mode so that it will pass the compiled firmware to the connected ATtiny rather than trying to program itself.

AVRDUDE is used then to change the ATtiny fuses and set them as the following:

  • No clock divider
  • Brown-out detection at 2.7V (not necessary, but useful if running off battery)
  • Self-programming

This tutorial should also work with ATtiny85, ATtiny841, and ATtiny167. You can find the detailed steps with a blink example on the main tutorial page.

PIC16F15386, A New PIC Family Announced By Microchip

Microchip, the well-known manufacturer of microcontrollers and semiconductors, announced this week a new family of 8-bit PIC microcontrollers, the ‘PIC16F15386’.

The new PIC16F15386 family features a 8 MIPS CPU speed, with 2KB RAM and up to 28KB flash memory offered in 8 to 48-pin packages. It also has a dual UART, dual SPI and dual I²C interfaces, one 8-bit timer and two 16-bit timers.

PIC16F15386 Features

  • Enhanced Mid-range Core with 49 Instruction, 16 Stack Levels
  • Flash Program Memory with self read/write capability
  • eXtreme Low Power (XLP)
  • IDLE and DOZE low power modes
  • Peripheral Module Disable (PMD)
  • Peripheral Pin Select (PPS)
  • 4x 10-bit PWMs
  • 2x Capture, Compare, PWM (CCP)
  • Complementary Waveform Generator (CWG)
  • Numerically Controlled Oscillator (NCO)
  • 4x Configurable Logic Controller (CLC)
  • 43 Channels 10-bit ADC with Voltage Reference
  • 5-bit Digital to Analog Converter (DAC)
  • 2x Comparators
  • 1x 8-bit Timers (TMR0/TMR2)
  • 2x 16-bit Timer (TMR1)
  • Window Watchdog Timer (WWDT)
  • Enhanced Power-On/Off-Reset
  • Low-Power Brown-Out Reset (LPBOR)
  • Programmable Brown-Out Reset (BOR)
  • In Circuit Serial Programming (ICSP)
  • PIC16LF15386 (1.8V – 3.6V)
  • PIC16F15386 (2.3V – 5.5V)

PIC16F15386 family comes with essential peripherals like Intelligent Analog, Core Independent Peripherals (CIPs) and communication combined with eXtreme Low-Power (XLP) for a wide range of low-power applications. The family features PWMs, multiple communication, temperature sensor and memory features like Memory Access Partition (MAP) and Device Information Area (DIA).

We’ve always offered a diverse portfolio of products with large market appeal,” said Steve Drehobl, vice president of Microchip’s 8-bit MCU division. “With the combination of the most requested features and peripherals by our large base of PIC MCU users, the flexibility in memory size and package options and the availability of MPLAB Xpress with MCC, we expect the PIC16F15386 family to be popular with experienced and first-time PIC MCU designers.

The PIC16F15386 is also compatible with the MPLAB Xpress IDE and the MPLAB Code Configurator, a graphical programming environment. The family includes 13 unique products that are offered in various package options including PDIP, SOIC, DFN, UDFN, UQFN and SSOP.

All products are available now for sampling and in volume production. Volume pricing starts at $0.33 for the product family.

PingPong - The versatile IOT Board

PingPong IoT Development Board – Connecting Hardware to the Cloud

Germany-based Round Solutions developed the PingPong, a powerful and flexible hardware platform for IoT and machine-to-machine (M2M) applications. The PingPong can be used for both wired and wireless connections. The modular hardware design can integrate custom-specific applications and communication standards into a single solution platform that has a very small form factor.

The basic hardware platform of PingPong has a 32-bit 200MHz Microchip PIC32MZ microcontroller unit (MCU) running C/C++ code. It supports RTOS or Real Time Operating System which is available as Open Source Software so that developers can adapt their applications individually and bring them to market more swiftly. The base board of PingPong has following features:

  •  A high-speed cellular module
  • A component for high-precision Global Navigation Satellite System (GNSS)
  • An Internet connectivity module
  • USB
  • CAN-Bus and many other components

    PingPong - The IoT Development Board RTOS 3G Version
    PingPong – The IoT Development Board RTOS 3G Version

One amazing feature is, the high-speed cellular module and the numerous interfaces can be controlled over the cloud. So, you don’t have to keep it wired all the time in order to control all those modules.

Technical Information:

Having an area of 85×52 mm², the PingPong is really tiny in size compared to its features. It has a booming 4 MB flash memory which is perfect for IoT purpose. PingPong beats other IoT modules with the wireless technologies it possesses – 2G, 3G, Galileo E1, GLONASS, and GPS. Supported bands(MHz) for cellular communication are 1800, 1900, 2100, 850, and 900. It communicates with other MCUs over I²C protocol which is widely used by almost all types of MCUs.

The greatest strength of PingPong is its expandability. The developer can overcome all the limitations of PingPong by adding a variety of expansion cards to the PingPong platform. Some examples of expansion cards are, wireless local area network (WLAN), Bluetooth, input/output (I/0), Iridium satellite communications, ISM/RF, SigFox, near-field communication (NFC), radio-frequency identification (RFID), and camera connectivity.

Applications:

  • Send and receive data: Pingpong offers different possibilities for sending and receiving data. Whether it’s wired over Ethernet or on the go with built-in GSM/GPRS module, PingPong does its job of exchanging data continuously.
  • Remote control: The PingPong can be used to control processes remotely via its outputs. Using the digital output with a relay can either enable or disable the power supply of an application.
  • Positioning: With its built-in GNSS and GPS module, the PingPong can also be used to determine position, motion, speed and acceleration.
  • Telemetry: The PingPong can be connected to a wide variety of sensors to process digital and analog measurements. Thus, for example, temperature values collected from a temperature sensor can be transferred via analog input to the PingPong.

And there are much more applications. From hobby projects to industrial development, sensor data collection to the smart home project – anywhere you can use this versatile board.

PingPong supports numerous expansion cards
PingPong supports numerous expansion cards

Important Links:

To learn more on this amazing IoT board, watch these three videos:


Conclusion:

The PingPong is a surprisingly powerful IoT module. It’s a developer’s dream. Having all these features in one package is truly outstanding. The feature of adding expansion cards makes it even stronger.

You can purchase your own PingPong from roundsolutions.com at €199.00. It may seem to be a bit overpriced, but it’s really not. Just consider the features you are getting in a single package and you’ll realize it.