Array Errors

emailcausey · July 11, 2014

The code below is working well. I have added an array to it (see purple bold text) and get expected values (arraypres[0]=100....array[9]=109). However, when I change it to

uint16_t arraypres[20];

and

if(number <20){

arraypres[number]=100+number;

number = number+1;

}

I have unexpected results (see attachment). I am perplexed as to why this is happening. Any suggestions greatly appreciated.

Code:

#include "DSP28x_Project.h" // Device Header file and Examples Include File

#include "f2802x_common/include/adc.h"

#include "f2802x_common/include/clk.h"

#include "f2802x_common/include/flash.h"

#include "f2802x_common/include/gpio.h"

#include "f2802x_common/include/pie.h"

#include "f2802x_common/include/pll.h"

#include "f2802x_common/include/pwm.h"

#include "f2802x_common/include/wdog.h"

#include "f2802x_common/include/spi.h"

#include "f2802x_common/include/timer.h"

// nokia5110 libraries

#include "font8x8.h"

#include "nokia5110.h"

#include "stdio.h"

// Prototype statements for functions found within this file.

interrupt void adc_isr(void);

void Adc_Config(void);

interrupt void cpu_timer0_isr(void);

interrupt void spiRxFifoIsr(void);

void gpio_init(void);

void spi_init(void);

// Global variables used in this example:

uint16_t interruptCount=0, val=0, arraymot[5], check=0;

uint16_t j=0,i=0, a=0,AVG_VOLT=0,mV=0,ConversionCount = 0, LoopCount = 0,interval=900, y=0; //default interval is 15 min

int16 level1=0, level2=0, level3=0, slope=16;//0.16 is the avg slope for LMV324 (should be 0.15 for INA333 slope)

uint16_t baseline;

uint16_t arraypres[10];

int16 number=0;

long Voltage1[10];

long Voltage2[10];

long Voltage3[10];

long Voltage5[10];

long Voltage6[10];

long Voltage7[10];

long Voltage8[10];

long Voltage9[10];

long Voltage10[10];

long Mean_Volt3=0;

long Mean_Volt7=0;

long Mean_Volt10=0;

long Peqn=0;

long Peqn1=0;

long Peqn2=0;

long Sum_Volt3=0;

long Sum_Volt7=0;

long Sum_Volt10=0;

ADC_Handle myAdc;

CLK_Handle myClk;

FLASH_Handle myFlash;

GPIO_Handle myGpio;

PIE_Handle myPie;

SPI_Handle mySpi;

CPU_Handle myCpu;

PLL_Handle myPll;

PWM_Handle myPwm1;

WDOG_Handle myWDog;

TIMER_Handle myTimer;

char value0[10];

char value1[10];

char value2[10];

void main(void)

{

// Initialize all the handles needed for this application

myAdc = ADC_init((void *)ADC_BASE_ADDR, sizeof(ADC_Obj));

myClk = CLK_init((void *)CLK_BASE_ADDR, sizeof(CLK_Obj));

myCpu = CPU_init((void *)NULL, sizeof(CPU_Obj));

myFlash = FLASH_init((void *)FLASH_BASE_ADDR, sizeof(FLASH_Obj));

myGpio = GPIO_init((void *)GPIO_BASE_ADDR, sizeof(GPIO_Obj));

myPie = PIE_init((void *)PIE_BASE_ADDR, sizeof(PIE_Obj));

myPll = PLL_init((void *)PLL_BASE_ADDR, sizeof(PLL_Obj));

myPwm1 = PWM_init((void *)PWM_ePWM1_BASE_ADDR, sizeof(PWM_Obj));

myWDog = WDOG_init((void *)WDOG_BASE_ADDR, sizeof(WDOG_Obj));

myTimer = TIMER_init((void *)TIMER0_BASE_ADDR, sizeof(TIMER_Obj));

mySpi = SPI_init((void *)SPIA_BASE_ADDR, sizeof(SPI_Obj));

// Perform basic system initialization

WDOG_disable(myWDog);

CLK_enableAdcClock(myClk);

(*Device_cal)();

//Select the internal oscillator 1 as the clock source

CLK_setOscSrc(myClk, CLK_OscSrc_Internal);

// Setup the PLL for x12 /2 which will yield 60Mhz = 10Mhz * 12 / 2

PLL_setup(myPll, PLL_Multiplier_12, PLL_DivideSelect_ClkIn_by_2);

PIE_disable(myPie);

PIE_disableAllInts(myPie);

CPU_disableGlobalInts(myCpu);

CPU_clearIntFlags(myCpu);

// If running from flash copy RAM only functions to RAM

#ifdef _FLASH

memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize);

