Exponential Series in ARM Cortex M4 Assembly

e^x = 1 + (x/1!)+((x^2)/2!)+((x^3)/3!)+......

The below ARM assembly code will be used to find the value of e^x  based on the above definition for any value of x using the Floating point unit of ARM Cortex-M4 Processor.

Code:

 PRESERVE8
        THUMB
        AREA    |.text|,CODE,READONLY
        EXPORT __main
        ENTRY
__main    FUNCTION
        MOV R0,#10;Holding the Number of Terms in Series 'n'
        MOV R1,#1;Counting Variable 'i'
        VLDR.F32 S0,=1;Holding the sum of series elements 's'
        VLDR.F32 S1,=1;Temp Variable to hold the intermediate series elements 't'
        VLDR.F32 S2,=3;Holding 'x' Value
LOOP1    CMP R1,R0;Compare 'i' and 'n' 
        BLE LOOP;if i < n goto LOOP
        B stop;else goto stop
LOOP      VMUL.F32 S1,S1,S2; t = t*x
        VMOV.F32 S5,R1;Moving the bit stream in R1('i') to S5(floating point register)
        VCVT.F32.U32 S5, S5;Converting the bitstream into unsigned fp Number 32 bit
        VDIV.F32 S1,S1,S5;Divide t by 'i' and store it back in 't'
        VADD.F32 S0,S0,S1;Finally add 's' to 't' and store it in 's'
        ADD R1,R1,#1;Increment the counter variable 'i'
        B LOOP1;Again goto comparision
stop    B stop
        ENDFUNC
        END

Read More

Five Stage Pipeline

In simple terms, pipelining enables instruction level parallelism. From fetching an instruction to its actual execution, one can divide this whole process into well-defined stages. So, in a five stage pipeline, we can effectively execute five different instructions in one clock cycle.

• However, each stage can be stalled due to complexity of operations like division, branching takes more time than addition or unavailability of data, or dependency between successive instructions.
  

• Implementing a pipeline stage adds cost and delay to architecture, but overall CPI (clocks per instruction) decreases, which makes pipelining viable for computer architecture.
  

• As the pipeline is as stronger as its weakest link, it should be taken care that every stage should be load balanced while designing a pipeline i.e. time required to process should remain almost equal.
  

• Reading and writing the memory and register file and using the ALU typically constitute the biggest delays in the processor. So we try to choose five pipeline stages so that each stage involves exactly one of these slow steps. The five stages, one step per stage are:

Fetch

• In the Fetch stage, the processor reads the instruction from instruction memory.

Decode

• In the Decode stage, the processor reads the source operands from the register file and decodes the instruction to produce the control signals.
  

Execute

• In the Execute stage, the processor performs a computation with the ALU.

Memory

• In the Memory stage, the processor reads or writes data memory.

Writeback 

• Writeback stage, the processor writes the result to the register file, when applicable. 

In the pipelined processor given in the above figure, the length of a pipeline stage is set at 250 ps by the slowest stage, the memory access (in the Fetch or Memory stage). At time 0, the first instruction is fetched from memory. At 250 ps, the first instruction enters the Decode stage, and a second instruction is fetched. At 500 ps, the first instruction executes, the second instruction enters the Decode stage, and a third instruction is fetched. And so forth, until all the instructions complete. The instruction latency is 5 * 250 = 1250 ps. The throughput is 1 instruction per 250 ps (4 billion instructions per second). Because the stages are not perfectly balanced with equal amounts of logic, the latency is slightly longer for the pipelined than for the single-cycle processor. Similarly, the throughput is not quite five times as great for a five-stage pipeline as for the single-cycle processor. Nevertheless, the throughput advantage is substantial.

Advantages of Five Stage Pipeline:

• Will help in executing multiple instructions in parallel.All the stages i.e. all the units in the pipeline will be busy all the time.
  

• Because each stage has only one-fifth of the entire logic, the clock frequency is almost five times faster.

• Hence, the latency of each instruction is ideally unchanged, but the throughput is ideally five times better.
  

• Microprocessors execute millions or billions of instructions per second, so throughput is more important than latency.
  

But the Pipelining process will introduce some overhead, so the throughput will not be quite as high as we might ideally desire, but pipelining nevertheless gives such great advantage for so little cost that all modern high-performance microprocessors are pipelined.

