Real-Time Applications Using MS - Yury Magda

Trusted by over 1 million members

Try Scribd FREE for 30 days to access over 125 million titles without ads or interruptions! Start Free Trial Cancel Anytime.



























































































Real-Time Real-Time Applications using MSP432P401R LaunchPad and Raspberry Pi

By Yury Magda































Copyright © 2015 by Yury Magda. All rights reserved.

The programs, examples, and applications presented in this book have been included for their instructional value. The author offer no warranty implied or express, including but not limited to implied warranties of fitness or merchantability for any particular purpose and do not accept any liability for any loss or damage arising from the use of any information in this book, or any error error or omission in such information, or any incorrect use of these programs, procedures, and applications. No part of this publication publication may may be repr reproduced, oduced, stored stored in a retrieval retrieval system, or transmitted in any form or by any means, electronic, mechanical, photocopying, recording, or otherwise, without the prior written permission of the author. author.































Contents Contents Introduction Disclaimer Raspberry Pi GPIO pins Designing Real-Time applications: project 1 Designing Real-Time applications: project 2 Designing Real-Time applications: project 3 Designing Real-Time applications: project 4 Designing Real-Time applications: project 5 Designing Real-Time applications: project 6 Designing Real-Time applications: project 7 Designing Real-Time applications: project 8 Designing Real-Time applications: project 9 Using an MSP432 32-bit timer in Real-Time applications applications Designing Real-Time applications: project 10 Designing a Digital-to-Analog converter with MSP432 Designing Real-Time applications: project 11































































Introduction A popular popular Raspberry Pi miniature computer is often used for designing measurement and control systems by professionals and hobbyists. Such systems can be driven via a generalpurpose input/output port (GPIO) with pins accessible through header J8 on the Raspberry Pi board. With GPIO, user applications can process signals from various sensors and control external loads (relays, motors, etc.).

The only drawback is that Linux OS running on the Raspberry Pi is not suited for processing signals travelling via GPIO pins in real time. This prevents the Raspberry Pi from using in real-time applications that should process signals in a very short time. Meanwhile, Linux provides a powerful high-level environment for the development of GUI applications performing high-level data processing. It would be attractive to combine Linux high-level interfaces with real-time signal processing while building real-time applications.

One way to build real-time applications is to apply a combination of the Raspberry Pi and a stand-alone microcontroller (MCU) board capable of performing real-time tasks. In this configuration, the MCU board could process signals from sensors in real time, drive motors and actuators, etc. Such development board could execute commands from the Raspberry Pi and return r eturn data via some interface (parallel, UART UART, SPI, I2C, etc.).

On the other hand, the Raspberry Pi could perform non-critical operations including highlevel processing the data obtained from an MCU board, data visualization and networking. Such configuration can be used, for example, in image, video and audio processing systems. In those systems, the Raspberry Pi could process the image or video from cameras, while a stand-alone microcontroller module could control a precision motor positioning a camera.































Studio™ (CCS) v.6.1.0. 3. A developer can can achieve better performance for an application application by direct programming CPU and peripheral registers using simple and clear commands and macros. Well-organized MSP432 Technical Reference Manual may come in handy.

The demo projects of real-time application described in this book may be used as the templates for building various measurement and control systems. Each project includes both hardware and software accompanied by the detailed description of what is doing.

The material of the book assumes that the readers are familiar, at least, with basics of designing and assembling electronic circuits. For most projects having some basic skills in electronics and low-level MCU programming will serve the readers well and allow them to understand what is going on behind the scenes. Each project is accompanied by the brief description that helps to make things clear. clear.

All projects were designed using the Raspberry Pi 2 board running Raspbian OS, although developers can use the earlier versions of the Raspberry Pi board as well. All of the source code for the Raspberry Pi projects was developed in the Python environment running in Raspbian OS. The program code for MSP-EXP432P401R LaunchPad was developed using Energia MT IDE and Code Composer Studio 6.1.0 by Texas Texas Instruments. Most projects described in this guide can be easily improved or modified if necessary. necessary.