#endif

// Setup a debug vector table and enable the PIE

PIE_setDebugIntVectorTable(myPie);

PIE_enable(myPie);

// Register interrupt handlers in the PIE vector table

PIE_registerPieIntHandler(myPie, PIE_GroupNumber_10, PIE_SubGroupNumber_1, (intVec_t)&adc_isr);

PIE_registerPieIntHandler(myPie, PIE_GroupNumber_1, PIE_SubGroupNumber_7, (intVec_t)&cpu_timer0_isr);

// Configure CPU-Timer 0 to interrupt every second:

// 60MHz CPU Freq, 1 second Period (in uSeconds)

//ConfigCpuTimer(&CpuTimer0, 60, 1000000);

TIMER_stop(myTimer);

TIMER_setPeriod(myTimer, 60*1000000);

TIMER_setPreScaler(myTimer, 0);

TIMER_reload(myTimer);

TIMER_setEmulationMode(myTimer, TIMER_EmulationMode_StopAfterNextDecrement);

TIMER_enableInt(myTimer);

TIMER_start(myTimer);

// Initialize the ADC

ADC_enableBandGap(myAdc);

ADC_enableRefBuffers(myAdc);

ADC_powerUp(myAdc);

ADC_enable(myAdc);

ADC_setVoltRefSrc(myAdc, ADC_VoltageRefSrc_Int);

// Enable ADCINT1 in PIE

PIE_enableAdcInt(myPie, ADC_IntNumber_1);

// Enable CPU Interrupt 1

CPU_enableInt(myCpu, CPU_IntNumber_10);

// Enable CPU INT1 which is connected to CPU-Timer 0:

CPU_enableInt(myCpu, CPU_IntNumber_1);

// Enable Global interrupt INTM

// Enable TINT0 in the PIE: Group 1 interrupt 7

PIE_enableTimer0Int(myPie);

CPU_enableGlobalInts(myCpu);

// Enable Global realtime interrupt DBGM

CPU_enableDebugInt(myCpu);

// Configure ADC

//Note: Channel ADCINA4 will be double sampled to workaround the ADC 1st sample issue for rev0 silicon errata

ADC_setIntPulseGenMode(myAdc, ADC_IntPulseGenMode_Prior); //ADCINT1 trips after AdcResults latch

ADC_enableInt(myAdc, ADC_IntNumber_1); //Enabled ADCINT1

ADC_setIntMode(myAdc, ADC_IntNumber_1, ADC_IntMode_ClearFlag); //Disable ADCINT1 Continuous mode

ADC_setIntSrc(myAdc, ADC_IntNumber_1, ADC_IntSrc_EOC2); //setup EOC2 to trigger ADCINT1 to fire

ADC_setSocChanNumber (myAdc, ADC_SocNumber_0, ADC_SocChanNumber_A4); //set SOC0 channel select to ADCINA4 - Interval

ADC_setSocChanNumber (myAdc, ADC_SocNumber_1, ADC_SocChanNumber_A4); //set SOC1 channel select to ADCINA4 - Interval

ADC_setSocChanNumber (myAdc, ADC_SocNumber_2, ADC_SocChanNumber_A7); //set SOC2 channel select to ADCINA7 - Pressure

ADC_setSocChanNumber (myAdc, ADC_SocNumber_3, ADC_SocChanNumber_A3); //Motor

ADC_setSocTrigSrc(myAdc, ADC_SocNumber_0, ADC_SocTrigSrc_EPWM1_ADCSOCA); //set SOC0 start trigger on EPWM1A, due to round-robin SOC0 converts first then SOC1

ADC_setSocTrigSrc(myAdc, ADC_SocNumber_1, ADC_SocTrigSrc_EPWM1_ADCSOCA); //set SOC1 start trigger on EPWM1A, due to round-robin SOC0 converts first then SOC1

ADC_setSocTrigSrc(myAdc, ADC_SocNumber_2, ADC_SocTrigSrc_EPWM1_ADCSOCA); //set SOC2 start trigger on EPWM1A, due to round-robin SOC0 converts first then SOC1, then SOC2

ADC_setSocTrigSrc(myAdc, ADC_SocNumber_3, ADC_SocTrigSrc_EPWM1_ADCSOCA);

