Digital To Analog with Tiva C Launchpad and Energía

April 17, 2015 Leave a comment


There are nice Energía diagrams for this LaunchPad in the Web.

Nevertheless, to become familiar with the board functionality and pin layout (and because enjoy drawing) decided to make a diagram. Tiva C Launchpad Pinout Diagram :


Since my first contact with Arduino always wanted to generate waveforms and see them in an oscilloscope. Almost three years ago made some projects with the MSP430 LaunchPad, can be seen y the SeuPay’s YouTube channel. Then also did some test with the Stellaris LaunchPad. Now, after more than a year with a couple of unboxed Tiva C LaunchPads, decided to try some waveforms generation with the inexpensive 32 bit, 80 MHz ARM platform. Using Energía, began some experiments with the Tiva C : Generating waves with the MCP4725, I2C 12-Bits DAC . Generating waves with the AD7801 Parallel 8-Bit DAC. In the development process, Direct Port Manipulation was implemented, in some cases just for experimenting and in others to reach higher data updates (samples/second).


Tiva C Launchpad and MCP4725

The first experiment is to generate wave shapes using an external DAC (Digital-To-Analog Converter).

The first choice was to use the MCP4725 from Adafruit’s (SparkFun also has a version with different address).


The following sketch fills an array with the values of a sine wave. Then the loop() function feeds the  DAC continuously with those values.

The Fast Mode Write Command of the MCP4725 is used.

