4.2 CCS (Code Composer Studio) IDE [1-4]

Transcription

1 4.1 Introduction In the present work, once the process of experimentation starts, the program reads the temperatures T 2, reads the voltage across the heater and converts it to a digital value. The value read by the controller is sent to the laptop using the on-chip UART. This data is captured by the PUTTY software running on the laptop and the data file is sent to the open source plotting software VEUSZ. The plotting software not only displays the results graphically but also estimates the slope and computes the Stefan s constant and displays on the monitor of the laptop. The details of the software packages used in the data acquisition and computation of Stefan s constant are given below. 4.2 CCS (Code Composer Studio) IDE [1-4] Code Composer Studio (CCS) is an integrated development environment (IDE) that supports TI's Microcontroller and embedded processors portfolio. CCS suite consists of the tools used to develop and debug embedded applications. It includes an optimizing C/C++ compiler, source code editor, project build environment, debugger, profiler, and many other features. The intuitive IDE provides a single user interface taking users through each step of the application development flow. Familiar tools and interfaces allow users to get started faster than ever before. CCS combines the advantages of the Eclipse software framework with advanced embedded debug capabilities from TI resulting in a compelling feature-rich development environment for embedded developers. CCS is primarily designed as for embedded project design and low-level JTAG based debugging. However, the latest releases are based on unmodified versions of the Eclipse open source IDE, which can be easily extended to include support for OS level application debug (Linux, Android, Windows Embedded) and 149

2 open source compiler suites such as GCC. Early versions included a real time kernel called DSP/BIOS and its later inception SYS/BIOS. Currently, the successor to these tools, the TI-RTOS embedded tools ecosystem, is available for downloading as a free plug-in to CCS. CCS has the following versions: Version 1.x in General release that dropped support for C2x, C3x, C4x and C5x DSPs. v1.3 added support for ARM. Version 2.0 in General release that added support for the upcoming C55x and C64x DSPs. Across the years it added support for TMS470 ARM7 (2.10), OMAP ARM9 plus C55x DSP (2.10) and C2x DSPs (2.12). Version 3.0 in Limited release that supported only C62x, C64x and C67x DSPs. Version 3.1 in General release. Version 3.2 in Limited release that supported only the new C64x+ DSPs. Version 3.3 in General release that supported all device families, and across the years it added support for OMAP Cortex A8 plus C64x+ DSP, TMS570 (ARM Cortex R4), C672x and C674x DSPs (3.3.82). A limited version for C24x DSPs only is still sold by TI. Version 4.0 in General release based on a modified version of Eclipse 3.2. Dropped support for C24x DSPs and added support for MSP430, Stellaris (ARM Cortex M3) and DaVinci devices. Version 5.0 in General release that uses an unmodified version of Eclipse 3.6 and later 3.7. It was hosted also in Linux. Added support for 150

3 C66x DSPs, Sitara (ARM9 and Cortex A8) and Tiva, Stellaris (ARM Cortex M4) devices. Version 6.0 in General release that uses an unmodified version of Eclipse 4.3. Added support for CC26x and CC32x wireless microcontrollers. Dropped support for C54x DSPs. Version is used in the present work, since this it is the supported software for Stellaris LaunchPad. 4.3 PUTTY Software [5] PUTTY is a free and open-source terminal emulator, serial console and network file transfer application. It supports several network protocols, including SCP, SSH, Telnet, rlogin, and raw socket connection. The name "PUTTY" has no definitive meaning. PUTTY was originally written for Microsoft Windows, but it has been ported to various other operating systems. Official ports are available for some Unix-like platforms, with work-in-progress ports to Classic Mac OS and Mac OS X, and unofficial ports have been contributed to platforms such as Symbian and Windows Mobile. PUTTY was written and is maintained primarily by Simon Tatham and is currently beta software. PUTTY supports many variations on the secure remote terminal, and provides user control over the SSH encryption key and protocol version, alternate ciphers such as 3DES, Arcfour, Blowfish, and DES, and Public-key authentication. It also can emulate control sequences from xterm, VT102 or ECMA-48 terminal emulation, and allows local, remote, or dynamic port forwarding with SSH (including X11 forwarding). The network communication layer supports IPv6, and the SSH protocol supports the zlib@openssh.com delayed compression scheme. PUTTY comes bundled with command-line SCP and SFTP clients, called "pscp" and "psftp" respectively. 151