Disclaimer The design techniques described in this book have been tested on the Raspberry Pi 2 board and MSP-EXP432P401R LaunchPad LaunchPad without damage of the equipment. I will not accept any responsibility for damages of any kind due to actions taken by you after reading this book.































Raspberry Pi GPIO pins Development platforms like Raspberry Pi provide an environment for software and hardware experimenting. This is possible because availability of General Purpose Input/Output pins (GPIO) on the Raspberry Pi 2 board. The Raspberry Pi 2 is equipped with the header labeled J8. This header runs along the edge of the board and has 40 pins. Most GPIO pins can operate in different modes thus accommodating different possible functions. Note that digital pins must be either high or low. Each GPIO pin may be put in input or output mode. When output, a pin can be pulled either LOW (log.”0”) or HIGH (log.”1”) by a program, so it is possible to control external circuitry connected to this pin. Log.“0” corresponds to the voltage level close to 0 volts, while the log.”1” corresponds to 3.3 volts. Reading the state of a loose pin returns the unpredictable result. All the GPIO pins can also be reconfigured to provide alternate functions (SPI, PWM, I2C, etc.).

Note that GPIO voltage levels are 3.3 V and are not 5 V tolerant. The 3.3 V logic level of the Raspberry Pi 2 assumes that external logic components use only 3.3 volt. The Raspberry Pi board has no over-voltage protection – the intention is that t hat people interested in serious interfacing will use an external board with buffers, level conversion and analog I/O rather than soldering directly onto the main board.

Chances are that external circuitry are be poorly assembled ass embled and have short circuits, so I highly recommend you to apply a stand-alone DC 3.3V power supply for powering your electronic circuits to prevent the permanent damage of the Raspberry Pi.

































wires (10-12cm long) so that to ensure minimum distortion dis tortion of digital signals. Using long wires may cause your circuit to stop functioning functi oning properly. properly.































Designing Real-Time applications: project 1 This section contains the first project of a real-time application using the Raspberry Pi and MSP432P401 LaunchPad. LaunchPad. Before we start off, let’s let’s consider in brief the key aspects of developing real-time applications. Nowadays, a growing number of microcontroller applications use Real-Time Real-Time Operating Systems (RTOS). As you may know, know, common microcontroller/microprocessor (MCU) applications when running use sequential processing loops and state machines. This approach works quite well when a microprocessor board is performing a rather limited number of functions. A different approach is required when an application involves more memory and peripherals. If the application is about 64KB in size or less, there is no need to use an RTOS. RTOS. Conversely, if the size of the application reaches 1 MB, an RTOS should likely be used.

Using an RTOS gives a few key advantages. Mostly an RTOS uses a “preemptive multitasking” approach which allows to increase the performance of complex real-time applications, especially those with a code base that t hat is progressively enhanced in each release. The key driver of RTOS adoption is application complexity. complexity. An RTOS will often be used when there are more interrupt sources, more functions, and more standard communications interfaces that need to be supported.































As an application becomes more complex, it can cause a growing number of problems such as excessive memory usage or leaks, delayed response to real-time events, or greater than expected MCU loads, etc. Such problems are often difficult to diagnose since they require a high-level understanding of system behavior and resource usage. Most RTOSs RTOSs have associated system-level debugging tools allowing to examine application behavior and resource usage.

Our next projects will use the Real-Time Operation System by Texas Instruments called TI-RTOS. TI-RTOS has associated tools that enable developers to look at stack usage and compare it against how much stack was assigned to a task. This makes it straightforward to detect stack overflows or to optimize task stack sizes to free up RAM for other parts of the application.

To process analog and digital signals in real time we will use the MSP-EXP432P401R LaunchPad™ by Texas Instruments ( Fig.1).































