Texas Instruments Inc., September 2011
Signal Generator Library
Module user’s Guide
C28x Foundation Software
Texas Instruments Inc., September 2011
Texas Instruments Inc., September 2011
IMPORTANT NOTICE Texas Instruments and its subsidiaries (TI) reserve the right to make changes to their products or to discontinue any product or service without notice, and advise customers to obtain the latest version of relevant information to verify, before placing orders, that information being relied on is current and complete. All products are sold subject to the terms and conditions of sale supplied at the time of order acknowledgement, including those pertaining to warranty, patent infringement, and limitation of liability. TI warrants performance of its semiconductor products to the specifications applicable at the time of sale in accordance with TI’s standard warranty. Testing and other quality control techniques are utilized to the extent TI deems necessary to support this warranty. Specific testing of all parameters of each device is not necessarily performed, except those mandated by government requirements. Customers are responsible for their applications using TI components. In order to minimize risks associated with the customer’s applications, adequate design and operating safeguards must be provided by the customer to minimize inherent or procedural hazards. TI assumes no liability for applications assistance or customer product design. TI does not warrant or represent that any license, either express or implied, is granted under any patent right, copyright, mask work right, or other intellectual property right of TI covering or relating to any combination, machine, or process in which such products or services might be or are used. TI’s publication of information regarding any third party’s products or services does not constitute TI’s approval, license, warranty or endorsement thereof. Reproduction of information in TI data books or data sheets is permissible only if reproduction is without alteration and is accompanied by all associated warranties, conditions, limitations and notices. Representation or reproduction of this information with alteration voids all warranties provided for an associated TI product or service, is an unfair and deceptive business practice, and TI is not responsible or liable for any such use. Resale of TI’s products or services with statements different from or beyond the parameters stated by TI for that products or service voids all express and any implied warranties for the associated TI product or service, is an unfair and deceptive business practice, and TI is not responsible nor liable for any such use. Also see: Standard Terms and Conditions of Sale for Semiconductor Products. www.ti.com/sc/docs/stdterms.htm
Mailing Address: Texas Instruments Post Office Box 655303 Dallas, Texas 75265
Copyright 2011, Texas Instruments Incorporated
Texas Instruments Inc., September 2011
Trademarks TMS320 is the trademark of Texas Instruments Incorporated. All other trademark mentioned herein are property of their respective companies Acronyms xDAIS : eXpress DSP Algorithm Interface Standard IALG : Algorithm interface defines a framework independent interface for the creation of
algorithm instance objects STB : Software Test Bench QMATH: Fixed Point Mathematical computation CcA : C-Callable Assembly FIR : Finite Impulse Response Filter IIR : Infinite Impulse Response Filter FFT : Fast Fourier Transform
Texas Instruments Inc., September 2011
CCCooonnnttteeennntttsss 1. Introduction……. ................................. .................................................................................... 1
2. SIN Generator……................................. .................................................................................. 1
2.1. Standard THD Sin generator .............................................................................................. 1
2.2. Low THD sin generator....................................................................................................... 1
2.3. High precision sin generator............................................................................................... 1
3. Signal Generator Modules…………….. ................. ................................................................ 5
3.1. SGENT_1: Single Channel SIN Generator (Table look-up)……....................................... 5
3.2. SGENT_2: Dual Channel SIN Generator (Table look-up)…… ....................................... 10
3.3. SGENT_3: 3φ SIN Generator (Table look-up)…… ......................................................... 15
3.4. SGENT_3D: Dual 3φ SIN Generator (Table look-up)…… .............................................. 20
3.5. SGENTI_1: Single Channel SIN Generator (Table look-up and Linear Interpolation)… 26
3.6. SGENTI_2: Dual Channel SIN Generator (Table look-up and Linear Interpolation)……31
3.7. SGENTI_3: 3φ SIN Generator (Table look-up and Linear interpolation)…….................. 36
3.8. SGENTI_3D: Dual 3φ SIN Generator (Table look-up and Linear Interpolation)…… ...... 41
3.9. SGENHP_1: High Precision SIN Generator (Table look-up and Linear Interpolation)… 47
3.10. SGENHP_2: High Precision SIN Generator (Table look-up and Linear Interpolation).. 52
3.11. RMPGEN: Ramp Generator…… ................................................................................... 57
3.12. TZDLGEN: Trapezoidal generator ................................................................................. 62
3.13. PROFILE: Profile generator… ....................................................................................... 67
4. Revision History……………........................... ....................................................................... 75
Texas Instruments Inc., September 2011 1
Introduction
1. Introduction The signal generator module repository contains SIN generation, ramp generation and trapezoidal generation modules. The signal generator modules are implemented using modulo arithmetic counter (i.e. Any overflow is ignored and only the remainder is kept) to precisely control the frequency. The frequency of the generated signal is reciprocal of the time it takes for successive overflow of modulo counter, which in turn commensurate with the step value added to the counter. Thus by changing the step value, one can precisely control the frequency. The step value is not directly commanded to vary the frequency, instead the modulation of frequency is performed using the normalized variable “freq” which is normalized to the maximum frequency. The maximum required frequency is predetermined based on the application requirement and it set by initializing the “step_max” input. Thus, the normalized variable “freq” allows the user to control the frequency of the signal between 0 to maximum frequency. This strategy is adopted for all signal generator modules NOTE: The source project for the library currently has two build options: STD and STD_FPU32. Both build configurations are implemented using IQ math, however, the STD_FPU32 config ensures that the library can be used in another project that has “fpu32” run time support option turned on. Each build configuration generates its own libray: C28x_SGEN_Lib_fixed.lib and C28x_SGEN_Lib_fpu32.lib respectively. The examples were built using the fpu32 enabled library(C28x_SGEN_Lib_fpu32.lib) but can easily be modified to work with fixed point operations by a) Turning off fpu32 support from the compiler’s Run Time Support options (project
properties) b) Replacing the fpu32 enabled library i.e. C28x_SGEN_Lib_fpu32.lib with the standard
fixed point version, C28x_SGEN_Lib_fixed.lib, in the linker’s File Search Path option
Each example has a javascript file :“AddWatchWindowVars.js” which the user can run from the scripting console to setup the watch window variables and graphs for each project.
2. SIN Generation
The signal generator repository contains comprehensive set of SIN generation modules viz., Single channel, Dual channel, 3φ and dual 3φ SIN generator to cater to various application requirements. Single and Dual channel modules are available in three forms viz., Standard THD version (SGENT_xx, Low THD version (SGENTI_xx) and High precision version (SGENHP_xx). The 3φ and dual 3φ SIN generator are available in two forms viz., Standard THD version (SGENT_xx) and Low THD version (SGENTI_xx).
2.1. Standard THD sin generator (SGENT_1, SGENT_2, SGENT_3& SGENT_3D)
The standard THD sine generators are implemented using direct table look-up technique and it uses 16-bit modulo counter. Although a 16-bit counter is used, the upper byte (8-bits) is used to index the 256-point look-up table and hence to obtain the SIN value. Thus, by changing how quickly values overflow from lower byte (i.e., manipulating step value) the frequency of the sine wave can be changed. Modulo counter ignores the overflow or carry out of 16-bit counter and retains only the remainder. The graph shown in page 2 exemplifies the error of the SIN output obtained using direct table look-up technique with respect to the floating point results.
2.2. Low THD sin generator (SGENTI_1, SGENTI_2, SG ENTI_3& SGENTI_3D)
Texas Instruments Inc., September 2011 2
The low THD sin generators are implemented using Table look-up and linear interpolation technique and it uses 16-bit modulo counter. The upper byte (8-bits) is used to index the 256-point look-up table and lower byte (8-bits) used to interpolate between the look-up table entries. The graph shown in page 3 exemplifies the error of the SIN output obtained using table look-up with linear interpolation technique with respect to the floating point results.
2.3. High Precision sin generator (SGENHP_1 & SGEN HP_2) The high precision sin generators are implemented using Table look-up and linear interpolation technique and it uses 32-bit modulo counter. The high precision modules allow precise frequency control because of the fact that it uses 32-bit value for frequency input and also uses 32-bit modulo counter. The upper byte (8-bits) is used to index the 256-point look-up table and the 15-bits following the upper byte are used to interpolate between the look-up table entries. The graph shown in page 4 exemplifies the error of the SIN output obtained with this implementation with respect to the floating-point results.
Texas Instruments Inc., September 2011 3
Standard THD sin generator (SGENT_1, SGENT_2, SGENT_3 & SGENT_3D) error graph
SIN(x) Obtained by C-float (Q15 format)
-36000
-24000
-12000
0
12000
24000
36000
0 1 2 3 4 5 6
Input 'x' (in radians)
SIN
(x)
SIN(x) Obtained by Direct table look-up technique (in Q15 format)
-36000
-24000
-12000
0
12000
24000
36000
0 1 2 3 4 5 6
Input 'x' (in radians)
SIN
(x)
Error with respect to Floating point
-800
-600
-400
-200
0
200
400
600
800
0 1 2 3 4 5 6
Input 'x' (in radians)
Err
or (
in C
ount
s)
Texas Instruments Inc., September 2011 4
Low THD sin generator (SGENTI_1, SGENTI_2, SGENTI_3& SGENTI_3D) error graph
SIN(x) Obtained by C-float (Q15 format)
-36000
-24000
-12000
0
12000
24000
36000
0 1 2 3 4 5 6
Input 'x' (in radians)
SIN
(x)
Error with respect to Floating point
-6
-4
-2
0
2
4
6
0 1 2 3 4 5 6
Input 'x' (in radians)
Err
or (
in C
ount
s)
SIN(x) Obtained by table look-up with linear interpolation (in Q15 format)
-36000
-24000
-12000
0
12000
24000
36000
0 1 2 3 4 5 6
Input 'x' (in radians)
SIN
(x)
Texas Instruments Inc., September 2011 5
High Precision sin generator (SGENHP_1 & SGENHP_2) error graph
SIN(x) Obtained by C-float (Q15 format)
-36000
-24000
-12000
0
12000
24000
36000
0 1 2 3 4 5 6
Input 'x' (in radians)
SIN
(x)
SIN(x) Obtained by table look-up with linear interpolation (in Q15 format)
-36000
-24000
-12000
0
12000
24000
36000
0 1 2 3 4 5 6
Input 'x' (in radians)
SIN
(x)
Error with respect to Floating point
-6
-4
-2
0
2
4
6
0 1 2 3 4 5 6
Input 'x' (in radians)
Err
or (
in C
ount
s)
Texas Instruments Inc., September 2011 6
Description This module generates single channel digital SIN signal using direct
table look-up technique. Availability C-Callable Assembly (CcA) Module Properties Type: Target Independent, Application Dependent Target Devices: x28xx
C-Callable Assembly Files: sgt1c.asm, sintb360.asm, sgen.h
Item C-Callable ASM Comments
Code Size� 16 +257words + cinit•
257 Look-up Table entries
Data RAM 0 words•
xDAIS ready Yes xDAIS component No IALG layer not implemented Multiple instances Yes Reentrancy Yes
Multiple Invocation
Yes
Stack usage 2 words Stack grows by 2 words
• Each pre-initialized SGENT_1 structure consumes 8 words in the data memory and 11 words in the cinit section ∆∆∆∆ Each instance of SGENT_1 module consumes 8 words in Data memory.
Single Channel SIN Generator (Table look-up) SGENT_1
out
freq
SGENT_1
gain
offset
step_max
Texas Instruments Inc., September 2011 7
C/C-Callable ASM Interface C/C-Callable ASM Interface Object Definition
The structure of SGENT_1 object is defined by the following structure definition typedef struct { unsigned int freq; unsigned int step_max; unsigned int alpha; int gain; int offset; int out; void (*calc)(void *); } SGENT_1;
Module Terminal Variables/Functions
Item Name Description Format Range(Hex)
freq Frequency in hertz between [ ]MAXF,0
normalized to [ ]1,0
Q15 0-7FFF
offset DC offset in the SIN signal Q15 8000-7FFF
alpha Initial phase [ ]π2,0 Q16 0-FFFF
gain Gain of the SIN signal Q15 0-7FFF
Input
step_max
65536
max_ SMAX
FstepF
×= .
The default value is set to 1000 to generate the maximum frequency of 305.17Hz using 20KHz sampling loop.
Q0 0000-7FFF
Output out SIN Output Q15 8000-7FFF
Special Constants and Data types SGENT_1
The module definition is created as a data type. This makes it convenient to instance an interface to the signal generator module. To create multiple instances of the module simply declare variables of type SGENT_1
SGENT_1_handle User defined Data type of pointer to SGENT_1 Module
SGENT_1_DEFAULTS
Structure symbolic constant to Initialize SGENT_1 Module. This provides the initial values to the terminal variables as well as method pointers.
Methods void (*calc)(void *);
This function implements the single channel digital SIN signal generation using direct table look-up technique.
Texas Instruments Inc., September 2011 8
C/C-Callable ASM Interface Module Usage
Instantiation The following example instances empty signal generator object SGENT_1 sgen; Initialization
To Instance pre-initialized object SGENT_1 sgen = SGENT_1_DEFAULTS;
Invoking the computation function sgen.calc(&sgen);
Example
The following pseudo code exemplifies, 50Hz single channel digital SIN signal generation using SGENT_1 module.
#include <sgen.h>
SGENT_1 sgen=SGENT_1_DEFAULTS;
int x1; main ( ) {
sgen.offset=0; sgen.gain=0x7fff; /* gain=1 in Q15 */ sgen.freq=5369; /* freq = (Required Freq/Max Freq)*2^15 */ /* = (50/305.17)*2^15 = 5369 */ sgen.step_max=1000; /* Max Freq= (step_max * sampling freq)/65536 */ /* Max Freq = (1000*20k)/65536 = 305.17 */
} void interrupt isr_20khz() {
sgen.calc(&sgen); x1=sgen.out;
} Note: Edit Linker Command file, to place the look-up table in Program memory.
SINTBL > PROG PAGE 0
Texas Instruments Inc., September 2011 9
Background Information Background Information
The signal generator modules are implemented using modulo arithmetic counter (i.e. Any overflow is ignored and only the remainder is kept) to precisely control the frequency. The frequency of the generated signal is reciprocal of the time it takes for successive overflow of modulo counter, which in turn commensurate with the step value added to the counter. Thus by changing the step value, one can precisely control the frequency.
The step value is not directly commanded to vary the frequency, instead the modulation of frequency is performed using the normalized variable “freq” which is normalized to the maximum frequency. The maximum required frequency is predetermined based on the application requirement and it set by initializing the “step_max” input. Thus, the normalized variable “freq” allows the user to control the frequency of the signal between 0 to maximum frequency. The standard THD sine generators are implemented using direct table look-up technique and it uses 16-bit modulo counter. Although a 16-bit counter is used, the upper byte (8-bits) is used to index the 256-point look-up table and hence to obtain the SIN value. Thus, by changing how quickly values overflow from lower byte (i.e., manipulating step value) the frequency of the sine wave can be changed. Modulo counter ignores the overflow or carry out of 16-bit counter and retains only the remainder. The graph shown in page 2 exemplifies the error of the SIN output obtained using direct table look-up technique with respect to the floating point results. The amount of time it takes for the 16-bit modulo counter to overflow, assuming that the counter is incremented in ISR.
ISRISR Tstep
Tstep
T ×=×= 65536216
(1)
The frequency of the generated SIN wave is reciprocal of the time, hence
ISRFstep
F ×=65536
(2)
Where ISR
ISR TF
1= is the ISR invocation frequency.
Thus the actual frequency of the SIN wave is determined by the “step” value used to increment the modulo-counter and the ISR execution rate. The signal generator modules use the normalized control variable to modulate the frequency instead of directly commanding the step value. The frequency control variable is normalized with respect to the maximum frequency. Assuming that the application requires the maximum frequency of 500Hz using 20Khz ISR loop. Then the step value to generate 500Hz is determined using equation (2)
4.163820000
65536500 =×=step
Texas Instruments Inc., September 2011 10
Background Information This step value of 1638 is used to initialize the “step_max” element of the signal generator module. The normalized control variable “freq” helps to control the frequency from 0 to 500Hz by varying it between 0 to 1 (Q15 format) with the frequency resolution of 0.305Hz
The frequency resolution is = max_step
FMAX , hence the “step_max” should be high to get good
frequency resolution. It should be set to at least “100” for reasonable frequency resolution. To generate SIN signal of frequency f , initialize the “freq” element of the SIN generator
module to 152×MAXf
f. Thus the required frequency is normalized with respect to the
maximum frequency as set by “step_max” and input as Q15 number to the SIN generator module.
Texas Instruments Inc., September 2011 11
Description This module generates dual channel digital SIN signal with phase control
using direct table look-up technique. Availability C-Callable Assembly (CcA) Module Properties Type: Target Independent, Application Dependent Target Devices: x28xx
C-Callable Assembly files: sgt2c.asm, sintb360.asm, sgen.h
Item C-Callable ASM Comments
Code Size� 24 words + 257 + cinit•
257 Look-up Table entries
Data RAM 0 words•
xDAIS ready Yes xDAIS component No IALG layer not implemented Multiple instances Yes Reentrancy Yes
Multiple Invocation
Yes
Stack usage 2 words Stack grows by 2 words
• Each pre-initialized SGENT_2 structure consumes 10 words in the data memory and 13 words in the cinit section ∆∆∆∆ Each instance of SGENT_2 module consumes 10 words in Data memory.
Dual Channel SIN Generator (Table look-up) SGENT_2
out1
SGENT_2
freq
gain
offset
step_max
phase
out2
Texas Instruments Inc., September 2011 12
C/C-Callable ASM Interface C/C-Callable ASM Interface Object Definition
The structure of SGENT_2 object is defined by the following structure definition typedef struct { unsigned int freq; unsigned int step_max; unsigned int alpha; int gain; int offset; int out1; unsigned int phase; int out2; void (*calc)(void *); } SGENT_2;
Module Terminal Variables/Functions
Item Name Description Format Range(Hex)
freq Frequency in hertz between [ ]MAXF,0
normalized to [ ]1,0
Q15 0-7FFF
offset DC offset in the SIN signal Q15 8000-7FFF
alpha Initial phase [ ]π2,0 Q16 0-FFFF
gain Gain of the SIN signal Q15 0-7FFF
phase Phase angle between the two SIN outputs
[ ]ππ +− , is normalized to [ ]1,1 +−
Q15 8000-7FFF
Input
step_max
65536
max_ SMAX
FstepF
×= .
The default value is set to 1000 to generate the maximum frequency of 305.17Hz using 20KHz sampling loop.
Q0 0000-7FFF
out1 SIN Output 1 � ( )θsin Q15 8000-7FFF Output
out2 SIN Output 2 � ( )phase+θsin Q15 8000-7FFF
Special Constants and Data types SGENT_2
The module definition is created as a data type. This makes it convenient to instance an interface to the signal generator module. To create multiple instances of the module simply declare variables of type SGENT_2 SGENT_2_handle User defined Data type of pointer to SGENT_2 Module
SGENT_2_DEFAULTS
Texas Instruments Inc., September 2011 13
C/C-Callable ASM Interface
Structure symbolic constant to Initialize SGENT_2 Module. This provides the initial values to the terminal variables as well as method pointers.
Methods void (*calc)(void *);
This function implements the dual channel digital SIN signal generation with phase control using direct table look-up technique.
Module Usage
Instantiation The following example instances empty signal generator object SGENT_2 sgen; Initialization
To Instance pre-initialized object SGENT_2 sgen = SGENT_2_DEFAULTS;
Invoking the computation function sgen.calc(&sgen);
Example
The following pseudo code exemplifies, two 50Hz digital SIN signal generation with 90deg phase shift using SGENT_2 module.
#include <sgen.h>
SGENT_2 sgen=SGENT_2_DEFAULTS;
Int x1, x2;
main ( ) {
sgen.offset=0; sgen.gain=0x7fff; /* gain = 1 in Q15 */ sgen.freq=5369; /* freq = (Required Freq/Max Freq)*2^15 */ /* = (50/305.17)*2^15 = 5369 */ sgen.step_max=1000; /* Max Freq= (step_max * sampling freq)/65536 */ /* Max Freq = (1000*20k)/65536 = 305.17 */
sgen.phase=4000h /* Phase = (required Phase)/180 in Q15 */ /* = (+90/180) in Q15 = 4000h */
} void interrupt isr_20khz() {
sgen.calc(&sgen); x1=sgen.out1; x2=sgen.out2;
} Note: Edit Linker Command file, to place the look-up table in Program memory.
SINTBL > PROG PAGE 0
Texas Instruments Inc., September 2011 14
Background Information Background Information
The signal generator modules are implemented using modulo arithmetic counter (i.e. Any overflow is ignored and only the remainder is kept) to precisely control the frequency. The frequency of the generated signal is reciprocal of the time it takes for successive overflow of modulo counter, which in turn commensurate with the step value added to the counter. Thus by changing the step value, one can precisely control the frequency.
The step value is not directly commanded to vary the frequency, instead the modulation of frequency is performed using the normalized variable “freq” which is normalized to the maximum frequency. The maximum required frequency is predetermined based on the application requirement and it set by initializing the “step_max” input. Thus, the normalized variable “freq” allows the user to control the frequency of the signal between 0 to maximum frequency. The standard THD sine generators are implemented using direct table look-up technique and it uses 16-bit modulo counter. Although a 16-bit counter is used, the upper byte (8-bits) is used to index the 256-point look-up table and hence to obtain the SIN value. Thus, by changing how quickly values overflow from lower byte (i.e., manipulating step value) the frequency of the sine wave can be changed. Modulo counter ignores the overflow or carry out of 16-bit counter and retains only the remainder. The graph shown in page 2 exemplifies the error of the SIN output obtained using direct table look-up technique with respect to the floating point results. The amount of time it takes for the 16-bit modulo counter to overflow, assuming that the counter is incremented in ISR.
ISRISR Tstep
Tstep
T ×=×= 65536216
(1)
The frequency of the generated SIN wave is reciprocal of the time, hence
ISRFstep
F ×=65536
(2)
Where ISR
ISR TF
1= is the ISR invocation frequency.
Thus the actual frequency of the SIN wave is determined by the “step” value used to increment the modulo-counter and the ISR execution rate. The signal generator modules use the normalized control variable to modulate the frequency instead of directly commanding the step value. The frequency control variable is normalized with respect to the maximum frequency. Assuming that the application requires the maximum frequency of 500Hz using 20Khz ISR loop. Then the step value to generate 500Hz is determined using equation (2)
4.163820000
65536500 =×=step
Texas Instruments Inc., September 2011 15
Background Information This step value of 1638 is used to initialize the “step_max” element of the signal generator module. The normalized control variable “freq” helps to control the frequency from 0 to 500Hz by varying it between 0 to 1 (Q15 format) with the frequency resolution of 0.305Hz
The frequency resolution is = max_step
FMAX , hence the “step_max” should be high to get good
frequency resolution. It should be set to at least “100” for reasonable frequency resolution. To generate SIN signal of frequency f , initialize the “freq” element of the SIN generator
module to 152×MAXf
f. Thus the required frequency is normalized with respect to the
maximum frequency as set by “step_max” and input as Q15 number to the SIN generator module.
Texas Instruments Inc., September 2011 16
Description This module generates 3-phase digital SIN signal with fixed 120° phase
shift between the channels using direct table look-up technique. Availability C-Callable Assembly (CcA) Module Properties Type: Target Independent, Application Dependent Target Devices: x28xx
C-Callable Assembly files: sgt3c.asm, sintb360.asm, sgen.h
Item C-Callable ASM Comments
Code Size� 34 words + 257 + cinit•
257 Look-up Table entries
Data RAM 0 words•
xDAIS ready Yes xDAIS component No IALG layer not implemented Multiple instances Yes Reentrancy Yes
Multiple Invocation
Yes
Stack usage 2 words Stack grows by 2 words
• Each pre-initialized SGENT_3 structure consumes 10 words in the data memory and 13 words in the cinit section ∆∆∆∆ Each instance of SGENT_3 module consumes 10 words in Data memory.
Three Phase SIN Generator (Table look-up) SGENT_3
out1
SGENT_3
freq
gain
offset
step_max out3
out2
Texas Instruments Inc., September 2011 17
C/C-Callable ASM Interface C/C-Callable ASM Interface Object Definition
The structure of SGENT_3 object is defined by the following structure definition typedef struct { unsigned int freq; unsigned int step_max; unsigned int alpha; int gain; int offset; int out1; int out2; int out3; void (*calc)(void *); } SGENT_3;
Module Terminal Variables/Functions
Item Name Description Format Range(Hex)
freq Frequency in hertz between [ ]MAXF,0
normalized to [ ]1,0
Q15 0-7FFF
offset DC offset in the SIN signal Q15 8000-7FFF
alpha Initial phase [ ]π2,0 Q16 0-FFFF
gain Gain of the SIN signal Q15 0-7FFF
Input
step_max
65536
max_ SMAX
FstepF
×= .
The default value is set to 1000 to generate the maximum frequency of 305.17Hz using 20KHz sampling loop.
Q0 0000-7FFF
out1 SIN Output 1 � ( )θsin Q15 8000-7FFF
out2 SIN Output 2 � ( )o120sin +θ Q15 8000-7FFF
Output
out3 SIN Output 3 � ( )o240sin +θ Q15 8000-7FFF
Special Constants and Data types SGENT_3
The module definition is created as a data type. This makes it convenient to instance an interface to the signal generator module. To create multiple instances of the module simply declare variables of type SGENT_3
SGENT_3_handle User defined Data type of pointer to SGENT_3 Module
SGENT_3_DEFAULTS
Texas Instruments Inc., September 2011 18
C/C-Callable ASM Interface
Structure symbolic constant to Initialize SGENT_3 Module. This provides the initial values to the terminal variables as well as method pointers.
Methods void (*calc)(void *);
This function implements 3-phase digital SIN signal generation with fixed 120° phase shift between the channels using direct table look-up technique.
Module Usage Instantiation
The following example instances empty generic signal generator object SGENT_3 sgen; Initialization
To Instance pre-initialized object SGENT_3 sgen = SGENT_3_DEFAULTS;
Invoking the computation function sgen.calc(&sgen);
Example The following pseudo code exemplifies, 3-phase digital SIN signal (50Hz) generation using SGENT_3 module.
#include <sgen.h>
SGENT_3 sgen=SGENT_3_DEFAULTS;
Int x1, x2, x3;
main ( ) {
sgen.offset=0; sgen.gain=0x7fff; /* gain = 1 in Q15 */ sgen.freq=5369; /* freq = (Required Freq/Max Freq)*2^15 */ /* = (50/305.17)*2^15 = 5369 */ sgen.step_max=1000; /* Max Freq= (step_max * sampling freq)/65536 */ /* Max Freq = (1000*20k)/65536 = 305.17 */
sgen.phase=4000h /* Phase = (required Phase)/180 in Q15 */ /* = (+90/180) in Q15 = 4000h */
} void interrupt isr_20khz() {
sgen.calc(&sgen); x1=sgen.out1; x2=sgen.out2;
x3=sgen.out3; } Note: Edit Linker Command file, to place the look-up table in Program memory.
SINTBL > PROG PAGE 0
Texas Instruments Inc., September 2011 19
Background Information Background Information
The signal generator modules are implemented using modulo arithmetic counter (i.e. Any overflow is ignored and only the remainder is kept) to precisely control the frequency. The frequency of the generated signal is reciprocal of the time it takes for successive overflow of modulo counter, which in turn commensurate with the step value added to the counter. Thus by changing the step value, one can precisely control the frequency.
The step value is not directly commanded to vary the frequency, instead the modulation of frequency is performed using the normalized variable “freq” which is normalized to the maximum frequency. The maximum required frequency is predetermined based on the application requirement and it set by initializing the “step_max” input. Thus, the normalized variable “freq” allows the user to control the frequency of the signal between 0 to maximum frequency. The standard THD sine generators are implemented using direct table look-up technique and it uses 16-bit modulo counter. Although a 16-bit counter is used, the upper byte (8-bits) is used to index the 256-point look-up table and hence to obtain the SIN value. Thus, by changing how quickly values overflow from lower byte (i.e., manipulating step value) the frequency of the sine wave can be changed. Modulo counter ignores the overflow or carry out of 16-bit counter and retains only the remainder. The graph shown in page 2 exemplifies the error of the SIN output obtained using direct table look-up technique with respect to the floating point results. The amount of time it takes for the 16-bit modulo counter to overflow, assuming that the counter is incremented in ISR.
ISRISR Tstep
Tstep
T ×=×= 65536216
(1)
The frequency of the generated SIN wave is reciprocal of the time, hence
ISRFstep
F ×=65536
(2)
Where ISR
ISR TF
1= is the ISR invocation frequency.
Thus the actual frequency of the SIN wave is determined by the “step” value used to increment the modulo-counter and the ISR execution rate. The signal generator modules use the normalized control variable to modulate the frequency instead of directly commanding the step value. The frequency control variable is normalized with respect to the maximum frequency. Assuming that the application requires the maximum frequency of 500Hz using 20Khz ISR loop. Then the step value to generate 500Hz is determined using equation (2)
4.163820000
65536500 =×=step
Texas Instruments Inc., September 2011 20
Background Information This step value of 1638 is used to initialize the “step_max” element of the signal generator module. The normalized control variable “freq” helps to control the frequency from 0 to 500Hz by varying it between 0 to 1 (Q15 format) with the frequency resolution of 0.305Hz
The frequency resolution is = max_step
FMAX , hence the “step_max” should be high to get good
frequency resolution. It should be set to at least “100” for reasonable frequency resolution. To generate SIN signal of frequency f , initialize the “freq” element of the SIN generator
module to 152×MAXf
f. Thus the required frequency is normalized with respect to the
maximum frequency as set by “step_max” and input as Q15 number to the SIN generator module.
Texas Instruments Inc., September 2011 21
Description This module generates dual, 3-phase digital SIN signal with fixed 120°
phase shift between the channels and phase control between the two three phase signals using direct table look-up technique.
Availability C-Callable Assembly (CcA) Module Properties Type: Target Independent, Application Dependent Target Devices: x28xx
C-Callable Assembly files: sgt3dc.asm, sintb360.asm, sgen.h
Item C-Callable ASM Comments
Code Size� 63 words + 257 + cinit•
257 Look-up Table entries
Data RAM 0 words•
xDAIS ready Yes xDAIS component No IALG layer not implemented Multiple instances Yes Reentrancy Yes
Multiple Invocation
Yes
Stack usage 2 words Stack grows by 2 words
• Each pre-initialized SGENT_3D structure consumes 14 words in the data memory and 17 words in the cinit section ∆∆∆∆ Each instance of SGENT_3D module consumes 14 words in Data memory.
Dual, three Phase SIN Generator (Table look-up) SGENT_3D
SGENT_3D
freq
gain
offset
step_max
phase
out11
out13
out12
out21
out23
out22
Texas Instruments Inc., September 2011 22
C/C-Callable ASM Interface C/C-Callable ASM Interface Object Definition
The structure of SGENT_3D object is defined by the following structure definition typedef struct { unsigned int freq; unsigned int step_max; unsigned int alpha; int gain; int offset; int out11; int out12; int out13; unsigned int phase; int out21; int out22; int out23; void (*calc)(void *); } SGENT_3D;
Module Terminal Variables/Functions
Item Name Description Format Range
(Hex) freq Frequency in hertz between [ ]MAXF,0
normalized to [ ]1,0
Q15 0-7FFF
offset DC offset in the SIN signal Q15 8000-7FFF
alpha Initial phase [ ]π2,0 Q16 0-FFFF
gain Gain of the SIN signal Q15 0-7FFF
Input
step_max
65536
max_ SMAX
FstepF
×= .
The default value is set to 1000 to generate the maximum frequency of 305.17Hz using 20KHz sampling loop.
Q0 0000-7FFF
out11 SIN Output 11 � ( )θsin Q15 8000-7FFF
out12 SIN Output 12 � ( )o120sin +θ Q15 8000-7FFF
out13 SIN Output 13 � ( )o240sin +θ Q15 8000-7FFF
out21 SIN Output 21 � ( )phase+θsin Q15 8000-7FFF
out22 SIN Output 22 � ( )phase++ o120sin θ Q15 8000-7FFF
Output
out23 SIN Output 23 � ( )phase++ o240sin θ Q15 8000-7FFF
Texas Instruments Inc., September 2011 23
C/C-Callable ASM Interface Special Constants and Data types SGENT_3D
The module definition is created as a data type. This makes it convenient to instance an interface to the signal generator module. To create multiple instances of the module simply declare variables of type SGENT_3D
SGENT_3D_handle User defined Data type of pointer to SGENT_3D Module
SGENT_3_DEFAULTS
Structure symbolic constant to Initialize SGENT_3D Module. This provides the initial values to the terminal variables as well as method pointers.
Methods void (*calc)(void *);
This function implements two, 3-phase digital SIN signal generation with phase control between the three phase signals using direct table look-up technique.
Module Usage
Instantiation The following example instances empty generic signal generator object SGENT_3D sgen; Initialization
To Instance pre-initialized object SGENT_3D sgen = SGENT_3D_DEFAULTS;
Invoking the computation function sgen.calc(&sgen);
Texas Instruments Inc., September 2011 24
C/C-Callable ASM Interface Example The following pseudo code exemplifies, dual 3-phase digital SIN signal (50Hz) generation with 90deg phase shift between the three phase signals using SGENT_3D module.
#include <sgen.h>
SGENT_3D sgen=SGENT_3D_DEFAULTS;
Int x11, x12, x13, x21, x22, x23;
main ( ) {
sgen.offset=0; sgen.gain=0x7fff; /* gain = 1 in Q15 */ sgen.freq=5369; /* freq = (Required Freq/Max Freq)*2^15 */ /* = (50/305.17)*2^15 = 5369 */ sgen.step_max=1000; /* Max Freq= (step_max * sampling freq)/65536 */ /* Max Freq = (1000*20k)/65536 = 305.17 */
sgen.phase=4000h /* Phase = (required Phase)/180 in Q15 */ /* = (+90/180) in Q15 = 4000h */
} void interrupt isr_20khz() {
sgen.calc(&sgen); x11=sgen.out11; x12=sgen.out12;
x13=sgen.out13; x21=sgen.out21;
x22=sgen.out22; x23=sgen.out23; } Note: Edit Linker Command file, to place the look-up table in Program memory.
SINTBL > PROG PAGE 0
Texas Instruments Inc., September 2011 25
Background Information Background Information
The signal generator modules are implemented using modulo arithmetic counter (i.e. Any overflow is ignored and only the remainder is kept) to precisely control the frequency. The frequency of the generated signal is reciprocal of the time it takes for successive overflow of modulo counter, which in turn commensurate with the step value added to the counter. Thus by changing the step value, one can precisely control the frequency.
The step value is not directly commanded to vary the frequency, instead the modulation of frequency is performed using the normalized variable “freq” which is normalized to the maximum frequency. The maximum required frequency is predetermined based on the application requirement and it set by initializing the “step_max” input. Thus, the normalized variable “freq” allows the user to control the frequency of the signal between 0 to maximum frequency. The standard THD sine generators are implemented using direct table look-up technique and it uses 16-bit modulo counter. Although a 16-bit counter is used, the upper byte (8-bits) is used to index the 256-point look-up table and hence to obtain the SIN value. Thus, by changing how quickly values overflow from lower byte (i.e., manipulating step value) the frequency of the sine wave can be changed. Modulo counter ignores the overflow or carry out of 16-bit counter and retains only the remainder. The graph shown in page 2 exemplifies the error of the SIN output obtained using direct table look-up technique with respect to the floating point results. The amount of time it takes for the 16-bit modulo counter to overflow, assuming that the counter is incremented in ISR.
ISRISR Tstep
Tstep
T ×=×= 65536216
(1)
The frequency of the generated SIN wave is reciprocal of the time, hence
ISRFstep
F ×=65536
(2)
Where ISR
ISR TF
1= is the ISR invocation frequency.
Thus the actual frequency of the SIN wave is determined by the “step” value used to increment the modulo-counter and the ISR execution rate. The signal generator modules use the normalized control variable to modulate the frequency instead of directly commanding the step value. The frequency control variable is normalized with respect to the maximum frequency. Assuming that the application requires the maximum frequency of 500Hz using 20Khz ISR loop. Then the step value to generate 500Hz is determined using equation (2)
4.163820000
65536500 =×=step
Texas Instruments Inc., September 2011 26
Background Information This step value of 1638 is used to initialize the “step_max” element of the signal generator module. The normalized control variable “freq” helps to control the frequency from 0 to 500Hz by varying it between 0 to 1 (Q15 format) with the frequency resolution of 0.305Hz
The frequency resolution is = max_step
FMAX , hence the “step_max” should be high to get good
frequency resolution. It should be set to at least “100” for reasonable frequency resolution. To generate SIN signal of frequency f , initialize the “freq” element of the SIN generator
module to 152×MAXf
f. Thus the required frequency is normalized with respect to the
maximum frequency as set by “step_max” and input as Q15 number to the SIN generator module.
Texas Instruments Inc., September 2011 27
Description This module generates single channel digital SIN signal using table look-
up and linear interpolation technique. Availability C-Callable Assembly (CcA) Module Properties Type: Target Independent, Application Dependent Target Devices: x28xx
C-Callable Assembly Files: sgti1c.asm, sintb360.asm, sgen.h
Item C-Callable ASM Comments
Code Size� 26 words + 257 + cinit•
257 Look-up Table entries
Data RAM 0 words•
xDAIS ready Yes xDAIS component No IALG layer not implemented Multiple instances Yes Reentrancy Yes
Multiple Invocation
Yes
Stack usage 2 words Stack grows by 2 words
• Each pre-initialized SGENTI_1 structure consumes 8 words in the data memory and 11 words in the cinit section ∆∆∆∆ Each instance of SGENTI_1 module consumes 8 words in Data memory.
Single Channel SIN Generator (Table look-up and interpolation) SGENTI_1
out
freq
SGENTI_1
gain
offset
step_max
Texas Instruments Inc., September 2011 28
C/C-Callable ASM Interface C/C-Callable ASM Interface Object Definition
The structure of SGENTI_1 object is defined by the following structure definition typedef struct { unsigned int freq; unsigned int step_max; unsigned int alpha; int gain; int offset; int out; void (*calc)(void *); } SGENTI_1;
Module Terminal Variables/Functions
Item Name Description Format Range(Hex)
freq Frequency in hertz between [ ]MAXF,0
normalized to [ ]1,0
Q15 0-7FFF
offset DC offset in the SIN signal Q15 8000-7FFF
alpha Initial phase [ ]π2,0 Q16 0-FFFF
gain Gain of the SIN signal Q15 0-7FFF
Input
step_max
65536
max_ SMAX
FstepF
×= .
The default value is set to 1000 to generate the maximum frequency of 305.17Hz using 20KHz sampling loop.
Q0 0000-7FFF
Output out SIN Output Q15 8000-7FFF
Special Constants and Data types SGENTI_1
The module definition is created as a data type. This makes it convenient to instance an interface to the signal generator module. To create multiple instances of the module simply declare variables of type SGENTI_1
SGENTI_1_handle User defined Data type of pointer to SGENTI_1 Module
SGENTI_1_DEFAULTS
Structure symbolic constant to Initialize SGENTI_1 Module. This provides the initial values to the terminal variables as well as method pointers.
Methods void (*calc)(void *);
This function implements the single channel digital SIN signal generation using table look-up and linear interpolation technique.
Texas Instruments Inc., September 2011 29
C/C-Callable ASM Interface Module Usage
Instantiation The following example instances empty signal generator object SGENTI_1 sgen; Initialization
To Instance pre-initialized object SGENTI_1 sgen = SGENTI_1_DEFAULTS;
Invoking the computation function sgen.calc(&sgen);
Example
The following pseudo code exemplifies, 50Hz single channel digital SIN signal generation using SGENTI_1 module.
#include <sgen.h>
SGENTI_1 sgen=SGENTI_1_DEFAULTS;
int x1; main ( ) {
sgen.offset=0; sgen.gain=0x7fff; /* gain=1 in Q15 */ sgen.freq=5369; /* freq = (Required Freq/Max Freq)*2^15 */ /* = (50/305.17)*2^15 = 5369 */ sgen.step_max=1000; /* Max Freq= (step_max * sampling freq)/65536 */ /* Max Freq = (1000*20k)/65536 = 305.17 */
} void interrupt isr_20khz() {
sgen.calc(&sgen); x1=sgen.out;
} Note: Edit Linker Command file, to place the look-up table in Program memory.
SINTBL > PROG PAGE 0
Texas Instruments Inc., September 2011 30
Background Information Background Information
The signal generator modules are implemented using modulo arithmetic counter (i.e. Any overflow is ignored and only the remainder is kept) to precisely control the frequency. The frequency of the generated signal is reciprocal of the time it takes for successive overflow of modulo counter, which in turn commensurate with the step value added to the counter. Thus by changing the step value, one can precisely control the frequency.
The step value is not directly commanded to vary the frequency, instead the modulation of frequency is performed using the normalized variable “freq” which is normalized to the maximum frequency. The maximum required frequency is predetermined based on the application requirement and it set by initializing the “step_max” input. Thus, the normalized variable “freq” allows the user to control the frequency of the signal between 0 to maximum frequency.
The low THD sin generators are implemented using Table look-up and linear interpolation technique and it uses 16-bit modulo counter. The upper byte (8-bits) is used to index the 256-point look-up table and lower byte (8-bits) used to interpolate between the look-up table entries.
( )112
121 xx
xx
yyyy −×
−−+= (1)
The amount of time it takes for the 16-bit modulo counter to overflow, assuming that the counter is incremented in ISR.
ISRISR Tstep
Tstep
T ×=×= 65536216
(2)
The frequency of the generated SIN wave is reciprocal of the time, hence
ISRFstep
F ×=65536
(3)
Where ISR
ISR TF
1= is the ISR invocation frequency.
Thus the actual frequency of the SIN wave is determined by the “step” value used to increment the modulo-counter and the ISR execution rate. The signal generator modules use the normalized control variable to modulate the frequency instead of directly commanding the step value. The frequency control variable is normalized with respect to the maximum frequency.
1x 2x
1y
2y
x
Texas Instruments Inc., September 2011 31
Background Information
Assuming that the application requires the maximum frequency of 500Hz using 20Khz ISR loop. Then the step value to generate 500Hz is determined using equation (3)
4.163820000
65536500 =×=step
This step value of 1638 is used to initialize the “step_max” element of the signal generator module. The normalized control variable “freq” helps to control the frequency from 0 to 500Hz by varying it between 0 to 1 (Q15 format) with the frequency resolution of 0.305Hz
The frequency resolution is = max_step
FMAX , hence the “step_max” should be high to get good
frequency resolution. It should be set to at least “100” for reasonable frequency resolution. To generate SIN signal of frequency f , initialize the “freq” element of the SIN generator
module to 152×MAXf
f. Thus the required frequency is normalized with respect to the
maximum frequency as set by “step_max” and input as Q15 number to the SIN generator module.
Texas Instruments Inc., September 2011 32
Description This module generates dual channel digital SIN signal with phase control
using table look-up and linear interpolation technique. Availability C-Callable Assembly (CcA) Module Properties Type: Target Independent, Application Dependent Target Devices: x28xx
C-Callable Assembly files: sgti2c.asm, sintb360.asm, sgen.h
Item C-Callable ASM Comments
Code Size� 45 words + 257 + cinit•
257 Look-up Table entries
Data RAM 0 words•
xDAIS ready Yes xDAIS component No IALG layer not implemented Multiple instances Yes Reentrancy Yes
Multiple Invocation
Yes
Stack usage 2 words Stack grows by 2 words
• Each pre-initialized SGENTI_2 structure consumes 10 words in the data memory and 13 words in the cinit section ∆∆∆∆ Each instance of SGENTI_2 module consumes 10 words in Data memory.
Dual Channel SIN Generator (Table look-up and Interpolation) SGENTI_2
out1
SGENTI_2
freq
gain
offset
step_max
phase
out2
Texas Instruments Inc., September 2011 33
C/C-Callable ASM Interface C/C-Callable ASM Interface Object Definition
The structure of SGENTI_2 object is defined by the following structure definition typedef struct { unsigned int freq; unsigned int step_max; unsigned int alpha; int gain; int offset; int out1; unsigned int phase; int out2; void (*calc)(void *); } SGENTI_2;
Module Terminal Variables/Functions
Item Name Description Format Range(Hex)
freq Frequency in hertz between [ ]MAXF,0
normalized to [ ]1,0
Q15 0-7FFF
offset DC offset in the SIN signal Q15 8000-7FFF
alpha Initial phase [ ]π2,0 Q16 0-FFFF
gain Gain of the SIN signal Q15 0-7FFF
phase Phase angle between the two SIN outputs
[ ]ππ +− , is normalized to [ ]1,1 +−
Q15 8000-7FFF
Input
step_max
65536
max_ SMAX
FstepF
×= .
The default value is set to 1000 to generate the maximum frequency of 305.17Hz using 20KHz sampling loop.
Q0 0000-7FFF
out1 SIN Output 1 � ( )θsin Q15 8000-7FFF Output
out2 SIN Output 2 � ( )phase+θsin Q15 8000-7FFF
Special Constants and Data types SGENTI_2
The module definition is created as a data type. This makes it convenient to instance an interface to the signal generator module. To create multiple instances of the module simply declare variables of type SGENTI_2
SGENTI_2_handle User defined Data type of pointer to SGENTI_2 Module
SGENTI_2_DEFAULTS
Texas Instruments Inc., September 2011 34
C/C-Callable ASM Interface
Structure symbolic constant to Initialize SGENTI_2 Module. This provides the initial values to the terminal variables as well as method pointers.
Methods void (*calc)(void *);
This function implements the dual channel digital SIN signal generation with phase control using table look-up and linear interpolation technique.
Module Usage
Instantiation The following example instances empty signal generator object SGENTI_2 sgen; Initialization
To Instance pre-initialized object SGENTI_2 sgen = SGENTI_2_DEFAULTS;
Invoking the computation function sgen.calc(&sgen);
Example
The following pseudo code exemplifies, two 50Hz digital SIN signal generation with 90deg phase shift using SGENTI_2 module.
#include <sgen.h>
SGENTI_2 sgen=SGENTI_2_DEFAULTS;
Int x1, x2;
main ( ) {
sgen.offset=0; sgen.gain=0x7fff; /* gain = 1 in Q15 */ sgen.freq=5369; /* freq = (Required Freq/Max Freq)*2^15 */ /* = (50/305.17)*2^15 = 5369 */ sgen.step_max=1000; /* Max Freq= (step_max * sampling freq)/65536 */ /* Max Freq = (1000*20k)/65536 = 305.17 */
sgen.phase=4000h /* Phase = (required Phase)/180 in Q15 */ /* = (+90/180) in Q15 = 4000h */
} void interrupt isr_20khz() {
sgen.calc(&sgen); x1=sgen.out1; x2=sgen.out2;
} Note: Edit Linker Command file, to place the look-up table in Program memory.
SINTBL > PROG PAGE 0
Texas Instruments Inc., September 2011 35
Background Information Background Information
The signal generator modules are implemented using modulo arithmetic counter (i.e. Any overflow is ignored and only the remainder is kept) to precisely control the frequency. The frequency of the generated signal is reciprocal of the time it takes for successive overflow of modulo counter, which in turn commensurate with the step value added to the counter. Thus by changing the step value, one can precisely control the frequency.
The step value is not directly commanded to vary the frequency, instead the modulation of frequency is performed using the normalized variable “freq” which is normalized to the maximum frequency. The maximum required frequency is predetermined based on the application requirement and it set by initializing the “step_max” input. Thus, the normalized variable “freq” allows the user to control the frequency of the signal between 0 to maximum frequency.
The low THD sin generators are implemented using Table look-up and linear interpolation technique and it uses 16-bit modulo counter. The upper byte (8-bits) is used to index the 256-point look-up table and lower byte (8-bits) used to interpolate between the look-up table entries.
( )112
121 xx
xx
yyyy −×
−−+= (1)
The amount of time it takes for the 16-bit modulo counter to overflow, assuming that the counter is incremented in ISR.
ISRISR Tstep
Tstep
T ×=×= 65536216
(2)
The frequency of the generated SIN wave is reciprocal of the time, hence
ISRFstep
F ×=65536
(3)
Where ISR
ISR TF
1= is the ISR invocation frequency.
Thus the actual frequency of the SIN wave is determined by the “step” value used to increment the modulo-counter and the ISR execution rate. The signal generator modules use the normalized control variable to modulate the frequency instead of directly commanding the step value. The frequency control variable is normalized with respect to the maximum frequency.
1x 2x
1y
2y
x
Texas Instruments Inc., September 2011 36
Background Information
Assuming that the application requires the maximum frequency of 500Hz using 20Khz ISR loop. Then the step value to generate 500Hz is determined using equation (3)
4.163820000
65536500 =×=step
This step value of 1638 is used to initialize the “step_max” element of the signal generator module. The normalized control variable “freq” helps to control the frequency from 0 to 500Hz by varying it between 0 to 1 (Q15 format) with the frequency resolution of 0.305Hz
The frequency resolution is = max_step
FMAX , hence the “step_max” should be high to get good
frequency resolution. It should be set to at-least “100” for reasonable frequency resolution. To generate SIN signal of frequency f , initialize the “freq” element of the SIN generator
module to 152×MAXf
f. Thus the required frequency is normalized with respect to the
maximum frequency as set by “step_max” and input as Q15 number to the SIN generator module.
Texas Instruments Inc., September 2011 37
Description This module generates 3-phase digital SIN signal with fixed 120° phase
shift between the channels using table look-up and linear interpolation technique.
Availability C-Callable Assembly (CcA) Module Properties Type: Target Independent, Application Dependent Target Devices: x28xx
C-Callable Assembly files: sgti3c.asm, sintb360.asm, sgen.h
Item C-Callable ASM Comments
Code Size� 66 words + 257 + cinit•
257 Look-up Table entries
Data RAM 0 words•
xDAIS ready Yes xDAIS component No IALG layer not implemented Multiple instances Yes Reentrancy Yes
Multiple Invocation
Yes
Stack usage 2 words Stack grows by 2 words
• Each pre-initialized SGENTI_3 structure consumes 10 words in the data memory and 13 words in the cinit section ∆∆∆∆ Each instance of SGENTI_3 module consumes 10 words in Data memory.
Three Phase SIN Generator (Table look-up and interpolation) SGENTI_3
out1
SGENTI_3
freq
gain
offset
step_max out3
out2
Texas Instruments Inc., September 2011 38
C/C-Callable ASM Interface C/C-Callable ASM Interface Object Definition
The structure of SGENTI_3 object is defined by the following structure definition typedef struct { unsigned int freq; unsigned int step_max; unsigned int alpha; int gain; int offset; int out1; int out2; int out3; void (*calc)(void *); } SGENTI_3;
Module Terminal Variables/Functions
Item Name Description Format Range(Hex)
freq Frequency in hertz between [ ]MAXF,0
normalized to [ ]1,0
Q15 0-7FFF
offset DC offset in the SIN signal Q15 8000-7FFF
alpha Initial phase [ ]π2,0 Q16 0-FFFF
gain Gain of the SIN signal Q15 0-7FFF
Input
step_max
65536
max_ SMAX
FstepF
×= .
The default value is set to 1000 to generate the maximum frequency of 305.17Hz using 20KHz sampling loop.
Q0 0000-7FFF
out1 SIN Output 1 � ( )θsin Q15 8000-7FFF
out2 SIN Output 2 � ( )o120sin +θ Q15 8000-7FFF
Output
out3 SIN Output 3 � ( )o240sin +θ Q15 8000-7FFF
Special Constants and Data types SGENTI_3
The module definition is created as a data type. This makes it convenient to instance an interface to the signal generator module. To create multiple instances of the module simply declare variables of type SGENTI_3
SGENTI_3_handle User defined Data type of pointer to SGENTI_3 Module
SGENTI_3_DEFAULTS
Texas Instruments Inc., September 2011 39
C/C-Callable ASM Interface
Structure symbolic constant to Initialize SGENTI_3 Module. This provides the initial values to the terminal variables as well as method pointers.
Methods void (*calc)(void *);
This function implements 3-phase digital SIN signal generation with fixed 120° phase shift between the channels using table look-up and linear interpolation technique.
Module Usage Instantiation
The following example instances empty generic signal generator object SGENTI_3 sgen; Initialization
To Instance pre-initialized object SGENTI_3 sgen = SGENTI_3_DEFAULTS;
Invoking the computation function sgen.calc(&sgen);
Example The following pseudo code exemplifies, 3-phase digital SIN signal (50Hz) generation using SGENTI_3 module.
#include <sgen.h>
SGENTI_3 sgen=SGENTI_3_DEFAULTS;
Int x1, x2, x3;
main ( ) {
sgen.offset=0; sgen.gain=0x7fff; /* gain = 1 in Q15 */ sgen.freq=5369; /* freq = (Required Freq/Max Freq)*2^15 */ /* = (50/305.17)*2^15 = 5369 */ sgen.step_max=1000; /* Max Freq= (step_max * sampling freq)/65536 */ /* Max Freq = (1000*20k)/65536 = 305.17 */
sgen.phase=4000h /* Phase = (required Phase)/180 in Q15 */ /* = (+90/180) in Q15 = 4000h */
} void interrupt isr_20khz() {
sgen.calc(&sgen); x1=sgen.out1; x2=sgen.out2;
x3=sgen.out3; } Note: Edit Linker Command file, to place the look-up table in Program memory.
SINTBL > PROG PAGE 0
Texas Instruments Inc., September 2011 40
Background Information Background Information
The signal generator modules are implemented using modulo arithmetic counter (i.e. Any overflow is ignored and only the remainder is kept) to precisely control the frequency. The frequency of the generated signal is reciprocal of the time it takes for successive overflow of modulo counter, which in turn commensurate with the step value added to the counter. Thus by changing the step value, one can precisely control the frequency.
The step value is not directly commanded to vary the frequency, instead the modulation of frequency is performed using the normalized variable “freq” which is normalized to the maximum frequency. The maximum required frequency is predetermined based on the application requirement and it set by initializing the “step_max” input. Thus, the normalized variable “freq” allows the user to control the frequency of the signal between 0 to maximum frequency.
The low THD sin generators are implemented using Table look-up and linear interpolation technique and it uses 16-bit modulo counter. The upper byte (8-bits) is used to index the 256-point look-up table and lower byte (8-bits) used to interpolate between the look-up table entries.
( )112
121 xx
xx
yyyy −×
−−+= (1)
The amount of time it takes for the 16-bit modulo counter to overflow, assuming that the counter is incremented in ISR.
ISRISR Tstep
Tstep
T ×=×= 65536216
(2)
The frequency of the generated SIN wave is reciprocal of the time, hence
ISRFstep
F ×=65536
(3)
Where ISR
ISR TF
1= is the ISR invocation frequency.
Thus the actual frequency of the SIN wave is determined by the “step” value used to increment the modulo-counter and the ISR execution rate. The signal generator modules use the normalized control variable to modulate the frequency instead of directly commanding the step value. The frequency control variable is normalized with respect to the maximum frequency.
1x 2x
1y
2y
x
Texas Instruments Inc., September 2011 41
Background Information
Assuming that the application requires the maximum frequency of 500Hz using 20Khz ISR loop. Then the step value to generate 500Hz is determined using equation (3)
4.163820000
65536500 =×=step
This step value of 1638 is used to initialize the “step_max” element of the signal generator module. The normalized control variable “freq” helps to control the frequency from 0 to 500Hz by varying it between 0 to 1 (Q15 format) with the frequency resolution of 0.305Hz
The frequency resolution is = max_step
FMAX , hence the “step_max” should be high to get good
frequency resolution. It should be set to at least “100” for reasonable frequency resolution. To generate SIN signal of frequency f , initialize the “freq” element of the SIN generator
module to 152×MAXf
f. Thus the required frequency is normalized with respect to the
maximum frequency as set by “step_max” and input as Q15 number to the SIN generator module.
Texas Instruments Inc., September 2011 42
Description This module generates dual, 3-phase digital SIN signal with fixed 120°
phase shift between the channels and phase control between the two three phase signals using table look-up and linear interpolation technique.
Availability C-Callable Assembly (CcA) Module Properties Type: Target Independent, Application Dependent Target Devices: x28xx
C-Callable Assembly Files: sgti3dc.asm, sintb360.asm, sgen.h
Item C-Callable ASM Comments
Code Size� 128 words + 257 + cinit•
257 Look-up Table entries
Data RAM 0 words•
xDAIS ready Yes xDAIS component No IALG layer not implemented Multiple instances Yes Reentrancy Yes
Multiple Invocation
Yes
Stack usage 2 words Stack grows by 2 words
• Each pre-initialized SGENTI_3D structure consumes 14 words in the data memory and 17 words in the cinit section ∆∆∆∆ Each instance of SGENTI_3D module consumes 14 words in Data memory.
Dual, three Phase SIN Generator (Table look-up and interpolation) SGENTI_3D
SGENTI_3D
freq
gain
offset
step_max
phase
out11
out13
out12
out21
out23
out22
Texas Instruments Inc., September 2011 43
C/C-Callable ASM Interface C/C-Callable ASM Interface Object Definition
The structure of SGENTI_3D object is defined by the following structure definition typedef struct { unsigned int freq; unsigned int step_max; unsigned int alpha; int gain; int offset; int out11; int out12; int out13; unsigned int phase; int out21; int out22; int out23; void (*calc)(void *); } SGENTI_3D;
Module Terminal Variables/Functions
Item Name Description Format Range
(Hex) freq Frequency in hertz between [ ]MAXF,0
normalized to [ ]1,0
Q15 0-7FFF
offset DC offset in the SIN signal Q15 8000-7FFF
alpha Initial phase [ ]π2,0 Q16 0-FFFF
gain Gain of the SIN signal Q15 0-7FFF
Input
step_max
65536
max_ SMAX
FstepF
×= .
The default value is set to 1000 to generate the maximum frequency of 305.17Hz using 20KHz sampling loop.
Q0 0000-7FFF
out11 SIN Output 11 � ( )θsin Q15 8000-7FFF
out12 SIN Output 12 � ( )o120sin +θ Q15 8000-7FFF
out13 SIN Output 13 � ( )o240sin +θ Q15 8000-7FFF
out21 SIN Output 21 � ( )phase+θsin Q15 8000-7FFF
out22 SIN Output 22 � ( )phase++ o120sin θ Q15 8000-7FFF
Output
out23 SIN Output 23 � ( )phase++ o240sin θ Q15 8000-7FFF
Texas Instruments Inc., September 2011 44
C/C-Callable ASM Interface Special Constants and Data types SGENTI_3D
The module definition is created as a data type. This makes it convenient to instance an interface to the signal generator module. To create multiple instances of the module simply declare variables of type SGENTI_3D
SGENTI_3D_handle User defined Data type of pointer to SGENTI_3D Module
SGENTI_3_DEFAULTS
Structure symbolic constant to Initialize SGENTI_3D Module. This provides the initial values to the terminal variables as well as method pointers.
Methods void (*calc)(void *);
This function implements two, 3-phase digital SIN signal generation with phase control between the three phase signals using table look-up and linear interpolation technique.
Module Usage
Instantiation The following example instances empty generic signal generator object SGENTI_3D sgen; Initialization
To Instance pre-initialized object SGENTI_3D sgen = SGENTI_3D_DEFAULTS;
Invoking the computation function sgen.calc(&sgen);
Texas Instruments Inc., September 2011 45
C/C-Callable ASM Interface Example The following pseudo code exemplifies, dual 3-phase digital SIN signal (50Hz) generation with 90deg phase shift between the three phase signals using SGENTI_3D module.
#include <sgen.h>
SGENTI_3D sgen=SGENTI_3D_DEFAULTS;
Int x11, x12, x13, x21, x22, x23;
main ( ) {
sgen.offset=0; sgen.gain=0x7fff; /* gain = 1 in Q15 */ sgen.freq=5369; /* freq = (Required Freq/Max Freq)*2^15 */ /* = (50/305.17)*2^15 = 5369 */ sgen.step_max=1000; /* Max Freq= (step_max * sampling freq)/65536 */ /* Max Freq = (1000*20k)/65536 = 305.17 */
sgen.phase=4000h /* Phase = (required Phase)/180 in Q15 */ /* = (+90/180) in Q15 = 4000h */
} void interrupt isr_20khz() {
sgen.calc(&sgen); x11=sgen.out11; x12=sgen.out12;
x13=sgen.out13; x21=sgen.out21;
x22=sgen.out22; x23=sgen.out23; } Note: Edit Linker Command file, to place the look-up table in Program memory.
SINTBL > PROG PAGE 0
Texas Instruments Inc., September 2011 46
Background Information Background Information
The signal generator modules are implemented using modulo arithmetic counter (i.e. Any overflow is ignored and only the remainder is kept) to precisely control the frequency. The frequency of the generated signal is reciprocal of the time it takes for successive overflow of modulo counter, which in turn commensurate with the step value added to the counter. Thus by changing the step value, one can precisely control the frequency.
The step value is not directly commanded to vary the frequency, instead the modulation of frequency is performed using the normalized variable “freq” which is normalized to the maximum frequency. The maximum required frequency is predetermined based on the application requirement and it set by initializing the “step_max” input. Thus, the normalized variable “freq” allows the user to control the frequency of the signal between 0 to maximum frequency.
The low THD sin generators are implemented using Table look-up and linear interpolation technique and it uses 16-bit modulo counter. The upper byte (8-bits) is used to index the 256-point look-up table and lower byte (8-bits) used to interpolate between the look-up table entries.
( )112
121 xx
xx
yyyy −×
−−+= (1)
The amount of time it takes for the 16-bit modulo counter to overflow, assuming that the counter is incremented in ISR.
ISRISR Tstep
Tstep
T ×=×= 65536216
(2)
The frequency of the generated SIN wave is reciprocal of the time, hence
ISRFstep
F ×=65536
(3)
Where ISR
ISR TF
1= is the ISR invocation frequency.
Thus the actual frequency of the SIN wave is determined by the “step” value used to increment the modulo-counter and the ISR execution rate. The signal generator modules use the normalized control variable to modulate the frequency instead of directly commanding the step value. The frequency control variable is normalized with respect to the maximum frequency.
1x 2x
1y
2y
x
Texas Instruments Inc., September 2011 47
Background Information
Assuming that the application requires the maximum frequency of 500Hz using 20Khz ISR loop. Then the step value to generate 500Hz is determined using equation (3)
4.163820000
65536500 =×=step
This step value of 1638 is used to initialize the “step_max” element of the signal generator module. The normalized control variable “freq” helps to control the frequency from 0 to 500Hz by varying it between 0 to 1 (Q15 format) with the frequency resolution of 0.305Hz
The frequency resolution is = max_step
FMAX , hence the “step_max” should be high to get good
frequency resolution. It should be set to at least “100” for reasonable frequency resolution. To generate SIN signal of frequency f , initialize the “freq” element of the SIN generator
module to 152×MAXf
f. Thus the required frequency is normalized with respect to the
maximum frequency as set by “step_max” and input as Q15 number to the SIN generator module.
Texas Instruments Inc., September 2011 48
Description This module generates single channel digital SIN signal using table look-
up and linear interpolation technique and it uses 32-bit integration counter for high precision SIN generation.
Availability C-Callable Assembly (CcA) Module Properties Type: Target Independent, Application Dependent Target Devices: x28xx
C-Callable Assembly files: sghp1c.asm, sintb360.asm, sgen.h
Item C-Callable ASM Comments
Code Size� 34 words + 257 + cinit•
257 Look-up Table entries
Data RAM 0 words•
xDAIS ready Yes xDAIS component No IALG layer not implemented Multiple instances Yes Reentrancy Yes
Multiple Invocation
Yes
Stack usage 2 words Stack grows by 2 words
• Each pre-initialized SGENHP_1 structure consumes 12 words in the data memory and 15 words in the cinit section ∆∆∆∆ Each instance of SGENHP_1 module consumes 12 words in Data memory.
Single Channel SIN Generator (High precision) SGENHP_1
out
freq
SGENHP_1
gain
offset
step_max
Texas Instruments Inc., September 2011 49
C/C-Callable ASM Interface C/C-Callable ASM Interface Object Definition
The structure of SGENHP_1 object is defined by the following structure definition typedef struct { void (*calc)(void *); unsigned long int freq; unsigned long int step_max; unsigned long int alpha; int gain; int offset; int out; } SGENHP_1;
Module Terminal Variables/Functions
Item Name Description Format Range(Hex)
freq Frequency in hertz between [ ]MAXF,0
normalized to [ ]1,0
Q31 0-7FFFFFFF
offset DC offset in the SIN signal Q15 8000-7FFF
alpha Initial phase [ ]π2,0 Q16 0-FFFF
gain Gain of the SIN signal Q15 0-7FFF
Input
step_max
322
max_ SMAX
FstepF
×= .
The default value is set to 1000 to generate the maximum frequency of 305.17Hz using 20KHz sampling loop.
Q0 0-7FFFFFFF
Output out SIN Output Q15 8000-7FFF
Special Constants and Data types SGENHP_1
The module definition is created as a data type. This makes it convenient to instance an interface to the signal generator module. To create multiple instances of the module simply declare variables of type SGENHP_1
SGENHP_1_handle User defined Data type of pointer to SGENHP_1 Module
SGENHP_1_DEFAULTS
Structure symbolic constant to Initialize SGENHP_1 Module. This provides the initial values to the terminal variables as well as method pointers.
Methods void (*calc)(void *);
Texas Instruments Inc., September 2011 50
C/C-Callable ASM Interface
This function implement the single channel digital SIN signal generation using table look-up and linear interpolation technique and it uses 32-bit integrator to generate high precision SIN signal.
Module Usage
Instantiation The following example instances empty signal generator object SGENHP_1 sgen; Initialization
To Instance pre-initialized object SGENHP_1 sgen = SGENHP_1_DEFAULTS;
Invoking the computation function sgen.calc(&sgen);
Example
The following pseudo code exemplifies, 50Hz single channel digital SIN signal generation using SGENHP_1 module.
#include <sgen.h>
SGENHP_1 sgen=SGENHP_1_DEFAULTS;
int x1; main ( ) {
sgen.offset=0; sgen.gain=0x7fff; /* gain=1 in Q15 */ sgen.freq=0x14F8CF92; /* freq = (Required Freq/Max Freq)*2^31 */ /* = (50/305.17)*2^31 = 0x14f8cf92 */ sgen.step_max=0x3E7FB26; /* Max Freq= (step_max * sampling freq)/2^32 */ /* =(0x3E7FB26*20k)/2^32 = 305.17 */ } void interrupt isr_20khz() {
sgen.calc(&sgen); x1=sgen.out;
} Note: Edit Linker Command file, to place the look-up table in Program memory.
SINTBL > PROG PAGE 0
Texas Instruments Inc., September 2011 51
Background Information Background Information
The signal generator modules are implemented using modulo arithmetic counter (i.e. Any overflow is ignored and only the remainder is kept) to precisely control the frequency. The frequency of the generated signal is reciprocal of the time it takes for successive overflow of modulo counter, which in turn commensurate with the step value added to the counter. Thus by changing the step value, one can precisely control the frequency.
The step value is not directly commanded to vary the frequency, instead the modulation of frequency is performed using the normalized variable “freq” which is normalized to the maximum frequency. The maximum required frequency is predetermined based on the application requirement and it set by initializing the “step_max” input. Thus, the normalized variable “freq” allows the user to control the frequency of the signal between 0 to maximum frequency.
The high precision sin generators are implemented using Table look-up and linear interpolation technique and it uses 32-bit modulo counter. The upper byte (8-bits) is used to index the 256-point look-up table and the 15-bits following the upper byte are used to interpolate between the look-up table entries.
( )112
121 xx
xx
yyyy −×
−−+= (1)
The amount of time it takes for the 32-bit modulo counter to overflow, assuming that the counter is incremented in ISR.
ISRTstep
T ×=322
(2)
The frequency of the generated SIN wave is reciprocal of the time, hence
ISRFstep
F ×=322
(3)
Where ISR
ISR TF
1= is the ISR invocation frequency.
Thus the actual frequency of the SIN wave is determined by the “step” value used to increment the modulo-counter and the ISR execution rate. The signal generator modules use the normalized control variable to modulate the frequency instead of directly commanding the step value. The frequency control variable is normalized with respect to the maximum frequency.
1x 2x
1y
2y
x
Texas Instruments Inc., September 2011 52
Background Information
Assuming that the application requires the maximum frequency of 500Hz using 20Khz ISR loop. Then the step value to generate 500Hz is determined using equation (3)
4.10737418220000
2500 32
=×=step
This step value of 107374182 is used to initialize the “step_max” element of the signal generator module. The normalized control variable “freq” helps to control the frequency from 0 to 500Hz by varying it between 0 to 1 (Q15 format) with the frequency resolution given by equation (4)
The frequency resolution is = max_step
FMAX (4)
Hence the “step_max” should be high to get good frequency resolution. It should be set to at least “100” for reasonable frequency resolution. To generate SIN signal of frequency f , initialize the “freq” element of the SIN generator
module to 312×MAXf
f. Thus the required frequency is normalized with respect to the
maximum frequency as set by “step_max” and input as Q31 number to the SIN generator module.
Since the frequency control variable is represented in Q31 format, we can precisely generate the required frequency.
Texas Instruments Inc., September 2011 53
Description This module generates single channel digital SIN signal using table look-
up and linear interpolation technique with phase control and it uses 32-bit integration counter for high precision SIN generation.
Availability C-Callable Assembly (CcA) Module Properties Type: Target Independent, Application Dependent Target Devices: x28xx
C-Callable Assembly files: sghp2c.asm, sintb360.asm, sgen.h
Item C-Callable ASM Comments
Code Size� 57 words + 257 + cinit•
257 Look-up Table entries
Data RAM 0 words•
xDAIS ready Yes xDAIS component No IALG layer not implemented Multiple instances Yes Reentrancy Yes
Multiple Invocation
Yes
Stack usage 2 words Stack grows by 2 words
• Each pre-initialized SGENHP_2 structure consumes 14 words in the data memory and 17 words in the cinit section ∆∆∆∆ Each instance of SGENHP_2 module consumes 14 words in Data memory.
Dual Channel SIN Generator (High precision) SGENHP_2
out1
SGENHP_2
freq
gain
offset
step_max
phase
out2
Texas Instruments Inc., September 2011 54
C/C-Callable ASM Interface C/C-Callable ASM Interface Object Definition
The structure of SGENHP_2 object is defined by the following structure definition typedef struct { unsigned long int freq; unsigned long int step_max; unsigned long int alpha; int gain; int offset; int out1; int out2; unsigned long int phase; void (*calc)(void *); } SGENHP_2;
Module Terminal Variables/Functions
Item Name Description Format Range(Hex)
freq Frequency in hertz between [ ]MAXF,0
normalized to [ ]1,0
Q31 0-7FFFFFFF
offset DC offset in the SIN signal Q15 8000-7FFF
alpha Initial phase [ ]π2,0 Q32 0-FFFFFFFF
gain Gain of the SIN signal Q15 0-7FFF
phase Phase angle between the two SIN outputs
[ ]ππ +− , is normalized to [ ]1,1 +−
Q15 8000-7FFF
Input
step_max
322
max_ SMAX
FstepF
×= .
The default value is set to 1000 to generate the maximum frequency of 305.17Hz using 20KHz sampling loop.
Q0 0-7FFFFFFF
out1 SIN Output 1 � ( )θsin Q15 8000-7FFF Output
out2 SIN Output 2 � ( )phase+θsin Q15 8000-7FFF
Special Constants and Data types SGENHP_2
The module definition is created as a data type. This makes it convenient to instance an interface to the signal generator module. To create multiple instances of the module simply declare variables of type SGENHP_2
SGENHP_2_handle User defined Data type of pointer to SGENHP_2 Module
SGENHP_2_DEFAULTS
Texas Instruments Inc., September 2011 55
C/C-Callable ASM Interface
Structure symbolic constant to Initialize SGENHP_2 Module. This provides the initial values to the terminal variables as well as method pointers.
Methods void (*calc)(void *);
This function implements the dual channel digital SIN signal generation using table look-up and linear interpolation technique with phase control and it uses 32-bit integrator to generate high precision SIN signal.
Module Usage
Instantiation The following example instances empty signal generator object SGENHP_2 sgen; Initialization
To Instance pre-initialized object SGENHP_2 sgen = SGENHP_2_DEFAULTS;
Invoking the computation function sgen.calc(&sgen);
Example
The following pseudo code exemplifies, two 50Hz digital SIN signal generation with 90deg phase shift using SGENHP_2 module.
#include <sgen.h>
SGENHP_2 sgen=SGENHP_2_DEFAULTS;
int x1, x2;
main( ) {
sgen.offset=0; sgen.gain=0x7fff; /* gain=1 in Q15 */ sgen.freq=0x14F8CF92; /* freq = (Required Freq/Max Freq)*2^31 */ /* = (50/305.17)*2^31 = 0x14f8cf92 */ sgen.step_max=0x3E7FB26; /* Max Freq= (step_max * sampling freq)/2^32 */ /* =(0x3E7FB26*20k)/2^32 = 305.17 */
sgen.phase=0x40000000; /* Phase= (required Phase)/180 in Q31 */ /* = (+90/180) in Q31 = 40000000h */ } void interrupt isr_20khz() {
sgen.calc(&sgen); x1=sgen.out1; x2=sgen.out2;
} Note: Edit Linker Command file, to place the look-up table in Program memory.
SINTBL > PROG PAGE 0
Texas Instruments Inc., September 2011 56
Background Information Background Information
The signal generator modules are implemented using modulo arithmetic counter (i.e. Any overflow is ignored and only the remainder is kept) to precisely control the frequency. The frequency of the generated signal is reciprocal of the time it takes for successive overflow of modulo counter, which in turn commensurate with the step value added to the counter. Thus by changing the step value, one can precisely control the frequency.
The step value is not directly commanded to vary the frequency, instead the modulation of frequency is performed using the normalized variable “freq” which is normalized to the maximum frequency. The maximum required frequency is predetermined based on the application requirement and it set by initializing the “step_max” input. Thus, the normalized variable “freq” allows the user to control the frequency of the signal between 0 to maximum frequency.
The high precision sin generators are implemented using Table look-up and linear interpolation technique and it uses 32-bit modulo counter. The upper byte (8-bits) is used to index the 256-point look-up table and the 15-bits following the upper byte are used to interpolate between the look-up table entries.
( )112
121 xx
xx
yyyy −×
−−+= (1)
The amount of time it takes for the 32-bit modulo counter to overflow, assuming that the counter is incremented in ISR.
ISRTstep
T ×=322
(2)
The frequency of the generated SIN wave is reciprocal of the time, hence
ISRFstep
F ×=322
(3)
Where ISR
ISR TF
1= is the ISR invocation frequency.
Thus the actual frequency of the SIN wave is determined by the “step” value used to increment the modulo-counter and the ISR execution rate. The signal generator modules use the normalized control variable to modulate the frequency instead of directly commanding the step value. The frequency control variable is normalized with respect to the maximum frequency.
1x 2x
1y
2y
x
Texas Instruments Inc., September 2011 57
Background Information
Assuming that the application requires the maximum frequency of 500Hz using 20Khz ISR loop. Then the step value to generate 500Hz is determined using equation (3)
4.10737418220000
2500 32
=×=step
This step value of 107374182 is used to initialize the “step_max” element of the signal generator module. The normalized control variable “freq” helps to control the frequency from 0 to 500Hz by varying it between 0 to 1 (Q15 format) with the frequency resolution given by equation (4)
The frequency resolution is = max_step
FMAX (4)
Hence the “step_max” should be high to get good frequency resolution. It should be set to at least “100” for reasonable frequency resolution. To generate SIN signal of frequency f , initialize the “freq” element of the SIN generator
module to 312×MAXf
f. Thus the required frequency is normalized with respect to the
maximum frequency as set by “step_max” and input as Q31 number to the SIN generator module.
Since the frequency control variable is represented in Q31 format, we can precisely generate the required frequency.
Texas Instruments Inc., September 2011 58
Description This module generates ramp output (Positive or Negative ramp) of
adjustable gain, frequency and DC offset. Availability C-Callable Assembly (CcA) Module Properties Type: Target Independent, Application Dependent Target Devices: x28xx
C-Callable Assembly Files: rampgc.asm, sgen.h
Item C-Callable ASM Comments
Code Size� 12 words + cinit• Data RAM 0 words•
xDAIS ready Yes xDAIS component No IALG layer not implemented Multiple instances Yes Reentrancy Yes
Multiple Invocation
Yes
Stack usage 2 words Stack grows by 2 words
• Each pre-initialized RMPGEN structure consumes 8 words in the data memory and 11 words in the cinit section ∆∆∆∆ Each instance of RMPGEN module consumes 8 words in Data memory.
Ramp Generator RMPGEN
out
freq
RMPGEN
gain
offset
step_max
Texas Instruments Inc., September 2011 59
C/C-Callable ASM Interface C/C-Callable ASM Interface Object Definition
The structure of RMPGEN object is defined by the following structure definition typedef struct { int freq; unsigned int step_max; unsigned int alpha; int gain; int offset; int out; void (*calc)(void *); } RMPGEN;
Module Terminal Variables/Functions
Item Name Description Format Range(Hex)
freq Frequency in hertz between
[ ]MAXMAX FF ,− normalized to [ ]1,1− .
The positive frequency input generates ramp up (+ve Ramp) and negative frequency input generates ramp down output (-ve Ramp)
Q15 8000-7FFF
offset DC offset in the ramp signal Q15 8000-7FFF
alpha Initial phase [ ]π2,0 Q16 0-FFFF
gain Gain of the ramp signal Q15 0-7FFF
Input
step_max
65536
max_ SMAX
FstepF
×= .
The default value is set to 1000 to generate the maximum frequency of 305.17Hz using 20KHz sampling loop.
Q0 0000-7FFF
Output out SIN Output Q15 8000-7FFF
Special Constants and Data types RMPGEN
The module definition is created as a data type. This makes it convenient to instance an interface to the signal generator module. To create multiple instances of the module simply declare variables of type RMPGEN.
RMPGEN_handle User defined Data type of pointer to RMPGEN Module
SGENTI_1_DEFAULTS
Structure symbolic constant to Initialize RMPGEN Module. This provides the initial values to the terminal variables as well as method pointers.
Methods void (*calc)(void *);
This function generates ramp output with adjustable gain, frequency and DC offset.
Texas Instruments Inc., September 2011 60
C/C-Callable ASM Interface Module Usage
Instantiation The following example instances empty signal generator object RMPGEN sgen; Initialization
To Instance pre-initialized object RMPGEN sgen = RMPGEN_DEFAULTS;
Invoking the computation function sgen.calc(&sgen);
Example
The following pseudo code exemplifies, 50Hz negative ramp signal generation using RMPGEN module. #include <sgen.h>
RMPGEN sgen=RMPGEN_DEFAULTS;
int x1; main ( ) {
sgen.offset=0; sgen.gain=0x7fff; /* gain=1 in Q15 */ sgen.freq=-5369; /* freq = (Required Freq/Max Freq)*2^15 */ /* = (50/305.17)*2^15 = 5369 */
/* Negate freq input for –ve ramp */
sgen.step_max=1000; /* Max Freq= (step_max * sampling freq)/65536 */ /* Max Freq = (1000*20k)/65536 = 305.17 */
} void interrupt isr_20khz() {
sgen.calc(&sgen); x1=sgen.out;
}
Texas Instruments Inc., September 2011 61
Background Information Background Information
The signal generator modules are implemented using modulo arithmetic counter (i.e. Any overflow is ignored and only the remainder is kept) to precisely control the frequency. The frequency of the generated signal is reciprocal of the time it takes for successive overflow of modulo counter, which in turn commensurate with the step value added to the counter. Thus by changing the step value, one can precisely control the frequency.
The step value is not directly commanded to vary the frequency, instead the modulation of frequency is performed using the normalized variable “freq” which is normalized to the maximum frequency. The maximum required frequency is predetermined based on the application requirement and it set by initializing the “step_max” input. Thus, the normalized variable “freq” allows the user to control the frequency of the signal between 0 to maximum frequency. The amount of time it takes for the 16-bit modulo counter to overflow, assuming that the counter is incremented in ISR.
ISRISR Tstep
Tstep
T ×=×= 65536216
(1)
The frequency of the generated ramp signal is reciprocal of the time, hence
ISRFstep
F ×=65536
(2)
Where ISR
ISR TF
1= is the ISR invocation frequency.
Thus the actual frequency of the ramp is determined by the “step” value used to increment the modulo-counter and the ISR execution rate. The signal generator modules use the normalized control variable to modulate the frequency instead of directly commanding the step value. The frequency control variable is normalized with respect to the maximum frequency. Assuming that the application requires the maximum frequency of 500Hz using 20Khz ISR loop. Then the step value to generate 500Hz is determined using equation (2)
4.163820000
65536500 =×=step
This step value of 1638 is used to initialize the “step_max” element of the signal generator module. The normalized control variable “freq” helps to control the frequency from 0 to 500Hz by varying it between 0 to 1 (Q15 format) with the frequency resolution of 0.305Hz
The frequency resolution is = max_step
FMAX , hence the “step_max” should be high to get good
frequency resolution. It should be set to at least “100” for reasonable frequency resolution.
Texas Instruments Inc., September 2011 62
Background Information
To generate RAMP signal of frequency f , initialize the “freq” element of the ramp generator
module to 152×MAXf
f. Thus the required frequency is normalized with respect to the
maximum frequency as set by “step_max” and input as Q15 number to the ramp generator module. The negative frequency input generates negative ramp output.
Positive Ramp Output: Negative Ramp Output:
offset
gain
T
0
gain
offset
T
0
Texas Instruments Inc., September 2011 63
Description This module generates trapezoidal output of adjustable gain, frequency
and DC offset. Input pre-scalar is provided to generate very low frequency output.
Availability C-Callable Assembly (CcA) Module Properties Type: Target Independent, Application Dependent Target Devices: x28xx
C-Callable Assembly Files: tzdlgc.asm, sgen.h
Item C-Callable ASM Comments
Code Size� 89 words + cinit• Data RAM 0 words•
xDAIS ready Yes xDAIS component No IALG layer not implemented Multiple instances Yes Reentrancy Yes
Multiple Invocation
Yes
Stack usage 2 words Stack grows by 2 words
• Each pre-initialized TZDLGEN structure consumes 14 words in the data memory and 17 words in the cinit section ∆∆∆∆ Each instance of TZDLGEN module consumes 14 words in Data memory.
Trapezoidal Generator TZDLGEN
out
TZDLGEN
gain
offset
step_max
prescalar
Texas Instruments Inc., September 2011 64
C/C-Callable ASM Interface C/C-Callable ASM Interface Object Definition
The structure of TZDLGEN object is defined by the following structure definition typedef struct { unsigned int skip_cntr; unsigned int prescalar;
unsigned int freq; unsigned int step_max; unsigned int task; unsigned int alpha; int gain; int offset; int out; void (*init)(void *); void (*calc)(void *); } TZDLGEN;
Module Terminal Variables/Functions
Item Name Description Format Range(Hex)
freq Frequency in hertz between [ ]MAXF,0
normalized to [ ]1,0
Q15 0000-7FFF
offset DC offset in the trapezoidal signal Q15 8000-7FFF
alpha Initial phase [ ]π2,0 Q16 0-FFFF
gain Gain of the trapezoidal signal Q15 0-7FFF
prescalar Prescalar for modulo counter, used to generate very low frequency.
Q0 0-7FFF
Input
step_max
prescalar
FstepF S
MAX ×××
=655364
max_.
The default value is set to 4000 to generate the maximum frequency of 305.17Hz using 20KHz sampling loop and unity prescalar.
Q0 0000-7FFF
Output out Trapezoidal Output Q15 8000-7FFF
Special Constants and Data types TZDLGEN
The module definition is created as a data type. This makes it convenient to instance an interface to the signal generator module. To create multiple instances of the module simply declare variables of type TZDLGEN.
TZDLGEN_handle User defined Data type of pointer to TZDLGEN module
TZDLGEN_DEFAULTS
Texas Instruments Inc., September 2011 65
C/C-Callable ASM Interface
Structure symbolic constant to Initialize TZDLGEN Module. This provides the initial values to the terminal variables as well as method pointers.
Methods void (*init)(void *);
This function initializes the trapezoidal module. void (*calc)(void *); This function generates trapezoidal output with adjustable gain, frequency and DC offset.
Module Usage
Instantiation The following example instances empty signal generator object TZDLGEN sgen; Initialization
To Instance pre-initialized object TZDLGEN sgen = TZDLGEN_DEFAULTS;
Invoking the computation function sgen.calc(&sgen);
Example
The following pseudo code exemplifies, 50Hz trapezoidal signal generation, using TZDLGEN module. #include <sgen.h>
TZDLGEN sgen=TZDLGEN_DEFAULTS;
int x1; main ( ) {
sgen.prescalar=1; sgen.freq=5369; /* freq = (Required Freq/Max Freq)*2^15 */ /* = (50/305.17)*2^15 = 5369 */ sgen.step_max=4000; /* Max Freq= (step_max*Fs)/(4*65536*prescalar) */
/* Max Freq = (4000*20k)/(4*65536*1) = 305.17 */ sgen.gain=0x7fff; /* ~1 in Q15 format */ sgen.offset=0; sgen.init(&tgen); } void interrupt isr_20khz() {
sgen.calc(&sgen); x1=sgen.out;
}
Texas Instruments Inc., September 2011 66
Background Information Background Information
The trapezoidal module is implemented using modulo arithmetic counter (i.e. Any overflow is ignored and only the remainder is kept) to precisely control the frequency. The trapezoidal signal consists of four states viz., MIN, RAMP UP, MAX and RAMP DOWN. The module is initialized to “MIN” state by the initialization routine and state switching is performed during the overflow of the modulo counter. Hence, the modulo counter overflows four times to complete one cycle of trapezoidal output. As a result the frequency of the generated signal is reciprocal of the time it takes for 4 overflows of modulo counter, which in turn commensurate with the step value added to the counter. Thus by changing the step value, one can precisely control the frequency.
The step value is not directly commanded to vary the frequency, instead the modulation of frequency is performed using the normalized variable “freq” which is normalized to the maximum frequency. The maximum required frequency is predetermined based on the application requirement and it set by initializing the “step_max” input. Thus, the normalized variable “freq” allows the user to control the frequency of the signal between 0 to maximum frequency. The modular counter have software prescalar to reduce the increment rate in order to generate very low frequency trapezoidal signal. The prescalar essentially increases the time to overflow, thereby reducing the frequency. The amount of time it takes for the 16-bit modulo counter to overflow 4 times, for a given prescalar is given by
ISRISR Tstep
prescalarT
step
prescalarT ×××=×××= 65536424 16
(1)
The frequency of the generated trapezoidal signal is reciprocal of the time, hence
ISRFprescalar
stepF ×
××=
655364 (2)
Where ISR
ISR TF
1= is the ISR invocation frequency.
Min
Max
0
FFFFh
Modulo Counter
Trapezoidal Output
Ramp up Ramp down
T
Texas Instruments Inc., September 2011 67
Background Information
Thus, the actual frequency of the trapezoidal signal is determined by the incremental step value, prescalar and ISR execution rate. The signal generator modules use the normalized control variable to modulate the frequency instead of directly commanding the step value. The frequency control variable is normalized with respect to the maximum frequency. Assuming that the application requires the maximum frequency of 500Hz using 20Khz ISR loop and unity prescalar. Then the step value to generate 500Hz is determined using equation (2)
6.655320000
1655364500 =×××=step
This step value of 6553 is used to initialize the “step_max” element of the signal generator module. The normalized control variable “freq” helps to control the frequency from 0 to 500Hz by varying it between 0 to 1 (Q15 format) with the frequency resolution of 76.3mHz
The frequency resolution is = max_step
FMAX , hence the “step_max” should be high to get good
frequency resolution. It should be set to at least “100” for reasonable frequency resolution. To generate trapezoidal signal of frequency f , initialize the “freq” element of the ramp
generator module to 152×MAXf
f. Thus the required frequency is normalized with respect to
the maximum frequency as set by “step_max” and input as Q15 number to the trapezoidal generator module.
Prescalar: From equation (2), the minimum frequency is generated for unity prescalar, if the step increment is “1”.
=×
=×××
=655364
20000
1655364
1ISRMIN FF 76mHz
Hence, the minimum frequency is 76mHz or 13.1sec time period for 20Khz ISR. If the pre-scalar value is set to 2, then the minimum frequency is 38mHz or 26.2sec time period for 20K ISR.
=××
=×××
=2655364
20000
2655364
1ISRMIN FF 38mHz
Thus, the pre-scalar is essentially used to generate very low frequency signal by increasing the value.
Texas Instruments Inc., September 2011 68
Description This module generates profiling signal of adjustable gain, frequency and
DC offset. It can generate continuos or triggered single shot output. Input pre-scalar is provided to generate very low frequency.
Availability C-Callable Assembly (CcA) Module Properties Type: Target Independent, Application Dependent Target Devices: x28xx
C-Callable Assembly Files: profilec.asm, sgen.h
Item C-Callable ASM Comments
Code Size� 156 words + cinit•
Data RAM 0 words•
XDAIS ready Yes XDAIS component No IALG layer not implemented Multiple instances Yes Reentrancy Yes
Multiple Invocation
Yes
Stack usage 2 words Stack grows by 2 words
• Each pre-initialized PROFILE structure consumes 20 words in the data memory and 23 words in the cinit section ∆∆∆∆ Each instance of PROFILE module consumes 20 words in Data memory.
Profiling Signal Generator PROFILE
out
PROFILE
gain
offset
step_max
prescalar
trig
t_rmpup
t_max
mode
t_rmpdn
t_max
Texas Instruments Inc., September 2011 69
C/C-Callable ASM Interface C/C-Callable ASM Interface Object Definition
The structure of PROFILE object is defined by the following structure definition typedef struct { int mode; int trig;
unsigned int skip_cntr; unsigned int prescalar;
unsigned int freq; unsigned int step_max; int t_rmpup; int t_max; int t_rmpdn; int t_min;
unsigned int task; unsigned int alpha; int gain; int offset; int out; void (*init)(void *); void (*calc)(void *); } PROFILE;
Module Terminal Variables/Functions
Item Name Description Format Range(Hex) mode 1: Continuous Signal generation
0: Single Shot operation Binary 0 or 1
trig Trigger input for single shot operation Binary 0 or 1 prescalar Prescalar for modulo counter, used to
generate very low frequency. Q0 0-7FFF
freq Frequency in hertz between [ ]MAXF,0
normalized to [ ]1,0
Q15 0000-7FFF
step_max
prescalar
FstepF S
MAX ×××
=655364
max_.
The default value is set to 4000 to generate the maximum frequency of 305.17Hz using 20KHz sampling loop and unity prescalar.
Q0 0000-7FFF
offset DC offset in the trapezoidal signal Q15 8000-7FFF
alpha Initial phase [ ]π2,0 Q16 0-FFFF
gain Gain of the trapezoidal signal Q15 0-7FFF t_min Ratio of minimum state time with respect to
the time period ( T ) in Q8 format Q8 0000-0100
t_rmpup Ratio of ramp up state time with respect to the time period ( T ) in Q8 format
Q8 0000-0100
t_max Ratio of max state time with respect to the time period ( T ) in Q8 format
Q8 0000-0100
Input
t_rmpdn Ratio of ramp down state time with respect to the time period ( T ) in Q8 format
Q8 0000-0100
Output out Profile Output Q15 8000-7FFF
Texas Instruments Inc., September 2011 70
C/C-Callable ASM Interface Methods void (*init)(void *);
This function initializes the profile module. void (*calc)(void *); This function generates profile signal of adjustable gain, frequency and DC offset. It provides option for single shot or continuos signal generation.
Module Usage
Instantiation The following example instances empty signal generator object PROFILE sgen; Initialization
To Instance pre-initialized object PROFILE sgen = PROFILE_DEFAULTS;
Invoking the computation function sgen.calc(&sgen);
Example The following pseudo code exemplifies 50Hz profile signal generation with the following properties using PROFILE module (Assuming 20KHz sampling frequency).
1) Min State time: 10% of T. 2) Ramp up state time: 20% of T. 3) Max state time: 30% of T. 4) Ramp down state time: 40% of T.
#include <sgen.h>
PROFILE sgen=PROFILE_DEFAULTS;
int x1; main ( ) {
/* Signal Generator module initialization */ sgen.mode=1; /* Set Mode bit for Continuous signal Generation */
sgen.prescalar=1; sgen.freq=5369; /* freq = (Required Freq/Max Freq)*2^15 */ /* = (50/305.17)*2^15 = 5369 */ sgen.step_max=4000; /* Max Freq= (step_max * sampling freq)/(4*65536) */ /* Max Freq = (4000*20k)/(4*65536) = 305.17 */ sgen.gain=0x7fff; /* ~1 in Q15 format */ sgen.offset=0; sgen.t_rmpup=51; /* 20% of T, 0.2 in Q8 */ sgen.t_max=77; /* 30% of T, 0.3 in Q8 */ sgen.t_rmpdn=102; /* 40% of T, 0.4 in Q8 */ sgen.t_min=25; /* 10% of T, 0.1 in Q8 */ sgen.init(&sgen); } void interrupt isr_20khz() {
sgen.calc(&sgen); x1=sgen.out;
}
Texas Instruments Inc., September 2011 71
Background Information Background Information
The profile signal generator is implemented using modulo arithmetic counter (i.e. Any overflow is ignored and only the remainder is kept) to precisely control the frequency. The profile signal consists of four states viz., MIN, RAMP UP, MAX and RAMP DOWN. The module is initialized to “MIN” state by the initialization routine and state switching is performed during the overflow of the modulo counter. Hence, the modulo counter overflows four times to complete one cycle of profile output. As a result the frequency of the generated signal is reciprocal of the time it takes for 4 overflows of modulo counter, which in turn commensurate with the step value added to the counter. Thus by changing the step value, one can precisely control the frequency.
The step value is not directly commanded to vary the frequency, instead the modulation of frequency is performed using the normalized variable “freq” which is normalized to the maximum frequency. The maximum required frequency is predetermined based on the application requirement and it set by initializing the “step_max” input. Thus, the normalized variable “freq” allows the user to control the frequency of the signal between 0 to maximum frequency. The step value is calculated using the following equation max_stepfreqstep ×= (1)
Where, 1:0=freq in Q15 format
Adding the same step value continuously to the modulo counter provides equal time period ( 4
T or 25% of T) for each state of the profile viz., MIN, RAMP UP, MAX and RAMP DOWN
resulting in trapezoidal output as given below. Profile generator requires the traversal time for each state modifiable. This is done by providing 4 parameters describing the MIN state time, RAMP UP state time, MAX state time and RAMP DOWN state time. The time input for each state is specified as the ratio with respect to the Profile time period (T) in Q8 format.
Min
Max
0
FFFFh
Modulo Counter
Trapezoidal Output
Ramp up Ramp down
T
MIN State time
RAMP UP State time
MAX State time
RAMP DOWN State time
Texas Instruments Inc., September 2011 72
Background Information
The modular counter have software pre-scalar to reduce the increment rate in order to generate very low frequency trapezoidal signal. The pre-scalar essentially increases the time to overflow, thereby reducing the frequency. The amount of time it takes for the 16-bit modulo counter to overflow 4 times, for a given pre-scalar is given by
ISRISR Tstep
prescalarT
step
prescalarT ×××=×××= 65536424 16
(2)
The frequency of the generated trapezoidal signal is reciprocal of the time, hence
ISRFprescalar
stepF ×
××=
655364 (3)
Where ISR
ISR TF
1= is the ISR invocation frequency.
Thus, the actual frequency of the trapezoidal signal is determined by the incremental step value, pre-scalar and ISR execution rate. The signal generator modules use the normalized control variable to modulate the frequency instead of directly commanding the step value. The frequency control variable is normalized with respect to the maximum frequency. Assuming that the application requires the maximum frequency of 500Hz using 20Khz ISR loop and unity pre-scalar. Then the step value to generate 500Hz is determined using equation (3)
6.655320000
1655364500 =×××=step
This step value of 6553 is used to initialize the “step_max” element of the signal generator module. The normalized control variable “freq” helps to control the frequency from 0 to 500Hz by varying it between 0 to 1 (Q15 format) with the frequency resolution of 76.3mHz
The frequency resolution is = max_step
FMAX , hence the “step_max” should be high to get good
frequency resolution. It should be set to at least “100” for reasonable frequency resolution. To generate trapezoidal signal of frequency f , initialize the “freq” element of the trapezoidal
generator module to 152×MAXf
f. Thus the required frequency is normalized with respect to
the maximum frequency as set by “step_max” and input as Q15 number to the trapezoidal generator module.
Texas Instruments Inc., September 2011 73
Background Information Pre-scalar
From equation (2), the minimum frequency is generated for unity pre-scalar, if the step increment is “1”.
=×
=×××
=655364
20000
1655364
1ISRMIN FF 76mHz
Hence, the minimum frequency is 76mHz or 13.1sec time period for 20Khz ISR. If the pre-scalar value is set to 2, then the minimum frequency is 38mHz or 26.2sec time period for 20K ISR.
=××
=×××
=2655364
20000
2655364
1ISRMIN FF 38mHz
Thus, the pre-scalar is essentially used to generate very low frequency signal by increasing the value.
Time Specification
The state traversal time for MIN, RAMP_UP, MAX and RAMP DOWN are input to the module as ratio with respect to the profile time period in Q8 format and it is given below. The sum of the time parameter expressed as ratio with respect to the profile time period, must be unity. Otherwise the generated frequency will be different from the one set by the “freq” input.
t_min = 81 2×T
T (4)
t_rmpup= 82 2×T
T (5)
t_max = 83 2×T
T (6)
t_rmpdn= 84 2×T
T (7)
T
T3=0.3T T1=0.2T
T4=0.4T T2=0.1T
Texas Instruments Inc., September 2011 74
Background Information To generate the profile given in the last page, initialize the time parameters as given below,
1) t_min= 5122.0 8 =×T
T 2) t_rmpup= 262
1.0 8 =×T
T
3) t_max= 7723.0 8 =×T
T 4) t_rmpdn= 1022
4.0 8 =×T
T
The step value in equation (1), if added to modulo counter will provide ( 4
T or 25% of T) for each state. To get the required traversal time for each state, the step value is scaled up/down before adding to modulo counter. The step value is scaled up, if the state time parameter is less the 0.25 the scaled down if the state time parameter is greater then 0.25. Actual step value added during ramp up phase is give by the following equation
= rmpupt
step
_
25.0× (8)
Similarly for the other state of the profile output, actual step values are calculated based on time parameter and added to modulo counter. Single shot & Continuous profile generation: The profile generator operates in two modes viz., Single shot mode and Continuos mode. It is selected by using “mode” element. Setting the “mode” element will generate continuous profile output, resetting to “zero” will allow the module to work in single shot mode. In single shot mode, the profile generator generates one cycle of profile, if “trig” element is set to “1”. Trigger element is automatically reset to “zero”, after a cycle of profile output. Wave Generation: The profile generator can be used to generate ramp and triangular waveform by appropriately initializing the state time parameters Positive ramp generation: 1) t_rmpup=256 (1 in Q8) 2) t_max=0, 3) t_min=0 4) t_rmpdn=0 Negative ramp generation: 1) t_rmpup=0 2) t_max=0, 3) t_min=0 4) t_rmpdn=256 (1 in Q8) Triangular wave generation: 1) t_rmpup=128 (0.5 in Q8) 2) t_max=0, 3) t_min=0 4) t_rmpdn=128 (0.5 in Q8)
trig
out
Texas Instruments Inc., September 2011 75
4. Revision History
V1.00 – Nov 2010 � First Release
V1.01 – Sep 2011
� Minor Revision � Created two build configurations for source library project
o STD (fixed point only): C28x_SGEN_Lib_fixed.lib o STD_FPU32 (floating point support): C28x_SGEN_Lib_fpu32.lib
� Created single linker command file; linked in to all projects � Added support scripts to set up watch variables and graphs