ADC_setSocSampleWindow(myAdc, ADC_SocNumber_0, ADC_SocSampleWindow_64_cycles); //set SOC0 S/H Window to 64 ADC Clock Cycles, (6 ACQPS plus 1)

ADC_setSocSampleWindow(myAdc, ADC_SocNumber_1, ADC_SocSampleWindow_64_cycles); //set SOC1 S/H Window to 64 ADC Clock Cycles, (6 ACQPS plus 1)

ADC_setSocSampleWindow(myAdc, ADC_SocNumber_2, ADC_SocSampleWindow_64_cycles); //set SOC2 S/H Window to 64 ADC Clock Cycles, (6 ACQPS plus 1)

ADC_setSocSampleWindow(myAdc, ADC_SocNumber_3, ADC_SocSampleWindow_64_cycles);

// Enable PWM clock

CLK_enablePwmClock(myClk, PWM_Number_1);

// Setup PWM

PWM_enableSocAPulse(myPwm1); // Enable SOC on A group

PWM_setSocAPulseSrc(myPwm1, PWM_SocPulseSrc_CounterEqualCmpAIncr); // Select SOC from from CPMA on upcount

PWM_setSocAPeriod(myPwm1, PWM_SocPeriod_FirstEvent); // Generate pulse on 1st event

PWM_setCmpA(myPwm1, 0x0080); // Set compare A value

PWM_setPeriod(myPwm1, 0xFFFF); // Set period for ePWM1

PWM_setCounterMode(myPwm1, PWM_CounterMode_Up); // count up and start

CLK_enableTbClockSync(myClk);

gpio_init();

spi_init();

nokiaInit();

clear();

myGpio = GPIO_init((void *)GPIO_BASE_ADDR, sizeof(GPIO_Obj));

GPIO_setMode(myGpio, timeandreset, GPIO_19_Mode_GeneralPurpose);

GPIO_setDirection(myGpio, timeandreset, GPIO_Direction_Output);

GPIO_setHigh(myGpio, timeandreset); //Default is that the Omron is off

GPIO_setMode(myGpio, LED1, GPIO_28_Mode_GeneralPurpose);

GPIO_setDirection(myGpio, LED1, GPIO_Direction_Output);

GPIO_setMode(myGpio, LED2, GPIO_29_Mode_GeneralPurpose);

GPIO_setDirection(myGpio, LED2, GPIO_Direction_Output);

GPIO_setMode(myGpio, LED3, GPIO_34_Mode_GeneralPurpose);

GPIO_setDirection(myGpio, GPIO_Number_34, GPIO_Direction_Output);

GPIO_setMode(myGpio, buzzer, GPIO_0_Mode_GeneralPurpose);

GPIO_setDirection(myGpio, GPIO_Number_0, GPIO_Direction_Output);

GPIO_setLow(myGpio, LED1);

GPIO_setLow(myGpio, LED2);

GPIO_setLow(myGpio, LED3);

GPIO_setLow(myGpio, buzzer);

int SBP;

SBP = 120;

int DBP;

DBP = 110;

while(1)