How Hazards Come into picture in a Five Stage Pipeline:
A central challenge in pipelined systems is handling hazards that occur when the results of one instruction are
needed by a subsequent instruction before the former instruction has completed.

Types of Hazards:
 

Structure Hazards: (because of one memory)
This type of Hazard occurs when there is a conflict for use of a common resource. Because somewhere in the
pipeline there can be a situation where instruction fetch and the data fetch can happen at the same time. So
in that case instruction fetch would have to stall for that cycle, which would cause a pipeline bubble. Hence
the pipelined data paths require separate instruction/data memories.

Data Hazards:
This type of Hazard occurs when an instruction depends on the result of a previous instruction which is still in the pipeline.

Possible Solutions for Data Hazards:

• Solving Data Hazards with Forwarding:

Some data hazards can be solved by forwarding (also called bypassing) a result from the memory or write back stage to a dependent instruction in the Execute stage.

• Solving Data Hazards with Stalls:

The alternative solution is to stall the pipeline, holding up operation until the data is available.
 

Control Hazards:
Control hazards occur when the decision of what instruction to fetch has not been made by the time the next instruction must be fetched. Control hazards are solved by predicting which instruction should be fetched and flushing the pipeline if the prediction is later determined to be wrong. Moving the decision as early as possible minimizes the number of instructions that are flushed on a mis-prediction.

Read More

Python Language Translator

 

Synopsis:

The Python Language Translator is a python script which takes the input from the user and converts it to any language that user want and read the converted text in that particular language

Execution:

Command : python PyLanguage_Translator.py

Script Link:

 

Read More

C Code to Perform Sampling Rate Convertion

  Sampling Rate Conversion in Real Time(Using a C language)

 

Upsampling and DownSampling using Reconstruction

(Using sinc Function):

Code:

#include<stdio.h>
#include<math.h>
#define PI 3.14
void main()
{
  int m,n,samplingrate,chunksize,subchunk2size,newchunksize,newsamplingrate,newsubchunk2size;
  float i;
  //int noofsamples;
  int factor;
  unsigned char a,b,c,d,e;
  FILE *fp,*fp2;
  void writeheaderfile(FILE *fp,int newsamplingrate,int newchunksize,int newsubchunk2size,FILE *fp2);
  void writedatafile(FILE *fp,int newsamplingrate,int newchunksize,int newsubchunk2size,float i,int subchunk2size,FILE *fp2);
  printf("Original Song is in : song1.wav\nResult is stored in : Createdsong.wav\n");
  fp=fopen("song1.wav","r");
  fp2=fopen("Createdsong.wav","w+");
  fseek(fp,24,SEEK_SET);
  fread(&samplingrate,4,1,fp);
  printf("Sampling Rate is : %d\n",samplingrate);
  fseek(fp,4,SEEK_SET);
  fread(&chunksize,4,1,fp);
  printf("chunksize is : %d\n",chunksize);
  fseek(fp,40,SEEK_SET);
  fread(&subchunk2size,4,1,fp);
  printf("subchunk2size is : %d\n",subchunk2size);
  printf("Enter the New Sampling Rate : ");scanf("%d",&newsamplingrate);
  i=(float)samplingrate/newsamplingrate;
  //printf("I value is : %f\n",i);
  //noofsamples=readnoofsamples(fp);
  printf("No of Samples in Given File : %d\n",subchunk2size/4);
  newsubchunk2size=subchunk2size/i;
  newchunksize=newsubchunk2size+36;
  //noofsamples=newsubchunk2size/4;
  writeheaderfile(fp,newsamplingrate,newchunksize,newsubchunk2size,fp2);
  //fclose(fp2);
 // fp2=fopen("Createdsong.wav","w+");
  writedatafile(fp,newsamplingrate,newchunksize,newsubchunk2size,i,subchunk2size,fp2);
}
/*int readnoofsamples(FILE *fp)
{
int count=1;
unsigned char c;
fp=fopen("song1.wav","r");
fseek(fp,44,SEEK_SET);
while(1)
{
if(feof(fp)) break;
fscanf(fp,"%c",&c);
count++;
//printf("%d\n",count);

}
//count=count/4;
return count;
}*/
void writedatafile(FILE *fp,int newsamplingrate,int newchunksize,int newsubchunk2size,float i,int subchunk2size,FILE *fp2)
{
//FILE *fp2;
int count=0,samco=1,center,samp=0,previous=0,x,temp;
short int e,r;
long int m,n,sumfr,sumfl;
float suml=0,sumr=0;
unsigned char z,s,v,w,c;
float sinc(int m,float i,int n);
printf("Writing the Samples in File....Please Wait....\n");
//fp=fopen("song1.wav","r");
fseek(fp,40,SEEK_SET);
    fread(&subchunk2size,4,1,fp);
    //printf("subchunk2size is : %d\n",subchunk2size);
    //fclose(fp);
//fp=fopen("song1.wav","r");
//fp2=fopen("Createdsong.wav","a");
fseek(fp,44,SEEK_SET);
fseek(fp2,44,SEEK_SET);
//printf("%d\n",subchunk2size);
for(m=0;m<=subchunk2size;m++)
{
//if(feof(fp)) break;

sumfl=0;
sumr=0;
suml=0;
sumfr=0;
center=rint(m*i);
if(previous==center)
{

}
else
{
for(temp=0;temp<(center-previous);temp++)
{
count++;
}
}
previous=center;
fseek(fp,44+(4*count),SEEK_SET);
for(n=count-10;n<count+10;n++)
{
//printf("m value : %d\n",m);
if(n<0)
{
e=0;
r=0;
}
else
{


fread(&e,2,1,fp);
fread(&r,2,1,fp);
}
sumr=sumr+(e*sinc(m,i,n));
suml=suml+(r*sinc(m,i,n));
sumfl=suml;
sumfr=sumr;
//if(sumfl==0) printf("m=%d\t n=%d\n",m,n);
//printf("m*I=%d\t n=%d\t e=%d\n",m*i,n,e);
//printf("suml=%lf\t sumr=%lf\t n=%d\t count=%d\t e=%d\t r=%d\n",suml,sumr,n,count,e,r);

}
fwrite(&sumfr,2,1,fp2);
fwrite(&sumfl,2,1,fp2);
/*fscanf(fp,"%c",&t);
fscanf(fp,"%c",&s);
fscanf(fp,"%c",&v);
fscanf(fp,"%c",&w);
printf("%d %d %d %d\n",t,s,v,w);*/
//if(sumfr==0) printf("m=%d\t and n=%d\n",m,n);
//printf("m=%d\t and sumfl=%d\t sumfr=%d\n",m,sumfl,sumfr);
//getchar();
}
printf("Process Completed...Result is in Createdsong.wav\n");

fclose(fp);
fclose(fp2);
}
float sinc(int m,float i,int n)
{
float temp;
if(rint(m*i)==n) 
{
//printf("sinc value is : %f\n",1.00);
return 1.00;
}
else
{
temp=PI*(m*i-n);
//printf("sinc value is : %f\n",(sin(temp)/temp));
return (sin(temp)/temp);
}
}

void writeheaderfile(FILE *fp,int newsamplingrate,int newchunksize,int newsubchunk2size,FILE *fp2)
{long int count=1;
unsigned char header;
//FILE *fp2;
//fp=fopen("song1.wav","r");
//fp2=fopen("Createdsong.wav","w+");
  fseek(fp,0,SEEK_SET);
  while(1)
 {
  fread(&header,4,1,fp);
  fwrite(&header,4,1,fp2);
  if(ftell(fp)==44) break;
 }
  fseek(fp2,4,SEEK_SET);
  fwrite(&newchunksize,4,1,fp2);
  fseek(fp2,24,SEEK_SET);
  fwrite(&newsamplingrate,4,1,fp2);
  fseek(fp2,40,SEEK_SET);
  fwrite(&newsubchunk2size,4,1,fp2);
  //fclose(fp2);
  //fclose(fp);
  //printf("Suc\n");
}

Down Sampling using Decimation(Without Using Sinc Function):

Code:

#include<stdio.h>
void main()
{
  FILE *fp,*fp2;
  unsigned char down;
  int samplingrate,ratio,i=4,chunksize,subchunk2size,newchunksize,newsubchunk2size;
  int newsamplingrate;
  long int count=1;
  
//Getting the Sampling Rate from the File 
  //  while(1)
 // {
    fp=fopen("mono.wav","r");
    fseek(fp,24,SEEK_SET);
    fread(&samplingrate,4,1,fp);
    rewind;
    fseek(fp,4,SEEK_SET);
    fread(&chunksize,4,1,fp);
    rewind;
    fseek(fp,40,SEEK_SET);
    fread(&subchunk2size,4,1,fp);
    
    //fscanf(fp,"%d",&sample);
    //**fprintf(stdout,"samplingrate is %u\n chunksize is : %u\nsubchunk2size is : %u\n",samplingrate,chunksize,subchunk2size);
    //count++;
    //if(count>44) break;
  //}
  //printf("The count value is : %ld\n",count-1);

fclose(fp);
//printf("Enter the New Sampling Rate : ");scanf("%d",&newsamplingrate);
newsamplingrate=5000;
if(newsamplingrate<samplingrate)
{  
  ratio=samplingrate/newsamplingrate;
  fp=fopen("song1.wav","r");
  fseek(fp,44,SEEK_SET);
  while(1)
  { 
    fscanf(fp,"%c",&down);
    //fprintf(stdout,"%d\t",down);
    count++;
    i--;
    if(feof(fp)) break;
    if(i<1)
    {
      i=4;
      fseek(fp,SEEK_CUR+4*(ratio-1)-1,SEEK_CUR);
    }   
  }


  fclose(fp);  

  count=count/4;
//  printf("Count is  : %ld\n",count);
  newsubchunk2size=chunksize/3;
  newchunksize=newsubchunk2size+36;
  writeheaderfile(fp,newsamplingrate,newchunksize,newsubchunk2size);
  writedatafile(fp,newsamplingrate,newchunksize,newsubchunk2size,ratio);

}
/*if(newsamplingrate>samplingrate)
{
  ratio=newsamplingrate/samplingrate;
  fp=fopen("song1.wav","r");
  fseek(fp,44,SEEK_SET);
  newsubchunk2size=chunksize*3;
  newchunksize=newsubchunk2size+36;
  writeheaderfile(fp,newsamplingrate,newchunksize,newsubchunk2size);
  writedataupfile(fp,newsamplingrate,newchunksize,newsubchunk2size,ratio);
}*/
}
//Writing the Header Section 
void writeheaderfile(FILE *fp,int newsamplingrate,int newchunksize,int newsubchunk2size)
{long int count=1;
unsigned char header;
FILE *fp2;
fp=fopen("mono.wav","r");
  fp2=fopen("song2.wav","w+");
  //rewind;
  while(1)
 {
  fread(&header,4,1,fp);
  //if(ftell(fp)==5) fprintf(fp2,"%c",newchunksize);
  //else if(ftell(fp)==17) fprintf(fp2,"%c",newsubchunk2size);
  //else if(ftell(fp)==25) fprintf(fp2,"%c",newsamplingrate);
  //else fprintf(fp2,"%c",header);
  fwrite(&header,4,1,fp2);
   if(ftell(fp)==44) {fclose(fp);break;}
 }
  //fp=fopen("song1.wav","r");
  //fp2=fopen("song2.wav","w+");
  //rewind(fp2);
  fseek(fp2,4,SEEK_SET);
  fwrite(&newchunksize,4,1,fp2);//fprintf(fp2,"%c",&newchunksize);
  //rewind(fp2);
  fseek(fp2,40,SEEK_SET);
  fwrite(&newsubchunk2size,4,1,fp2);
  //rewind(fp2);
  fseek(fp2,24,SEEK_SET);
  fwrite(&newsamplingrate,4,1,fp2);
  //fclose(fp);
  fclose(fp2);

  
}
//Write data to file
void writedatafile(FILE *fp,int newsamplingrate,int newchunksize,int newsubchunk2size,int ratio)
{unsigned char down;
 long int count=1;
 int i=4;
 FILE *fp2;
 fp=fopen("mono.wav","r");
 fp2=fopen("song2.wav","a+");
  fseek(fp,44,SEEK_SET);
  while(1)
  { 
    fscanf(fp,"%c",&down);
    fprintf(fp2,"%c",down);
    count++;
    i--;
    if(feof(fp)) break;
    if(i<1)
    {
      i=4;
      fseek(fp,SEEK_CUR+4*(ratio-1)-1,SEEK_CUR);
    }   
  }


  fclose(fp);  
  fclose(fp2);
}

Read More