/*MCP4725_Sin_01.ino   Arduining 17 APR 2015

-Energia Sketch to be used with Tiva C Launchpad and the Adafruit's MCP4725.
-I2C Fast Mode Write Command is used.
-120 samples are producing a 3.62Hz sine wave  => 434 samples/second.

Based in the code at:


//The MCP4725 from Adafruit:
//  I2C address is 0x62 ( by default A0 has a 10k pull-down resistor ).
//  I2C address is 0x63 if A0 is connected to VCC. 
#define MCP4725_ADDR 0x62           //I2c address..

int ch[ 360 ] , cl[ 360 ];          //Arrays to load the sine wave.

void setup() {

  Wire.begin();           // SCL(3) and SDA(3) by default in Tiva C.
  Wire.setModule(0);      // Changing to SCL(0)and SDA(0),(PB_2 and PB_3). 

  analogWrite(GREEN_LED,25);        //led 10% on.
// Create a sine table of 360 points:
  for ( int i = 0; i <= 360; i++ ) {
    int c = sin( i * 3.141592 / 180 ) * 2047 + 2048;
    ch[ i ] = int( c / 256 );      // the 4 most significant bits.
    cl[ i ] = c - ch[ i ] * 256;   // the 8 least significant bits.

void loop() {
  for ( int i = 0; i < 360; i=i+3 ) {     //Only 120 points are used.
    //Fast Mode Write Command.
    Wire.write( ch[ i ] );        // the 4 most significant bits.
    Wire.write( cl[ i ] );        // the 8 least significant bits.

This is the final result.


The DSO Nano is very handy because fits anywhere close to my desktop computer and

has become an excellent and inexpensive monitor for debugging.

DSO Nano screen capture of a  simulated ECG wave (using the same hardware):



Working with C and Direct Registers (and Ports) Manipulation

Thanks to the page:

Where the professor Valvano, from University of Texas at Austin, teach how to Develop Embedded Systems with the ARM M 4 Processor (Tiva C LaunchPad).

The chapters are mainly designed to work in C but, with some adjusts, the Energía environment does pretty good.

To enable Direct Register Manipulation we need to include in Energía the hardware register definitions.

Just write at the beginning of your code:


This file is located in: C:\energia-0101E0015\hardware\lm4f\cores\lm4f\inc

I just made a copy and put it in: C:\energia-0101E0015\hardware\lm4f\libraries\tm4c123gh6pm

Notice that the file was copied inside a folder created with the same name.

(Surely there is a path to be included in Enegía to do this in a more elegant way).

Now you can use the Valvano’s examples in the Energía IDE, just remember to split the code appearing inside the main() function in two parts:

  – The configuration code goes inside the setup() function of Energía.

  – And the code running continuously is located inside the loop() function of Energía.

Is also possible to include Assembly code in Energía, but it needs another post.


Wiring the AD7801 8-Bits Parallel Digital to Analog Converter

A parallel DAC with 8 Bits is chosen to make the data transfer very fast.

Found the AD7801  at Mouser, the problem: (No DIP Package).

OK, let’s do some SMT work. With the DAC ordered and a  20 contact SOIC-to-DIP adapter.

…some SMT manual soldering…Breadboard-adapter-AD7801_02

A wiring diagram to connect the AD7801 to the Tiva C LaunchPad:


The AD7801, once soldered and wired, is very easy to operate. Simply put a new data in the PORTB and toggle PORTA bit 2 to produce a low pulse in the WR signal.

Did a A Quick-Ref of the chip:


Then I had to study  Valvano’s code to understand how to deal with the Direct Register (and Ports) Manipulation.

First began to do the I/O Ports setup using the Direct Register manipulation, this part is not necessary, you can use Arduino code in Energía to do it. But was a good opportunity to learn  some details of the the ARM  Cortex M 4.

Finally, the code used to generate the fast data transfer between Tiva C launchpad and the AD7801:

/*AD7801_FastDAC.ino 18 APR 2015

Testing the Tiva C LaunchPad and the AD7801 (Parallel Input 8-Bit DAC).
Using the PORTB to write the 8-Bit data.
Using PORTA bit 2 for the write signal (WR).

6 kHz    POINTS=256   ==>  1,536 Mega-samples/sec.
96 kHz   POINTS=16    ==>  1,536 Mega-samples/sec.
Note: faster if offset is a char.( 1,9 Mega-samples/sec.)

#include     // TM4C123GE6PM Register Definitions.
#include             // To calculate the sine table.

// bits 7-0 of port B address (Data).
#define ldata     (*((volatile unsigned long *)0x400053FC))
// bit 2 of port A address (WR signal).
#define wrsignal  (*((volatile unsigned long *)0x40004010))

#define POINTS    256    // Wave points.(256 max. to keep offset as char type)
#define PEAKVAL   128    // Wave Amplitud (128 max, inside 8-Bits range)
#define OFFSET    128    // Center of the wave (128 for full 8-Bits span).

int sintable[POINTS];    // Array to load the sin table data.
int offset=0;           // index to point the data inside sintable[].

void setup(){


  // Fill the sin table with POINTS samples:
  for ( int i = 0; i <= POINTS; i++ ) {
    sintable[i] = sin( i * 3.141592 * 2 / POINTS ) * (PEAKVAL-1) + OFFSET ;


void loop(){
    //Write data to the AD7801

    ldata= sintable[offset];        // Load value in the port B.
    wrsignal= 0;                    // WR signal to low.
    wrsignal= 4;                    // WR signal to high
    if((POINTS-offset)<=0)offset=0; // Keep offset in range.

  //  delayMicroseconds(2);           // To experiment different frequencies.

Subroutine to initialize port B all pins output.
Port B is used to output the data.
void PortB_Init(void){
  volatile unsigned long delay;
  SYSCTL_RCGC2_R |= 0x02;          // 1) activate Port B clock
  delay = SYSCTL_RCGC2_R;          // allow time for clock to stabilize
                                   // 2) no need to unlock PB7-0
  GPIO_PORTB_AMSEL_R &= ~0xFF;     // 3) disable analog functionality on PB7-0
  GPIO_PORTB_PCTL_R = 0x00000000;  // 4) configure PB7-0 as GPIO
  GPIO_PORTB_DIR_R |= 0xFF;        // 5) set PB7-0 as outputs
  GPIO_PORTB_AFSEL_R &= ~0xFF;     // 6) disable alt funct on PB7-0
  GPIO_PORTB_DR8R_R |= 0xFF;       // enable 8 mA drive on PB7-0
  GPIO_PORTB_DEN_R |= 0xFF;        // 7) enable digital I/O on PB7-0

Subroutine to initialize port A pin 2 as output.
PA2 is used to drive the WR signal of the DAC.
void PortA_Init(void){
  volatile unsigned long delay;
  SYSCTL_RCGC2_R |= 0x01;           // 1) activate clock for Port A
  delay = SYSCTL_RCGC2_R;           // allow time for clock to start
                                    // 2) no need to unlock PA2 
  GPIO_PORTA_PCTL_R &= ~0x00000F00; // 3) regular GPIO 
  GPIO_PORTA_AMSEL_R &= ~0x04;      // 4) disable analog function on PA2 
  GPIO_PORTA_DIR_R |= 0x04;         // 5) set direction to output 
  GPIO_PORTA_AFSEL_R &= ~0x04;      // 6) regular port function 
  GPIO_PORTA_DEN_R |= 0x04;         // 7) enable digital port PA2
//End of code.

The complete assembly:


Two screenshots, thanks to the DSO Nano’s image capture function:

 A 6  kHz sine wave using POINTS= 256

and  a 95 kHz sine wave with POINTS= 16 .

The transfer speed is 1.536.000 samples/second.



Next steps:

Now we have a Sine Wave Generator, but the microcontroller is busy with this simple task.

If we need to do additional tasks like:

  • Change the frequency and (or) the amplitude on the fly.
  • Show  those values in a display.
  • Receive commands or transmit parameters serially.

 We need to use interruptions…

Thanks for reading Arduining blog.

Arduino Pro Trinket Pinout Diagram

April 2, 2015 Leave a comment

Here is my quick reference to wire the Adafruit’s Pro Trinket.

Following the color sheme of the previous published Trinket pinout diagram.


Pins A0-A5 can also be named as 14-19 for digital I/O ( digitalRead() and digitalWrite() ).

Very handy arduinos…


I’ll be posting some project with them…

My first approach was making a Christmas tree star, using Neopixels, last December…


Mini Client with the Arduino TRINKET and the ESP8266

January 19, 2015 4 comments

Sending the temperature to a ThingSpeak channel using the TMP35 sensor.

This is a small and low cost implementation of IoT (Internet of Things, possibly one of the next technological revolutions).


The ESP8266 can be used alone thanks to the apparition of several environments like LUA, C, Micro Python etc..

In this case I wanted to keep the solution in the Arduino environment to take advantage of many ready-to-use libraries and examples. Then I realized, due the reduced space in the Trinket (5.310Kb for code), the usability of such libraries it’s not so simple.

Programming the ATtiny85 with an ISP programmer will permit the use of the full 8K programming memory.

Anyway was a fun project, is great to see the small ATtiny85 acting as a Web Client.

Let’s make the Trinket do the job using just the Arduino IDE.




Power considerations:

The ESP8266 is power hungry when is communicating with a Wi-Fi spot. It can reach 215mA in Transmit Mode.

The 3.3Vregulator in the Trinket only supply 150mA max.

Then we need to use another 3.3V power source.

The L4931 (250 mA) is working at first. Two capacitors were added for stability, one in the input and another in the output.


Wiring diagram:

(….. on the works)



Making the ESP8266 breadboard friendly:

 To modify the ESP8266 we need a 0.1″ 4-pin right-angle male header (Not included in the part list).

The procedure is very simple:ESP8266-breadboard-09

First cut (remove) the row of pines closer to the board border.

Then, using a breadboard as guide and support, sold the right-angle header.

Use enough solder to obtain a good mechanical resistance.



More images in this post:



Mini breadboard wiring:


Wire color identification:MiniTrinket-ESP8266-Wiring_02

Black: ground.

Orange: 3.3V from the L4931 regulator.

Yellow: Trinket RX data (ESP8266 TX).

Purple: Trinket TX data (ESP8266 RX).

Green: Trinket analog input (TMP36 Vout).





Final assembly:


Everything in it’s place… let’s coding…




Temperature Sensor TMP35:




The Trinket Sketch:

At first, just ported the code from a working example made with the Meduino NANO and the DHT22 temperature sensor, finding out that the code size will be a problem.




Several changes were implemented to reduce the code size:

Changing to the TMP35 temperature sensor because is easier to read (don’t need a library ).

Avoiding the use of string manipulation functions.

Avoiding the use of floating math operations. (Only integer math was used).

Integrating CR and LF at the end of the strings and using print() function instead of println().

Many other changes until the compiler of the Arduino IDE announced:

Binary sketch size: 5,196 bytes (of a 5,310 byte maximum)

The Sketch:

(soon… need to be documented an cleaned….)



Mini Client part list :


Pictures from the Adafruit Industries web page.

1.- USB cable – A/MiniB.                                                                   1

2.- Hook-up Wire 22AWG Solid Core (assorted colors) .                    1

3.- Tiny breadboard 170 contacts.                                                   1

4.- Adafruit’s Trinket – Mini Microcontroller – 3.3V Logic                   1

5.- 3.3V 250mA Linear Voltage Regulator – L4931-3.3 TO-92          1

6.- 10uF 50V Electrolytic Capacitor.                                                2

7.-TMP35 – Analog Temperature sensor.                                         1

8.- ESP8266 WiFi Module.                                                              1

A 0.1″ 4-pin right-angle male header is recommended to adapt the ESP8266 to the breadboard.

This Post Is Under Construction…


Making ESP8266 breadboard friendly

January 2, 2015 5 comments

Just receive some samples of the ESP-01 board. My first thought was how to use it with a breadboard?.

Doing some Web research found several custom adapters and DIY ideas.

After some brainstorming and a couple of coffees find out a simple procedure to have the ESP8266 nicely plugged in my breadboard.

The solution implies to cut four pins and solder a four pin 0.1 right-angle male header.


The adhesive silicone dot helps to plug the module leveled.




The following images explain  themselves:





Ready for IoT fun projects…



Sending random values of temperature and humidity to ThingSpeak:



Meduino NANO a versatile Arduino NANO clone

December 24, 2014 Leave a comment

Two years ago I found the MEDUINO in Ebay (5 pieces for $44.95 including shipping).


Since then I have used them in several projects with good results.

For less than 10 bucks, you have an Arduino NANO compatible device with selectable working voltage (3.3V or 5V), additionally, you can use it as a USB-Serial adapter (FTDI chip) to interface or monitor other serial devices.


Meduino 3.3V capturing data from the ADXL335 accelerometer.


Meduino 5V transmiting light intensity from the Single Pixel Camera to Processing.


Meduino 3.3V as a USB-Serial adapter to check MODBUS protocol with the electric imp.


Meduino 3.3V as power source and USB serial adapter for the ESP8266 Wi-Fi module.

The pin arrangement is like the Arduino NANO but with the Mini-USB connector on the opposite side. The PCB of the Meduino is also slightly larger.


Meduino NANO and Arduino NANO pin assignment

The selectable Vcc (3.3/5V) is great to interface with different sensors and hardware.

ATmega328 overclocked:

One thing to consider for “serious” applications is the crystal frequency at 3.3V.


The ATMega328 datasheet shows a Safe Operating Area, the maximum recommended frequency for 3.3V operation is 13.3 MHz.

The Meduino NANO with 3.3V at 16MHz is out of the recommended frequency but for experimenting purposes at room temperature, is a very handy and low cost Arduino.

Using the Linear Sensor Array TSL201R with Arduino

March 26, 2014 5 comments

Dealing with linear Sensor Arrays is not easy. After some research in the web, found some experiments with TSL1401, TSL202R and TSL201R, many of them without a happy ending.

My intent is to find out how to do simple image processing of Linear Sensor Arrays using the Arduino.

This will open the path to develop some interesting experiments and applications:

-Line Follower Robots.

-Optical Flow Sensor (to sense movement in robots and autonomous vehicles).

-Laser Range Finders.

-Imagen Scanners (Barcode, character recognition etc.)

-Position Sensors.

-Objet Detection and Objet Counting.

-Objet Shape Identification and Analysis.

-Light Spectrum Analyzers.


After reading the (64×1) linear Sensor Arrays TSL201R manual…


…decided to buy some DIP-8 versions (package discontinued) in, (breadboard friendly).

This is the wiring diagram:


Arduino NANO, solid wires (AWG#22) and an adequate breadboard  for the job.


Pinhole cameras using  PCB Relay’s cases:


Because the small hole, more integration time is necessary.

The projected image field of view can be estimated using geometry…


The application in Progressing shows the illuminance of each pixel sent by the arduino.

Integration time and frames per second (FPS) are also presented.


 Here is an example of how to use the sensor to estimate the position of a floating ball.


Another  possible application, a laser ranger:


Working to increase the frames per second (FPS)…

Will be continued…

(in twitter you can follow my progress before it be posted here ): @arduining


Arduino Trinket Photo Session

February 19, 2014 1 comment

After receiving a bunch of Trinkets, my first impulse was to do some photographic composition…


TrinketHandIntelligence at your fingertips.

Trinket_Photo_01Imagine what can be done…

roundGoing arround…

NestTrinketsTrinket nest…

man_002Distributed intelligence…

ArduinoTrinketsGo arduining…


Get every new post delivered to your Inbox.

Join 28 other followers