4 4.4 VEUSZ open source plotting software [6] Veusz is a scientific plotting software package. Veusz is a Qt application written in Python, PyQt and NumPy. It is freely available for anyone to distribute under the terms of the GPL. It is designed to produce publication-quality plots. The name should be pronounced as "views". This program produces plots in popular vector formats, including PDF, PostScript and SVG. It is cross-platform, working under Microsoft Windows, Mac OS X and Unix/Linux. Plots are built up from a set of plotting widgets which can be added to the document and whose properties are edited using a consistent interface. For example, graph widgets can be placed within a grid widget to create an array of graphs. Widgets include X-Y plots, functions, contours, box plots, polar plots, ternary plots, vector plots, data images, labels and a variety of shapes. Datasets can be read using standard formats such as CSV, HDF5 or FITS, or entered, edited or created using functions from existing datasets. Functions can also be fitted to data. Veusz is extensible with Python plugins. Plugins can be added for importing data in other formats, automating operations and creating different kinds of mathematical relationships between datasets. The program also provides a command line and scripting interface (based on Python) to its plotting facilities. The saved file format is a simple Python text script, which makes it easy to create plots from other programs. Such versatile VEUSZ software is used in the present work to obtain the slope and hence to evaluate Stefan s constant. 152

5 4.5 Software Development for Data Acquisition using CCS [7-8] In the present study, the embedded software is developed using CCS version. The developed software reads the parameter temperature of sample T 2 and converts it into T 4 2 -T 4 1, T 1 is the surrounding temperature measured with the thermometer and reads voltage across the heater and converts corresponding voltage into current, and current into power resends the data to the desktop/laptop through UART. The program process is explained below..h files suitable for memory map, types, driver lib, on-chip ADC, GPIO, sysctl, and UART are included at the beginning of CCS. Baud rate of is selected for serial communication. Array and variables are initialized for data storage. Clock frequency 20MHz is selected using PLL. ADC0 is enabled for channels 4 and channel 5 for data acquisition with sample sequence 2. Data acquired at channels 4 and 5 are converted to their digital equivalent and then to a BCD number. Digital value from channel 4 is converted into current using the formula (analog voltagex1000/19x995) and again current converted into power using the formula (Q=I 2 R). Digital value from channel 5 is converted into the difference of fourth power of the body temperature and fourth power of the surrounding temperature (T 4 2 -T 4 1 ). Two data s power and temperature sends to remote desktop/laptop via USB. Description of the points mentioned above in the form of algorithm is represented in the form of flow chart is given in section 4.6. The program listing is 153

6 given in section 4.7. Sample screen shots of the CCS IDE, PUTTY and VEUSZ software are shown in figure 4.1, 4.2, and 4.3, respectively. Figure 4.1: Screen shot of CCS IDE for program development 154

7 Figure 4.2: Screen shot of data capturing through PUTTY software Figure 4.3: Screen shot of data importing and graph plotting using VEUSZ open source software 155

8 4.6 Flow chart of the software 156

9 157

10 4.7 Listing of the program [9-11] #include "inc/hw_memmap.h" //*Macros defining the memory map of the Stellaris device. This includes defines such as peripheral base address locations of GPIO_PORT_BASE. #include "inc/hw_types.h" //*Defines common types and macros such as tboolean and HWREG(x). #include "driverlib/adc.h" //*Defines and macros for GPIO API of DriverLib. This includes API functions such as ADCPinType and ADCPinWrite. #include "driverlib/gpio.h" //*Defines and macros for GPIO API of DriverLib. This includes API functions such as GPIOPinType PWM and GPIOPinWrite. #include"driverlib/sysctl.h" //*Defines and macros for System Control API of DriverLib. This includes API functions such as SysCtlClockSet and SysCtlClockGet. #include "utils/uartstdio.h" //*Defines and macros for GPIO API of DriverLib. This include API functions such as UARTPinType and UARTPinWrite. # define GPIO_PA0_U0RX 0x # define GPIO_PA1_U0TX 0x void InitConsole(void) { SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); //*Enable GPIO port A which is used for UART0 pins. 158

