Wiki

Analog Devices Wiki

English
English
简体中文
简体中文
日本語
日本語
Руccкий
Руccкий

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

resources:tools-software:sigmastudio:usingsigmastudio:systemimplementation [18 Jun 2012 22:31]
William Jahn created 		resources:tools-software:sigmastudio:usingsigmastudio:systemimplementation [18 Jun 2012 22:38]
William Jahn Added collapsable source code in plain text
Line 38: Line 38:
 {{codepic5.png}}\\ {{codepic5.png}}\\
 {{codepic6.png}}\\ {{codepic6.png}}\\
 +
 +~~~~ Click here to view the above source code as plain text |
 +<​code>​
 +#include "​prog_data.h"​
 +
 +#include "​param_data.h"​
 +
 +#include "​Design_IC 1.h" // *** This file is generated by SigmaStudio ***
 +
 +#include "​Design_IC 1_REG.h"​ // *** This file is generated by SigmaStudio ***
 +
 +#include "​comms.h"​
 +
 +#define byte unsigned char 
 +
 + 
 +
 +// Microcontroller Code MAIN program
 +
 +int main(void) ​
 +
 +{ 
 +
 +// Setup SPI port  this is hardware-specific
 +
 +SpiInit(); ​
 +
 +Mute();
 +
 + 
 +
 +// Write a program to DSP
 +
 +SpiWrite(PROG_START_ADR,​ PROGRAM_DATA,​ PROG_LENGTH*6); ​
 +
 + 
 +
 +// Wait some time
 +
 +Wait(...);
 +
 + 
 +
 +// Write a parameter file
 +
 +SpiWrite(PARAM_START_ADR,​ PARAM_DATA, PARAM_LENGTH*4); ​
 +
 +Wait(...);
 +
 +UnMute();
 +
 + 
 +
 +// Write a single value (0.242) to specified address
 +
 +// The address, MODULE_Main_Single1_VALUE,​ is defined in the
 +
 +// SigmaStudio generated header file (Design_IC 1.h).
 +
 +ParamWrite(MODULE_Main_Single1_VALUE,​ 0.242);
 +
 + 
 +
 +// Example safeload of single parameter, will safeload 1.999 in 5.23 
 +
 +// format to address 2 
 +
 +// This function includes the initiate safeload to parameter RAM
 +
 +SafeloadSingleParamWrite(2,​ 1.999);
 +
 + 
 +
 +// Example of a multiple parameter safeload (i.e. filter coefficients)
 +
 +//  - loads the data to each of the five safeload locations,
 +
 +//  -  then initiates the safeload
 +
 +SafeloadMultipleParamWrite(MODULE_Main_MidEQ1_Alg0_Stage0_B0_ADDRESS,​ 1.999, 0); 
 +
 +SafeloadMultipleParamWrite(MODULE_Main_MidEQ1_Alg0_Stage0_B1_ADDRESS,​ -.988, 1); 
 +
 +SafeloadMultipleParamWrite(MODULE_Main_MidEQ1_Alg0_Stage0_B2_ADDRESS,​ 1.999, 2);
 +
 +SafeloadMultipleParamWrite(MODULE_Main_MidEQ1_Alg0_Stage0_A1_ADDRESS,​ -.999888, 3);
 +
 +SafeloadMultipleParamWrite(MODULE_Main_MidEQ1_Alg0_Stage0_A2_ADDRESS,​ 1.999, 4);
 +
 +InitSafeloadParam();​
 +
 + 
 +
 +return 0;
 +
 +}
 +
 + 
 +
 +// Microcontroller Code Wait function
 +
 +void Wait(float time) //time to wait in milliseconds
 +
 +{
 +
 +long cycles;
 +
 +cycles = time / 1.422e-3; //assuming 45 MHz uC core clock speed
 +
 +while (cycles != 0)
 +
 +{
 +
 +  --cycles; ​
 +
 +}
 +
 +}
 +
 + 
 +
 +// Microcontroller Code Mute function
 +
 +void Mute()
 +
 +{
 +
 +byte corecontrol[2] = {0x00, 0x00}; ​
 +
 +//Write core control register
 +
 +SpiWrite(CORE_CONTROL_REG,​ corecontrol,​ 2);
 +
 +//Wait 20us 
 +
 +Wait(20);
 +
 +}
 +
 + 
 +
 +// Microcontroller Code UnMute function
 +
 +void UnMute()
 +
 +{
 +
 +byte corecontrol[2] = {0x02, 0x00}; ​
 +
 +//Write core control register
 +
 +SpiWrite(CORE_CONTROL_REG,​ corecontrol,​ 2);
 +
 +//Wait 20us
 +
 +Wait(20);  ​
 +
 +}
 +
 + 
 +
 +// Microcontroller SpiWrite function
 +
 +// The function takes the start address to be written to, an array of 
 +
 +// data, and the length of the array (in bytes). ​
 +
 +void SpiWrite(short address, unsigned char* data, int length)
 +
 +{ 
 +
 +int i = 0;
 +
 +byte address_hi = 0; // register/​RAM address high byte
 +
 +byte address_lo = 0; // register/​RAM address lo byte
 +
 +address_lo = (byte)address;​ // get low byte of register/​RAM address
 +
 +address_hi = (byte)(address>>​8);​ // get high byte of address shift left by 8 bits
 +
 + 
 +
 +// Fill in your write function here
 +
 +SPI_TX_REG = 0x00; // Write to DSP at chip address 0
 +
 +SPI_TX_REG = address_hi; // Write high address byte
 +
 +SPI_TX_REG = address_lo; // Write lo address byte
 +
 +for (i=0; i<​length;​ i++) // Write specified length of data
 +
 +{
 +
 +   ​SPI_TX_REG = data[i]; ​
 +
 +}
 +
 + 
 +
 +// Note: After each write to SPI_TX_REG, you may need to verify that the buffer
 +
 +// has been emptied (meaning the write has completed). This is hardware-specific.
 +
 +}
 +
 + 
 +
 +// Microcontroller Code - functions, write a single parameter
 +
 +void ParamWrite(short address, float param)
 +
 +{
 +
 +byte param_hex[4] = {0x00, 0x00, 0x00, 0x00} ;
 +
 +// Convert decimal parameter value to 5.23 format
 +
 +To523(param,​ param_hex); ​
 +
 +SpiWrite(address,​ param_hex, 4); 
 +
 +}
 +
 + 
 +
 +// Microcontroller Code functions, safeload: single parameter write
 +
 +void SafeloadSingleParamWrite(short address, float param)
 +
 +{
 +
 +byte param_hex[4] = {0x00, 0x00, 0x00, 0x00};
 +
 + 
 +
 +//convert decimal paramater value to 5.23 format
 +
 +To523(param,​ param_hex); ​
 +
 +byte paramex_hex[5];​
 +
 +paramex_hex[0]=0x00;​
 +
 +paramex_hex[1]=param_hex[0];​
 +
 +paramex_hex[2]=param_hex[1];​
 +
 +paramex_hex[3]=param_hex[2];​
 +
 +paramex_hex[4]=param_hex[3];​
 +
 + 
 +
 +SafeParam(SAFELOAD_DATA_0,​ paramex_hex);​
 +
 +SafeAddr(SAFELOAD_ADDRESS_0,​ address);
 +
 +InitSafeloadParam();​
 +
 +}
 +
 + 
 +
 +// Microcontroller Code functions, safeload: multiple parameter write
 +
 +// Note: After you call this function, call InitSafeloadParam once.
 +
 +void SafeloadMultipleParamWrite(short address, float param, int location)
 +
 +{
 +
 +byte param_hex[4] = {0x00, 0x00, 0x00, 0x00};
 +
 + 
 +
 +//convert decimal paramater value to 5.23 format
 +
 +To523(param,​ param_hex); ​
 +
 +byte paramex_hex[5];​
 +
 +paramex_hex[0]=0x00;​
 +
 +paramex_hex[1]=param_hex[0];​
 +
 +paramex_hex[2]=param_hex[1];​
 +
 +paramex_hex[3]=param_hex[2];​
 +
 +paramex_hex[4]=param_hex[3];​
 +
 + 
 +
 +SafeParam(SAFELOAD_DATA_0+location,​ paramex_hex);​
 +
 +SafeAddr(SAFELOAD_ADDRESS_0+location,​ address);
 +
 +}
 +
 + 
 +
 +// Microcontroller Code - functions, safeload: Initiate the safeload ​
 +
 +// write to parameter RAM
 +
 +void InitSafeloadParam()
 +
 +{
 +
 +byte corecontrol[2] = {2, 0}; 
 +
 + 
 +
 +//Read contents of core control register
 +
 +SpiRead(CORE_CONTROL_REG,​ corecontrol,​ 2); 
 +
 + 
 +
 +//Set Initiate Safe Transfer to Param RAM bit
 +
 +corecontrol[1] = corecontrol[1] | 0x10;    ​
 +
 + 
 +
 +//Write back to core control register
 +
 +SpiWrite(CORE_CONTROL_REG,​ corecontrol,​ 2);
 +
 +Wait(20); ​ //Wait 20us 
 +
 +}
 +
 + 
 +
 +//​Microcontroller Code - functions, SpiRead
 +
 +void SpiRead(short address, unsigned char* data, int length)
 +
 +{
 +
 +int i = 0;
 +
 +byte address_hi = 0; //DSP register/​RAM address high byte
 +
 +byte address_lo = 0; //DSP register/​RAM address lo byte
 +
 + 
 +
 +//get low byte of register/​RAM address
 +
 +address_lo = (byte)address; ​    
 +
 +//get high byte of address shift, left by 8 bits
 +
 +address_hi = (byte)(address>>​8);​
 +
 + 
 +
 +//Fill in you write function here
 +
 +SPI_RX_REG = 0x01;        //Write to DSP and set RW bit to 1
 +
 +SPI_RX_REG = address_hi; ​ //Write high address byte
 +
 +SPI_RX_REG = address_lo; ​ //Write lo address byte
 +
 + 
 +
 +for (i=0; i<​length;​ i++) //read specified length of data
 +
 +{
 +
 +  SPI_RX_REG = data[i]; ​
 +
 +}
 +
 + 
 +
 +// Note: After each write to SPI_TX_REG, you may need to verify that the buffer has
 +
 +// been emptied (meaning the write has completed). This is hardware-specific.
 +
 +}
 +
 + 
 +
 +//​Microcontroller Code - functions, Safeload: SafeAddr
 +
 +void SafeAddr(short safe_addr, short param_addr)
 +
 +{
 +
 +byte safe_addr_lo;​
 +
 +byte safe_addr_hi;​
 +
 + 
 +
 +//get low byte of register/​RAM address
 +
 +safe_addr_lo=(byte)safe_addr;  ​
 +
 +//get high byte of address shift left by 8 bits
 +
 +safe_addr_hi=(byte)(safe_addr>>​8); ​
 +
 + 
 +
 +byte param_addr_lo;​
 +
 +byte param_addr_hi;​
 +
 + 
 +
 +//get low byte of parameter address
 +
 +param_addr_lo=(byte)param_addr;  ​
 +
 +//get high byte of address shift left by 8 bits
 +
 +param_addr_hi=(byte)(param_addr>>​8); ​
 +
 + 
 +
 +SPI_TX_REG = 0x00; // Write to DSP at chip address 0
 +
 +SPI_TX_REG = safe_addr_hi;​ //Write high byte of safeload address
 +
 +SPI_TX_REG = safe_addr_lo;​ //Write low byte of safeload address
 +
 + 
 +
 +SPI_TX_REG = param_addr_hi;​ //Write high byte of parameter address
 +
 +SPI_TX_REG = param_addr_lo;​ //Write low byte of parameter address
 +
 +}
 +
 + 
 +
 +//​Microcontroller Code - functions, Safeload: SafeParam
 +
 +void SafeParam(short safe_param, unsigned char* param_data)
 +
 +{
 +
 +byte safe_param_lo;​
 +
 +byte safe_param_hi;​
 +
 + 
 +
 +//get low byte of register/​RAM address
 +
 +safe_param_lo=(byte)safe_param;​
 +
 +//get high byte of address shift left by 8 bits
 +
 +safe_param_hi=(byte)(safe_param>>​8); ​
 +
 + 
 +
 +SPI_TX_REG = 0x00; //Write to DSP at chip address 0
 +
 +SPI_TX_REG = safe_param_hi;​ //Write high byte of Safeload address
 +
 +SPI_TX_REG = safe_param_lo;​ //Write low byte of Safeload address
 +
 + 
 +
 +SPI_TX_REG = param_data[4];​ //Write parameter byte 4 (MSBs)
 +
 +SPI_TX_REG = param_data[3];​ //Write parameter byte 3
 +
 +SPI_TX_REG = param_data[2];​ //Write parameter byte 2
 +
 +SPI_TX_REG = param_data[1];​ //Write parameter byte 1
 +
 +SPI_TX_REG = param_data[0];​ //Write parameter byte 1 (LSBs)
 +
 +}
 +
 + 
 +
 +// Note: SafeParam and SafeAddr must be executed together.
 +
 + 
 +
 +// Microcontroller code - functions: convert a float number to 5.23 format
 +
 +void To523(float param_dec, byte* param_hex)
 +
 +{
 +
 +long param223;
 +
 +long param227;
 +
 + 
 +
 +//multiply decimal number by 2^23
 +
 +param223 = param_dec * (1 << 23);
 +
 +//convert to positive binary ​
 +
 +param227 = param223 + (1 << 27); 
 +
 + 
 +
 +param_hex[3]=(byte)param227; ​ //get byte 3 (LSBs) of parameter value
 +
 +param_hex[2]=(byte)(param227>>​8);​ //get byte 2 of parameter value
 +
 +param_hex[1]=(byte)(param227>>​16);​ //get byte 1 of parameter value
 +
 +//get byte 0 (MSBs) of parameter value
 +
 +param_hex[0]=(byte)(param227>>​24); ​
 +
 +//invert sign bit to get correct sign
 +
 +param_hex[0] = param_hex[0] ^ 0x08; 
 +
 +}
 +</​code>​
 +~~~~
resources/tools-software/sigmastudio/usingsigmastudio/systemimplementation.txt · Last modified: 18 Jun 2012 22:38 by William Jahn

Page Tools