I am using the stellaris launchpad. and i want to store the data in the memory card.for the first five second i am store the data in to buffer after that i disable the timer and when i called the mysdcard(unsigned int mydatac)
than it's consider the mydatac as register R0,what is the reason behind this??
i send you my whole code.
#include <string.h>
#include "inc/hw_ints.h"
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "driverlib/fpu.h"
#include "driverlib/gpio.h"
#include "driverlib/interrupt.h"
#include "driverlib/rom.h"
#include "driverlib/sysctl.h"
#include "driverlib/systick.h"
#include "grlib/grlib.h"
#include "utils/cmdline.h"
#include "utils/uartstdio.h"
#include "fatfs/src/ff.h"
#include "fatfs/src/diskio.h"
#include "drivers/cfal96x64x16.h"
#include "driverlib/timer.h"
#include "driverlib/debug.h"
#include "driverlib/adc.h"
#define PATH_BUF_SIZE 80
#define CMD_BUF_SIZE 64
static FATFS FatFs;
static FIL Fil;
FRESULT fr;
DWORD size;
unsigned int bw,count,br,i;
unsigned char Second,Hour,Min,Date,Month,Year; //received data from the rtc module
char second[],hour[],min[],date[],month[],year[]; //variable which are use forr the converting to string
int len,count2;
int count1=0;
char result[];
unsigned int counter=0;
unsigned int indata16, k,indata; //16 bit variables
unsigned int Hum, Temp; //8 bit variables
unsigned char Hum1[],Temp1[]; //8 bit variables
unsigned int bufferHum[], bufferTemp[];
unsigned int mydatac1;
unsigned int datacount;
#define CLK GPIO_PIN_1
#define RDY GPIO_PIN_2
#define DAT GPIO_PIN_3
unsigned long ulADC0Value[4];
unsigned long ulADC0Value1[4];
volatile unsigned long ulTempAvg;
int ulTempValueC;
int ulTempValueF;
int bufferulTempValueC[];
int bufferulTempValueF[];
volatile unsigned long ulTempAvg1;
char ulTempValueC1[];
char ulTempValueF1[];
void
SysTickHandler(void)
{
//
// Call the FatFs tick timer.
//
disk_timerproc();
}
//
// The error routine that is called if the driver library encounters an error.
//*****************************************************************************
#ifdef DEBUG
void
__error__(char *pcFilename, unsigned long ulLine)
{
}
#endif
// The program main function. It performs initialization, then runs a command
// processing loop to read commands from the console.
char *strrev(char *str){
char c, *front, *back;
for(front=str,back=str+strlen(str)-1;front < back;front++,back--){
c=*front;*front=*back;*back=c;
}
return str;
}
char *itoa(int v, char *buff, int radix_base){
static char table[] = "0123456789abcdefghijklmnopqrstuvwxyz";
char *p=buff;
unsigned int n = (v < 0 && radix_base == 10)? -v : (unsigned int) v;
while(n>=radix_base){
*p++=table[n%radix_base];
n/=radix_base;
}
*p++=table[n];
if(v < 0 && radix_base == 10) *p++='-';
*p='\0';
return strrev(buff);
}
unsigned int temp_hum(void)
{
signed int j=15;
//GPIOPinWrite(GPIO_PORTB_BASE,CLK, 2);
// SysCtlDelay(1000000);
//delay_ms(100); //delay for 100ms at power up
indata16 = 0x0000;
SysCtlDelay(500);
if(GPIOPinRead(GPIO_PORTB_BASE, RDY)==0)
//SysCtlDelay(1000000);
{
for(j=15;j>0;j-=2)
{
k = 0;
SysCtlDelay(500);
if(GPIOPinRead(GPIO_PORTB_BASE, DAT)==8)
{
//SysCtlDelay(1000000);
k = 1 << j;
}
indata16|=k;
GPIOPinWrite(GPIO_PORTB_BASE,CLK, 0);
SysCtlDelay(500);
while(GPIOPinRead(GPIO_PORTB_BASE, RDY)==0);
//SysCtlDelay(1000000);
k = 0;
SysCtlDelay(500);
if(GPIOPinRead(GPIO_PORTB_BASE, DAT)==8)
{
//SysCtlDelay(1000000);
k = 1 << (j-1);
}
indata16|=k;
GPIOPinWrite(GPIO_PORTB_BASE,CLK, 2);
SysCtlDelay(500);
while(GPIOPinRead(GPIO_PORTB_BASE, RDY)==1);
//SysCtlDelay(1000000);
}
}
return indata16;
}
static void mysdcard(unsigned int mydatac)
{
//itoa(bufferHum[mydatac],Hum1,10); //this function convert integer to string
//itoa(bufferTemp[mydatac],Temp1,10); //this function convert integer to string
mydatac1=mydatac;
itoa(mydatac1,result,10); //this function convert integer to string
itoa(bufferulTempValueC[mydatac1],ulTempValueC1,10); //this function convert integer to string
itoa(bufferulTempValueF[mydatac1],ulTempValueF1,10); //this function convert integer to string
if (f_open(&Fil, "DEMO1.csv", FA_WRITE | FA_OPEN_ALWAYS ) == FR_OK) // Create a file
{
size = (&Fil)->fsize;
fr= f_lseek(&Fil,size);
fr = f_write(&Fil,result,2, &bw);
fr= f_write(&Fil,",",1,&bw);
fr = f_write(&Fil,ulTempValueC1,2, &bw);
fr= f_write(&Fil,",",1,&bw);
fr = f_write(&Fil,ulTempValueF1,2, &bw);
//fr= f_write(&Fil,",",1,&bw);
//fr = f_write(&Fil,Hum1,2, &bw);
//fr= f_write(&Fil,",",1,&bw);
//fr = f_write(&Fil,Temp1,2, &bw);
fr= f_write(&Fil,"\n",1,&bw);
//f_printf(&Fil, "%u", 1234); /* "1234" */
//fr= f_write(&Fil,"Time\r\n",6,&bw);
}
fr=f_close(&Fil);
}
int
main(void)
{
count=0;
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
SysCtlADCSpeedSet(SYSCTL_ADCSPEED_250KSPS);
ADCSequenceDisable(ADC0_BASE, 1);
ADCSequenceConfigure(ADC0_BASE, 1, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC0_BASE, 1, 0, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE, 1, 1, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE, 1, 2, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE, 1, 3, ADC_CTL_TS | ADC_CTL_IE | ADC_CTL_END);
ADCSequenceEnable(ADC0_BASE, 1);
// Enable lazy stacking for interrupt handlers. This allows floating-point
// instructions to be used within interrupt handlers, but at the expense of
// extra stack usage.
//
ROM_FPULazyStackingEnable();
// Set the system clock to run at 50MHz from the PLL.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
// Enable the peripherals used by this example.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI2);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_2|GPIO_PIN_3);
GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_1);
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);
//
// Configure SysTick for a 100Hz interrupt. The FatFs driver wants a 10 ms tick.
//
/*ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / 100);
ROM_SysTickEnable();
ROM_SysTickIntEnable();*/
/*for the user requirment
* here it's generats interupt at every X second.
ulPeriod = SysCtlClockGet()*X;
TimerLoadSet(TIMER0_BASE, TIMER_A, ulPeriod);
*/
fr = f_mount(0, &FatFs);
if(fr != FR_OK)
{
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,GPIO_PIN_3);
//
// Delay for a bit
//
SysCtlDelay(50000);
return(1);
}
//fr = f_mkdir("sub1");
//if (fr) die(fr);
if (f_open(&Fil, "DEMO1.csv", FA_WRITE | FA_OPEN_ALWAYS ) == FR_OK) // Create a file
{
size = (&Fil)->fsize;
fr= f_lseek(&Fil,size);
fr= f_write(&Fil,"Time,internel_celsius,intenel_fahrenheit,ext_Hum,ext_Temp\r\n",56,&bw);
fr= f_write(&Fil,"\n",1,&bw);
//fr= f_write(&Fil,"Time\r\n",6,&bw);
// f_printf(&Fil, "%u", count); /* "1234" */
}
fr=f_close(&Fil);
//count1="0";
indata16 = 0x0000;
GPIOPinWrite(GPIO_PORTB_BASE,CLK, 2);
SysCtlDelay(1000000);
TimerLoadSet(TIMER0_BASE, TIMER_A,SysCtlClockGet());
IntEnable(INT_TIMER0A);
TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
IntMasterEnable();
TimerEnable(TIMER0_BASE, TIMER_A);
//
// Enable Interrupts
//
ROM_IntMasterEnable();
while(1)
{
if(count>=5)
{
//IntDisable(INT_TIMER0A);
TimerIntDisable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
//IntMasterDisable();
//TimerDisable(TIMER0_BASE, TIMER_A);
goto my_data;
}
ADCIntClear(ADC0_BASE, 1);
ADCProcessorTrigger(ADC0_BASE, 1);
while(!ADCIntStatus(ADC0_BASE, 1, false))
{
}
ADCSequenceDataGet(ADC0_BASE, 1, ulADC0Value);
}
my_data:
for(datacount=1;datacount<=5;datacount++)
{
mysdcard(datacount);
}
}
void Timer0IntHandler(void)
{
counter=counter+1;
// Clear the timer interrupt
count=count+1;
TimerIntClear (TIMER0_BASE, TIMER_TIMA_TIMEOUT);
if(GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_2))
{
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, 0);
}
else
{
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 4);
}
ulTempAvg = (ulADC0Value[0] + ulADC0Value[1] + ulADC0Value[2] + ulADC0Value[3] + 2)/4;
ulTempValueC = (1475 - ((2475 * ulTempAvg)) / 4096)/10;
ulTempValueF = ((ulTempValueC * 9) + 160) / 5;
bufferulTempValueC[count]=ulTempValueC;
bufferulTempValueF[count]=ulTempValueF;
/*indata=temp_hum();
Hum= indata >>8; //Separate Humidity reading into variable
bufferHum[count]=Hum;
Temp= indata & 0x00FF; //Separate Temperature reading into variable
bufferTemp[count]=Temp;*/
}