11 GPIOPinConfigure(GPIO_PA0_U0RX); //*The pin muxing for UART0 functions on port A0 and A1. GPIOPinConfigure(GPIO_PA1_U0TX); GPIOPinTypeUART (GPIO_PORTA_BASE, GPIO_PIN_0 GPIO_PIN_1); //* the alternate function for selected pins. UARTStdioInit(0); //* Initialization of the UART for console I/O. } int main (void) { unsigned long uladc0_value[4]; //*Array is used for storing the data read from the ADC FIFO. volatile unsigned long ultemp_valuec; //*Variables are used to store the temperature conversions for Celsius. volatile unsigned long current_ivalue; //*Variables are used to store the voltage conversions for current. volatile unsigned long Power_EValue; //*Variables are used to store the current conversions for power. volatile unsigned long ultemp_valuec1; //*Variables are used to store the digital value corresponding to the temperature value. volatile unsigned long ultemp_valuec2; //*Variables are used to store the temperature in celsuis ( 0 C) volatile unsigned long ultemp_valuet; //*Variables are used to store the Subtraction of fourth power of sample temperature with fourth power of surrounding temperature. 159

12 volatile unsigned long ultemp_valuet2; //*Variables are used to store the temperature in Kelvin temperature value. volatile unsigned long ultemp_valuet3; volatile unsigned long ultemp_valuet4; volatile unsigned long ultemp_valuet5; volatile unsigned long ultemp_valuet6; //*Variables are used to store the multiplication of square of Kelvin temperature value with square of Kelvin temperature. volatile unsigned long ultemp_valuet7; //* Variables are used to store the surrounding temperature in Kelvin. volatile unsigned long ultemp_valuet8; volatile unsigned long ultemp_valuet9; volatile unsigned long ultemp_valuet10; volatile unsigned long ultemp_valuet11; //*Variables are used to store the multiplication of square of surrounding temperature with square of surrounding temperature. SysCtlClockSet(SYSCTL_SYSDIV_10 SYSCTL_USE_PLL SYSCTL_OSC_MAIN SYSCTL_XTAL_16MHZ); //*Set the clocking to run at 20 MHz(200MHz/10) using the PLL. InitConsole(); UARTprintf("ADC ->\n"); //* The serial console to use for displaying messages. //*Display setup on the console. UARTprintf(" Type: Single Ended\n"); UARTprintf(" Samples: Four\n"); 160

13 UARTprintf(" Update Rate: 250ms\n"); UARTprintf(" Input Pin: AIN0/PB4,PB5\n\n"); SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0); //* Enable the ADC0 peripheral. SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); //*ADC0 peripheral for GPIOB. GPIOPinTypeADC(GPIO_PORTB_BASE, GPIO_PIN_4); //*Select analog ADC function for selected pins. GPIOPinTypeADC(GPIO_PORTB_BASE, GPIO_PIN_5); ADCSequenceConfigure(ADC0_BASE, 2, ADC_TRIGGER_PROCESSOR, 0); //*Enable sample sequence 2 with a processor signal trigger. ADCSequenceStepConfigure(ADC0_BASE, 2, 0, ADC_CTL_CH 4); //* Configure step 0 on sequence 2. Sample channel 4 in single-ended mode. ADCSequenceStepConfigure(ADC0_BASE, 2, 1, ADC_CTL_CH 5 ADC_CTL_IE ADC_CTL_END); //*Configure step 0 on sequence 2. Sample channel 5 in singleended mode and configure the interrupt flag to be set when the sample is done. Tell the ADC logic that this is the last conversion on sequence 2. ADCSequenceEnable(ADC0_BASE, 2); //*Sample sequence 2 is configured and enabled. ADCIntClear(ADC0_BASE, 2); //* Clear the interrupt flag before sample. while(1) //*Sample AIN0 forever. { ADCProcessorTrigger(ADC0_BASE, 2); //* Trigger the ADC conversion. 161