The MSP-EXP432P401R™ LaunchPad LaunchPad will be configured to run real-time tasks using the multitasking capability of the free Energia MT IDE environment (the newest version 0101E0016 was used). The Energia MT IDE is the open-source prototyping platform that uses the Wiring and Arduino framework for f or programming Texas Instruments launchpads. The Energia MT IDE is the cross platform and supported on Mac OS, Windows, Windows, and Linux. Energia MT includes an integrated development environment (IDE) that is based on Processing. Together with Energia MT, LaunchPad can be used to develop interactive objects, taking inputs from a variety of switches or sensors, and controlling a variety of lights, motors, and other physical outputs. LaunchPad projects can be stand-alone (only run on the Target Board, i.e. your LaunchPad), or they can communicate with software running on your computer (Host PC). Much more details about Energian can be found on http://energia.nu http://energia.nu..

Multitasking is the ability to run multiple tasks or threads concurrently on a microcontroller. microcontroller. In Energia MT, multitasking is achieved by treating each tab as a separate task (thread) and letting TI-RTOS and Energia take care of the rest. Currently, multitasking is supported on the MSP-EXP432P401R LaunchPad.

Below is a brief desription of the multitasking capability of the Energia MT environment.































circuit diagram for this system is shown in Fig.2.

































void setup() { pinMode(15, INPUT); // Pin P1.6 is set as input to pick up the signal on pin GPIO18 }

void loop() { inState = digitalRead(15); if(inState != 0x0) blinkON = 1; else blinkON = 0x0;

































void loopBlueLed() { if (blinkON) { digitalWrite(LED, HIGH); // turn the LED ON delay(100); digitalWrite(LED, LOW); delay(100);

// wait for 100 ms // turn the LED OFF by pulling pulling the LED pin LOW LOW // wait for 100 ms

} }

With this source code, the pin corresponding to the blue LED is configured as ouput. The loop() procedure repeatedly evaluates the value of the global variable blinkON. The LED

































digitalWrite(LED, digitalWrite(LED, HIGH); // turn the LED ON delay(500); digitalWrite(LED, digitalWrite(LED, LOW); delay(500);

// wait for half a second // turn the LED OFF by making the voltage LOW // wait for half a second

} }

This source code is almost the same as that shown in Listing 2, except the pin number used by the green LED.

The source code of the thread driving the red LED (file RedLed.ino) is shown in Listing 4.

































The simple Python application running on the Raspberry Pi simply stops/resumes blinking the LEDS by pulling pin GPIO18 HIGH/LOW, respectively. The source code of the script is shown in Listing 5.

Listing 5.

from time import sleep import RPi.GPIO as GPIO

GPIO.setwarnings(False) GPIO.setmode(GPIO.BCM) GPIO.setup(18, GPIO.OUT)



































































Designing Real-Time applications: project 2 The following demo project of a real-time application illustrates low-level programming techniques and using interrupts and threads in a system with the Raspberry Pi and MSP432P401R MCU. The circuit diagram of the project is shown in Fig.4.



































Each interrupt when activated calls an associated interrupt service routine (ISR) ( ISR) which drives a corresponding LED ON/OFF. The Energia MT source code of the application consists of three modules. The source code of the main thread (file MSP432_P1_6_7_ISR.ino) is shown in Listing 6.

Listing 6.

#include “msp.h”



































attachInterrupt(15, P16_ISRHandler, P16_ISRHandler, FALLING); // Interrupt is activated // when pin P1.6 (15) goes from HIGH to LOW attachInterrupt(14, P17_ISRHandler, P17_ISRHandler, FALLING); // Interrupt is activated // when pin P1.7 (14) goes goes from HIGH to LOW }

void loop(){}



































P1OUT ^= BIT0;

which drives pin P1.0 ON/OFF. ON/OFF. The last statement enables the data transfer in the corresponding thread:

redSW = 1;



































void loopRed() { // put your main code here, to run repeatedly: if (redSW != 0) { Serial.println(“Red LED was was toggled.”); redSW = 0;





































} }





































Designing Real-Time applications: project 3









































































When operating as a 16-Bit Timer Counter, the 16-bit timer/counter register, register, TAxR , increments or decrements (depending on mode of operation) with each rising edge of the clock signal. TAxR can can be read or written by software. Additionally, the timer can





