{

//arraypres[val] = 1;

asm(" NOP");

val = interruptCount;

//baseline pressure taken during first 5 seconds

if (val==5){ //0 V pulse sent for 3 seconds

GPIO_setLow(myGpio, timeandreset);

}

else if(val==8){ //Device pumps up for 40 seconds

GPIO_setHigh(myGpio, timeandreset);

}

else if(val==48){ //At this point a 0 V pulse sent for 3 seconds to turn the Omron off

GPIO_setLow(myGpio, timeandreset);

}

else if(val==51){ //Omron rests until interval is reached - LED remains turned on until interval is reached

GPIO_setHigh(myGpio, timeandreset);

if(SBP >= 160 || DBP >= 110)

{

GPIO_setHigh(myGpio, LED1);

}

if(SBP >= 140 && SBP < 160 || DBP >= 90 && DBP < 110)

{

GPIO_setHigh(myGpio, LED2);

}

if(SBP < 140 && DBP < 90)

{

GPIO_setHigh(myGpio, LED3);

}

//buzzer sounds if higher level is reached

if(val>51 && val<53 && (SBP >= 160 || DBP >= 110))

{

level1=1;

if(level1+level2+level3>2)

{

GPIO_setHigh(myGpio, buzzer);

level2=0;

level3=0;

}

if(val>51 && SBP < 160 && DBP < 110 && (SBP >= 140 || DBP >= 90))

{

level1=0;

level2=1;

if(level2+level3>2)

{

GPIO_setHigh(myGpio, buzzer);

level3=0;

}

if(val>51 && SBP < 140 && DBP < 90)

{

level1=0;

level2=0;

level3=1;

}

//buzzer turns off after 10s

if(val>53){

GPIO_setLow(myGpio,buzzer);

}

if(val==interval){

interruptCount = 0;

GPIO_setLow(myGpio, LED1);

GPIO_setLow(myGpio, LED2);

GPIO_setLow(myGpio, LED3);

}

/* functions */

void gpio_init(void){

// set up GPIO's for nokia

//GPIO_setMode(myGpio, nokiaVcc, GPIO_0_Mode_GeneralPurpose);

GPIO_setMode(myGpio, nokiaRst, GPIO_0_Mode_GeneralPurpose);

GPIO_setMode(myGpio, nokiaDc, GPIO_0_Mode_GeneralPurpose);

GPIO_setMode(myGpio, nokiaBlight, GPIO_0_Mode_GeneralPurpose);

GPIO_setMode(myGpio, nokiaSce, GPIO_0_Mode_GeneralPurpose);

//GPIO_setDirection(myGpio, nokiaVcc, GPIO_Direction_Output);

GPIO_setDirection(myGpio, nokiaRst, GPIO_Direction_Output);

GPIO_setDirection(myGpio, nokiaDc, GPIO_Direction_Output);

GPIO_setDirection(myGpio, nokiaBlight, GPIO_Direction_Output);

GPIO_setDirection(myGpio, nokiaSce, GPIO_Direction_Output);

//GPIO_setPullUp(myGpio, nokiaVcc, GPIO_PullUp_Disable);

GPIO_setPullUp(myGpio, nokiaRst, GPIO_PullUp_Disable);

GPIO_setPullUp(myGpio, nokiaDc, GPIO_PullUp_Disable);

GPIO_setPullUp(myGpio, nokiaBlight, GPIO_PullUp_Disable);

GPIO_setPullUp(myGpio, nokiaSce, GPIO_PullUp_Disable);

return;

}

void spi_init(void){

// enable Spia clock

CLK_enableSpiaClock(myClk);

//set up GPIO's for SPI

GPIO_setPullUp(myGpio, nokiaMosi, GPIO_PullUp_Disable);

GPIO_setPullUp(myGpio, nokiaClk, GPIO_PullUp_Disable);

GPIO_setQualification(myGpio, nokiaMosi, GPIO_Qual_ASync);

GPIO_setQualification(myGpio, nokiaClk, GPIO_Qual_ASync);

GPIO_setMode(myGpio, nokiaMosi, GPIO_16_Mode_SPISIMOA);

GPIO_setMode(myGpio, nokiaClk, GPIO_18_Mode_SPICLKA);

// Resets the serial peripheral interface (SPI)

SPI_reset(mySpi);

// Initializes the serial peripheral interface (SPI) object handle

SPI_enable(mySpi);

// Enables the serial peripheral interface (SPI) transmit and receive channels

SPI_enableChannels(mySpi);

// Enable master mode

SPI_setMode(mySpi, SPI_Mode_Master);

// Enables the serial peripheral interface (SPI) masater/slave transmit mode

SPI_enableTx(mySpi);

// Sets the serial peripheral interface (SPI) character length

SPI_setCharLength(mySpi, SPI_CharLength_8_Bits);

// Sets the serial peripheral interface (SPI) clock phase

SPI_setClkPhase(mySpi, SPI_ClkPhase_Normal);

// Sets the serial peripheral interface (SPI) clock polarity

SPI_setClkPolarity(mySpi, SPI_ClkPolarity_OutputFallingEdge_InputRisingEdge);

// Enables the serial peripheral interface (SPI) interrupt

SPI_enableInt(mySpi);

// Sets the serial peripheral interface (SPI) baud rate

SPI_setBaudRate(mySpi, (SPI_BaudRate_e)0x00);

// enable the SPI

SPI_enable(mySpi);

// Set so breakpoints don't disturb xmission

SPI_setPriority(mySpi, SPI_Priority_FreeRun);

PIE_registerPieIntHandler(myPie, PIE_GroupNumber_6, PIE_SubGroupNumber_1, (intVec_t)&spiRxFifoIsr);

PIE_enableInt(myPie, PIE_GroupNumber_6, PIE_InterruptSource_SPIARX);

CPU_enableInt(myCpu, CPU_IntNumber_6);

return;

}

interrupt void spiRxFifoIsr(void)

{

GPIO_setHigh(myGpio, nokiaSce); //set Sce high

SPI_read(mySpi);

// Issue PIE ack

PIE_clearInt(myPie, PIE_GroupNumber_6);

return;

}

interrupt void cpu_timer0_isr(void)

{

interruptCount = interruptCount++;

// Acknowledge this interrupt to receive more interrupts from group 1

PIE_clearInt(myPie, PIE_GroupNumber_1);

}

interrupt void adc_isr(void)

{

Voltage1[ConversionCount] = ADC_readResult(myAdc, ADC_ResultNumber_1); //interval

Voltage2[ConversionCount] = Voltage1[ConversionCount]*3300;

Voltage3[ConversionCount] = Voltage2[ConversionCount]/4096;

Voltage5[ConversionCount] = ADC_readResult(myAdc, ADC_ResultNumber_2); //pressure

Voltage6[ConversionCount] = Voltage5[ConversionCount]*3300;

Voltage7[ConversionCount] = Voltage6[ConversionCount]/4096;

Voltage8[ConversionCount] = ADC_readResult(myAdc, ADC_ResultNumber_3); //motor

Voltage9[ConversionCount] = Voltage8[ConversionCount]*3300;

Voltage10[ConversionCount] = Voltage9[ConversionCount]/4096;

Sum_Volt3=Voltage3[ConversionCount]+Sum_Volt3; //interval

Sum_Volt7=Voltage7[ConversionCount]+Sum_Volt7; //pressure

Sum_Volt10=Voltage10[ConversionCount]+Sum_Volt10; //motor

//Clears screen periodically

if(LoopCount == 99)

{

LoopCount = 0;

clear();

}

else LoopCount++;

// If 30 conversions have been logged, start over

if(ConversionCount == 29)

{

ConversionCount = 0;

Mean_Volt3=Sum_Volt3/30; //Mean of interval

Mean_Volt7=Sum_Volt7/30; //Mean of pressure

Mean_Volt10=Sum_Volt10/30; //Mean of motor

Sum_Volt3=0;

Sum_Volt7=0;

Sum_Volt10=0;

if (val<5){ //baseline measured

baseline=Mean_Volt7;

}

Peqn = (slope*Mean_Volt7-slope*baseline)/100;

}

else ConversionCount++;

if(number <10){

arraypres[number]=100+number;

number = number+1;

}

writeString(1,0,"Pressure:");

writeString(35,1,"mmHg");

writeString(1,2,"Voltage:");

writeString(35,3,"mV");

writeString(1,4,"Interval:");

int t=Mean_Volt7; //voltage from pressure

sprintf(value0,"%d",t);

writeString(1,3,value0);

int y_2=Peqn; //pressure

sprintf(value2,"%d",y_2);

writeString(1,1,value2);

if(Mean_Volt3<100){

writeString(1,5,"15 min");

interval=15*60;

}

else if(Mean_Volt3>=100 && Mean_Volt3<500){

writeString(1,5,"30 min");

interval=30*60;

}

else if(Mean_Volt3>=500 && Mean_Volt3<900){

writeString(1,5,"1 hr ");

interval=60*60;

}

else if(Mean_Volt3>=900 && Mean_Volt3<1300){

writeString(1,5,"2 hrs ");

interval=120*60;

}

else if(Mean_Volt3>=1300){

writeString(1,5,"3 hrs ");

interval=240*60;

}

// Clear ADCINT1 flag reinitialize for next SOC

ADC_clearIntFlag(myAdc, ADC_IntNumber_1);

// Acknowledge interrupt to PIE

PIE_clearInt(myPie, PIE_GroupNumber_10);

i++;

return;

}

emailcausey · July 11, 2014

What is odd is if I make the array very large (100) then the first 15 values are inaccurate and the rest are accurate. Any ideas?

TI_Trey · July 15, 2014

My guess is that the problem is related to signed/unsigned integers. The variable number is signed while you're array is not. I would try viewing the results as hex and see if you can see a pattern...

You might also want to try stepping through and looking at the variables in the arithmetic (as hex values)...I think you'll see the problem.

Sign In

Array Errors

Recommended Posts

emailcausey 0

Link to post

Share on other sites

emailcausey 0

Link to post

Share on other sites

TI_Trey 38

Link to post

Share on other sites

Join the conversation

Browse

Activity