14 while(!adcintstatus(adc0_base, 2, false)) //* Wait for conversion to be completed. { } ADCIntClear(ADC0_BASE, 2); //*Clear the ADC interrupt flag. ADCSequenceDataGet(ADC0_BASE, 2, uladc0_value); //*Read ADC value. ultemp_valuec = ( (3300 * uladc0_value[0]) / 4096); //* Conversion of digital value in to voltage. current_ivalue = (uladc0_value [0]*1000)/(19*995); //*Conversion of Voltage value in to current. Energy_EValue = (current_ivalue*current_ivalue)*197; //* Conversion of current value in to energy. ultemp_valuec1 = ( (33000 * uladc0_value[1]) / 4096); //*Conversion of second channel digital value in to voltage. ultemp_valuec1 = ultemp_valuec1/10; //*Conversion of voltage in to temperature in Celsius ( 0 C). ultemp_valuec2 = ultemp_valuec1+2730; //*Conversion of Celsius in to Kelvin. ultemp_valuet2 = (ultemp_valuec2*ultemp_valuec2); //*Multiplication of Kelvin temperature value. ultemp_valuet3 = (ultemp_valuec2*ultemp_valuec2); ultemp_valuet4 = (ultemp_valuet2/1000); //*Division of Kelvin temperature ultemp_valuet5 = (ultemp_valuet3/1000); value by

15 ultemp_valuet6 = ((ultemp_valuet4)* (ultemp_valuet5)); //*Multiplication of square of Kelvin temperature value with square of Kelvin temperature. ultemp_valuet7 = (302*302); //*Multiplication of surrounding temperature in Kelvin. ultemp_valuet8 = (302*302); ultemp_valuet9 = (ultemp_valuet7/10); //*Division of surrounding temperature by 10. ultemp_valuet10 = (ultemp_valuet8/10); ultemp_valuet11 = ((ultemp_valuet9)* (ultemp_valuet10)); //*Multiplication of square of surrounding temperature with square of surrounding temperature. ultemp_valuet = (ultemp_valuet6)-(ultemp_valuet11); //*Subtraction of fourth power of sample temperature with fourth power of surrounding temperature. ultemp_valuet = ultemp_valuet/100; //*Division of final temperature by 100. UARTprintf("%d %d \n\r ",Power_EValue, ultemp_valuet ); //*Print Power and Temperature difference value on Serial monitor. SysCtlDelay(SysCtlClockGet() / 12); //*Big delay. SysCtlDelay(SysCtlClockGet() / 12); SysCtlDelay(SysCtlClockGet() / 12); SysCtlDelay(SysCtlClockGet() / 12); SysCtlDelay(SysCtlClockGet() / 12); } } 163

16 4.8 Summary This chapter gives a systematic approach of developing the software and software packages required in determining the Stefan s constant. Results obtained in the present work using this software are discussed in chapter

17 REFERENCES 1. CCS (Code Composer Studio) manual, 2. File:/// F:/PROJECT/ccstudio.htm PUTTY user guide, 6. VEUSZ manual, 7. Cherukuri Rajeswari and Kanchi Raghavendra Rao, Fast track Exercises to understand ARM Cortex Architecture using TI Stellaris LaunchPad, American Journal of Embedded systems and Applications, communicated. 8. Sachin.V.chavan, Sumayaa.C.pathan, Design of LM4F120H5QR based Node for wireless sensor Network to monitor Environmental parameters of polyhouse, International Journal of Advances in Engineering and Technology, Vol.8, Issue.3, PP , June, M.Mohanty, M.Basu, and D.N. Pattanayak, Apllication of code composer studio in Digital signal processing, International Journal of Electrical Engineering and Technology (IJEET), Vol.5,Issue 11, pp.01-09, Nov Seema Verma, and pawan Sharma, Real Time Implementation of OFDM system on DSP processor, International Journal of Innovative Research in Computer and Communication Engineering, Vol. 1, Issue 10, pp , Dec

18 11. Millind U. Nemade, and Satish K.Shah, Real Time Speach Recognition using DSK TMS320C6713, International Journal of Advanced Research in Computer Science and software Engineering, Vol. 4, Issue.1, PP , Jan