selected clock source may be used directly by the timer or divided by 2, 4, or 8, using the ID bits of TAxCTL. The frequency of the selected clock source can be further divided by 2, 3, 4, 5, 6, 7, or 8 using the TAIDEX bits of the TAxEX0 register. The timer clock





















































































































































































































































































































































































































































































































































































































































































































































































































Designing Real-Time applications: project 6 Many real-time applications need to read several digital inputs at a time. This could be a case when an application should process signals from sensors of the same type. The following demo application illustrates reading several digital inputs of MSP432P401R MCU at a time and transferring the data obtained to the Raspberry Pi via a serial interface.

The circuit diagram of the application is shown in Fig.12.

Fig.12

In this circuit, three digital inputs (pins P2.5 – P2.7) of MSP432P401R MCU are read r ead after an interrupt on pin P2.4 of MSP432 has been activated by the falling edge on pin GPIO18 of the Raspberry Pi. The Energia MT source code of MSP432 application consists of two parts. One of them representing a main thread (file Reading_ParallelInput.ino) is shown in Listing 21.































int p2Read; int bReady = 0;

void setup() { // put your setup code here, to run once: P2DIR = 0x0;

// Port P2 is set as INPUT

P2OUT |= BIT5 | BIT6 | BIT7;

// Pull-up resistors on P2.5 - P2.7

P2REN |= BIT5 | BIT6 | BIT7;

// Select pull-up mode for P2.5 - P2.7

attachInterrupt(38, P24IsrHandler, P24IsrHandler, FALLING); FALLING); // configuring the interrupt on pin P2.4 of MSP432 }

void loop() { // put your main code here, to run repeatedly: }

void P24IsrHandler(void) { P2IFG &= ~BIT4; ~BIT4; // Clear interrupt flag for pin P2.4 bReady = 1; }

In this source code, the sequence

P2DIR = 0x0;































configure the interrupt handler processing events on pin P2.4 by the following statement:

attachInterrupt(38, P24IsrHandler, FALLING);

The interrupt handler P24IsrHandler when entered clears the interrupt flag assigned to the P2.4 interrupt line and set the bReady flag to 1 thus allowing the data transfer to the Raspberry Pi.

The Energia MT source code of the thread processing digital inputs (file Serial_Thread.ino) is shown in Listing 22.

Listing 22.

void setup1() { // put your setup code here, to run once: Serial.begin(9600); delay(500); }

void loop1() { // put your main code here, to run repeatedly: if (bReady (bReady == 1) { p2Read = P2IN; p2Read = p2Read >> 5; Serial.print(“BITS 7-5 of port P2: 0x”);































}

The program code of the thread is running within the loop1() function. If the global variable bReady = 1, the state of digital inputs P2.5 – P2.7 is saved in bits 0 – 2 of the p2Read variable. The value obtained is then transferred to the Raspberry Pi through a serial interface.

The project window in Energia MT IDE looks like the following (Fig.13).

Fig.13

The source code of the Python application running in Raspbian OS is shown in Listing 23.

Listing 23.































GPIO.setwarnings(False) GPIO.setmode(GPIO.BCM) GPIO.setup(18, GPIO.OUT)

s1 = serial.Serial(port=’/dev/ttyACM0’, baudrate=9600, parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE, bytesize=serial.EIGHTBITS, timeout=3) try: while 1: GPIO.output(18, GPIO.HIGH) GPIO.output(18, GPIO.LOW) rLine = s1.readline() print rLine sleep(5) except KeyboardInterrupt: print ” Terminating the application on Ctr-C…” s1.close() sys.exit(0)

The application will perform two actions: activating an interrupt and reading the data through a serial interface. The object s1 associated with the serial interface /dev/ttyACM0 will be used for reading data transferred by an MSP432 application. The GPIO18 pin driving the interrupt line to pin P2.4 is configured as output. The sequence

GPIO.output(18, GPIO.HIGH)

































the serial interface and output on the screen by the sequence:

rLine = s1.readline() print rLine

The loop repeats infinitely every 5 s until Ctrl-C is pressed.































Designing Real-Time applications: project 7 This section is dedicated to processing analog signals in real-time systems with MSP432P401R MCU and Raspberry Pi. Below is a brief description of the analog module of MSP432P401R CPU taken from the corresponding datasheet on the device. The MSP432P401R CPU contains the ADC14 module that supports fast 14-bit analog-todigital conversions. The module implements a 14-bit SAR core, sample select control, and up to 32 independent conversion-and-control buffers. The conversion-and-control buffer allows up to 32 independent analog-to-digital converter (ADC) samples to be converted and stored without any CPU intervention. ADC14 features include: •

1 Msps maximum conversion rate at maximum resolution of 14-bits;

•

Monotonic 14-bit converter with no missing codes;

• Sample-and-hold with programmable sampling periods controlled by software or timers; •

Conversion initiation by software or timers;

• Software-selectable on-chip reference voltage generation (1.2 V, 1.45 V, or 2.5 V) with option to make available externally; •

Software-selectable internal or external reference;

• Up to 32 individually i ndividually configurable external input channels, single-ended or differential input selection available; • Internal conversion channels for internal temperature sensor and ½ × AVcc and four more internal channels available on select devices (see device data sheet for availability as well as function); •

Independent channel-selectable channel-selectable reference sources for positive reference;































Fig.14

The above diagram may come in handy when configuring analog-to-digital converter for our application. The demo application is very simple – it will read r ead 3 channels named A0 – A2 and transfer the data obtained via a serial interface to the Raspberry Pi. The circuit diagram of such a system is shown in Fig.15.































Fig.15

In this circuit, the analog signals on pins P5.5 – P5.3 are simulated by potentiometers Rp1 – Rp3. Analog signals are taken from their wipers and fed to analog inputs of MSP432. The table below details the connections.

MSP432P401R LaunchPad pin

P5.5

Analog channel of MSP432P40R A0































#include “msp.h” #define ADC14CSTARTADD_1 (1 << 16) // the constant to select a memory register // ADC14MEM1 in ADC14CTL1

const float LSB = 3.345/4096; float vout[3];

int bincode[3]; int chs[3] = {ADC14INCH_0, ADC14INCH_1, ADC14INCH_2}; int i, cBusy;

void setup() { // put your setup code here, to run once:

P5SEL1 |= BIT3 | BIT4 | BIT5;

// Configure P5.5-P5.3 (A0-A2) for ADC

P5SEL0 |= BIT3 | BIT4 | BIT5;

// Configure ADC14 ADC14CTL0 |= ADC14SHT0_3 | ADC14SHP | ADC14ON; S&H=32, // ADC14 is on

// Sampling time,

































for (i = 0; i < 3; i++) { ADC14CTL0 &= ~ADC14ENC; delayMicroseconds(10); ADC14MCTL1 = 0x0; delayMicroseconds(10); ADC14MCTL1 ADC14MCT L1 += chs[i]; // Select an input channel from the chs array, Vref Vref = AVcc AVcc delayMicroseconds(10); ADC14CTL0 |= ADC14ENC | ADC14SC;

// Start sampling and conversion

delayMicroseconds(10); while(ADC14BUSY == 0x1);

bincode[i] = ADC14MEM1; vout[i] = LSB * bincode[i]; delayMicroseconds(10); } cBusy = 0; delay(1000);

// waiting until A/D conversion is complete































where bincode[i] is a binary code for each channel ( A0 … A2) and LSB (Least Significant Bit) = 3.345/212 = 3.345/4096. The constant 3.345 determines a reference voltage Vref (by (by default). In this particular case, the measured value of Vref turned out to be 3.345V. The array chs[3] contains the numbers of physical channels being selected via a multiplexor (see Fig.14). The variable cBusy is needed for synchronizing threads. When cBusy = 1, the A/D conversion is still running. When cBusy = 0, A/D conversion is complete, so the result can be transferred to the Raspberry Pi. The sequence

P5SEL1 |= BIT3 | BIT4 | BIT5; P5SEL0 |= BIT3 | BIT4 | BIT5;

configures pins P5.5 – P5.3 as analog inputs for channels A0 – A2. The following statement configures the ADC14 mode through the ADC14CTL0 control register:

ADC14CTL0 |= ADC14SHT0_3 | ADC14SHP | ADC14ON;































A/D conversion is executed within an for() loop running 3 iterations. In each iteration, the ADC14 is initially disabled by the statement

ADC14CTL0 &= ~ADC14ENC;

After a short delay (about 10 uS) the program code clears the memory control register by the statement:

ADC14MCTL1 = 0x0;

After a short delay, the program code selects the physical channel to be processed:

ADC14MCTL1 += chs[i];

This is followed by a delay of 10 uS. The next statement enables A/D conversion for the selected channel and starts sampling/conversion:

ADC14CTL0 |= ADC14ENC | ADC14SC;































The float value is then t hen saved in the corresponding element of the vout array:

vout[i] = LSB * bincode[i];

After the for() loop terminates, the cBusy flag is cleared thus allowing the data transfer. The measurement cycle for A0 – A2 channels repeats each 1 s (the delay(1000) statement). The following source code (file Serial_Thread.ini) represents the thread performing data transfer over a serial interface to the Raspberry Pi ( Listing 25).

Listing 25.

void setup1() { // put your setup code here, to run once: Serial.begin(9600); delay(500);































delay(3000); }

The above code is periodically (every 3 s) transfers the data obtained from channels A0 – A2 through the serial interface after A/D conversion is complete (cBusy = 0).

The source code of the Python application for reading data from MSP432P401R is shown in Listing 26.

Listing 26.

from time import sleep import serial

s1 = serial.Serial(port=’/dev/ttyACM1’, baudrate=9600, parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE,

































































Designing Real-Time applications: project 8 An application to be discussed in this section allows to continuously read 3 analog channels on the MSP432P401R board. The data collected from all channels are transferred to the Raspberry Pi if interrupt signal on pin P1.6 of MSP432 is activated. The interrupt line P1.6 is driven by pin GPIO19 of the Raspberry Pi. The circuit diagram for this project is shown in Fig.17.

































#include “msp.h” #define ADC14CSTARTADD_1 (1 << 16) // select a memory register ADC14MEM1

const float LSB = 3.345/4096; float vout[3];

int bincode[3]; int chs[3] = {ADC14INCH_0, ADC14INCH_1, ADC14INCH_2}; int i, bRead;

void setup() {

































ADC14CTL1 = ADC14RES_2 | ADC14CSTART ADC14CSTARTADD_1;

// Use sampling timer,

// 12-bit conversion results // and ADC14MEM1 memory reg. attachInterrupt(15, P16_ISRHandler, P16_ISRHandler, FALLING); // an interrupt is activated // when a falling edge arrives on pin P1.6 (15) bRead = 0; }

void loop() { for (i = 0; i < 3; i++) { ADC14CTL0 &= ~ADC14ENC;

































Serial.print(“A1 input, V: “); Serial.println(vout[1], 3);

Serial.print(“A2 input, V: “); Serial.println(vout[2], 3);

Serial.println(“–––––––”); bRead = 0; } delay(100); }

void P16_ISRHandler()



































import serial import sys

GPIO.setwarnings(False) GPIO.setmode(GPIO.BCM)

GPIO.setup(19, GPIO.OUT) # P1.6 P1.6 control control



































GPIO.output(19, GPIO.HIGH) sleep(0.1) GPIO.output(19, GPIO.LOW)

within the while loop periodically (every 4 s) activates the interrupt on pin P1.6 of MSP432 through GPIO19. Then the for loop reads 4 lines from the serial interface and output the results on the console. The Python application provides the following outputs:





































































Designing Real-Time applications: project 9 This section illustrates how to transfer t ransfer a command to MSP432 from the Raspberry Pi using a serial interface. An application running on the MSP432P401R board will receive the command, parse it and set the frequency of timer Timer_A3. The circuit diagram of the project is shown in Fig.19.



































#define pACLK 32768 32768 // a basic clock clock frequency taken taken from ACLK int cmd, pA3, freq;






































// fault flag





































} }





































TA3CTL = TASSEL_1 | MC_1 | TACLR;





































s1 = serial.Serial(port=’/dev/ttyACM0’, baudrate=9600,





































import serial





















































































































































































































































































































































































































































































































































































































































































































































































































conjunction with WR to write data to the parallel interface. 7

WR

Active Low Write Input. This is used in conjunction with CS to write data to the parallel interface.

8

GAIN

Gain Control Pin. This controls whether the outpu tput range from the DAC is 0 V to VREF or 0 V to 2 × VREF.

9

CLR

Asynchronous active low low control input that clears all input registers and DAC registers to zero.

10

LDAC

Active low low control inp input that updates tes the DAC registers with the contents of the t he input registers.

11

PD

Power-Down Pin. This active low control pin puts the DAC into power-down mode.

12

VDD

Power Supply Input. These parts can operate from 2.5 V to 5.5 V and the supply should be decoupled with a 10 µF capacitor in parallel with a 0.1 µF capacitor to GND.

13 to 20

DB0 to DB7

Eight Parallel Data Inputs. DB7 is the MSB of these eight bits.

The simple demo application illustrates use of the DAC AD5330 driven by MSP432P401R MCU. The circuit diagram of the application is shown in Fig.26.































Fig.26

In this circuit, the parallel inputs (DB0 – DB7) of AD5330 are connected to port P4 (pins P4.0 – P4.7). The CS control signal to AD5330 is taken from pin P1.5 of MCP432P401R, the WR signal signal is taken from pin P1.6. The reference voltage to AD5330 (pin 3) is selected to be +3.3V (VDD).

The Energia MT source code of the MSP432 application is shown in Listing.40.

Listing 40.


float vout = 0.0; float LSB = 3.3/256;































WDTCTL = WDTPW | WDTHOLD;

// Stop watchdog timer

// Configure GPIO Port 4 P4DIR = 0xFF;

// Pins P4.0 - P4.7 (DB0—>DB7) are set as outputs

// Configure P1.5 - P1.6 P1DIR |= BIT5 | BIT6; // P1.5 (CS) and P1.6(WR) are set as outputs }

void loop() { // put your main code here, to run repeatedly: if (vout (vout <= 3.3) { P4OUT = (int)(vout/LSB); delayMicroseconds(10);

P1OUT |= BIT5 | BIT6; // CS = WR = 1 P1OUT &= ~BIT5; // CS = 0 P1OUT &= ~BIT6; // WR = 0 delayMicroseconds(10);

P1OUT |= BIT6; // WR = 1 P1OUT |= BIT5; // CS = 1 vout += 0.4; delay(3000); } else vout = 0.0;































P4DIR = 0xFF;

Pins P1.5 (CS) and P1.6 (WR ) provide the control signals to AD5330, so they should also be configured as outputs by the statement:

P1DIR |= BIT5 | BIT6;

To understand how the DAC output is i s formed, let’s look at the truth table for AD5330 (X = don’t care).

CLR

LDAC

CS

WR

Function

1

1

1

X

No data transfer

1

1

X

1

No data transfer

0

X

X

X

Clear all registers

1

1

0

0→1

Load input register

1

0

0

0→1

Load input register and DAC register

1

0

X

X

Update DAC register

According to this table, the analog output of the D/A converter is updated by the rising edge of the WR signal signal when both LDAC and CS signal lines stay LOW. The bits of port P4 should already contain the valid data before the write operation starts off. This is reflected by the following sequence in the program code:

P4OUT = (int)(vout/LSB);































P1OUT &= ~BIT6; delayMicroseconds(10);

P1OUT |= BIT6; P1OUT |= BIT5;

Initially, both LDAC and CS lines are pulled HIGH by the statement

P1OUT |= BIT5 | BIT6;

Then CS goes LOW:

P1OUT &= ~BIT5;

This is immediately followed by the t he statement

P1OUT &= ~BIT6;

that pulls the WR line line LOW.

The following sequence completes updating the D/A output:

P1OUT |= BIT6; P1OUT |= BIT5;

The short delays about 10uS provided by the delayMicroseconds(10) statements are optional; they can increase the reliability when some level of noise is presented in the circuit.

































Designing Real-Time applications: project 11 This project allows to design the D/A converter converter with AD5330 controlled by the Python application running on the Raspberry Pi. The circuit diagram of the application is shown in Fig.27.

Fig.27
































float vout = 0.0; float LSB = 3.3/256; int cmd;


WDTCTL = WDTPW | WDTHOLD;

// Stop watchdog timer

// Configure GPIO Port 4 P4DIR = 0xFF;

// Pins P4.0 - P4.7 (DB0—>DB7) are set as outputs

// Configure P1.5 - P1.6 P1DIR |= BIT5 | BIT6; // P1.5 (CS) and P1.6(WR) are set as outputs //Initial settings for DAC P4OUT = 128; // vout = 1.6V delayMicroseconds(10);

P1OUT |= BIT5 | BIT6; // CS = WR = 1 P1OUT &= ~BIT5; // CS = 0 P1OUT &= ~BIT6; // WR = 0































void loop() { // put your main code here, to run repeatedly: while (Serial.available() > 0) {

// look for the next valid integer in the incoming serial stream: cmd = Serial.parseInt(); // cmd line: <4,freq> if (cmd == 4) // 4 = write DAC command { vout = Serial.parseFloat(); if((vout >= 0.1) && (vout <= 3.3)) { P4OUT = (int)(vout/LSB); delayMicroseconds(10);

P1OUT |= BIT5 | BIT6; // CS = WR = 1 P1OUT &= ~BIT5; // CS = 0 P1OUT &= ~BIT6; // WR = 0 delayMicroseconds(10);

P1OUT |= BIT6; // WR = 1 P1OUT |= BIT5; // CS = 1































where value1 is a command code and value2 is a parameter (new D/A output, in our case). In this application, the data string will be, for example, as follows:

4,1.33

The value of 4 indicates the write command to DAC, and the value of 1.33 will be a new DAC output equal to 1.33 V. Parsing the data string is performed by the following fragment of code:

. . . cmd = Serial.parseInt(); if (cmd == 4) // 4 = write DAC command { vout = Serial.parseFloat(); . . .

The rest of code has already been discussed in the previous section, so we will move to the Raspberry Pi software.

The Python application running in Raspbian OS has the following source code ( Listing 42).































# Cmd line: sudo -c 4 -v #Ex.: pi@raspberrypi ~/Developer/MSP432 $ sudo python Set_DAC_UART Set_DAC_UART.py -c 4 -v 1.22

import serial import time import argparse

parser = argparse.ArgumentParser(description argparse.ArgumentParser(description=‘Configuring =‘Configuring the DAC output’) parser.add_argum parser.add_argument(‘-c’, ent(‘-c’, ‘—cmd’, help=‘command’, required=True) parser.add_argum parser.add_argument(‘-v’, ent(‘-v’, ‘—voltage’, help=‘Desired voltage’, required=True) required=True) args = parser.parse_args() str1 = args.cmd + ‘,’ + args.voltage

s1 = serial.Serial(port=’/dev/ttyACM0’, baudrate=9600, parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE, bytesize=serial.EIGHTBITS, timeout=1) time.sleep(1) s1.write(str1) time.sleep(1)

































Then the str1 string is sent via the serial interface associated with the object s1. The Python application can be launched as shown below.

pi@raspberrypi ~/Developer $ sudo python Set_DAC_UART.py -c 4 -v 1.22 pi@raspberrypi ~/Developer $ sudo python Set_DAC_UART.py -c 4 -v 2.66 pi@raspberrypi ~/Developer/MSP432 $ sudo python Set_DAC_UART Set_DAC_UART.py -c 4 -v 0.77

Real-Time Applications Using MS - Yury Magda

Recommend Documents