A counter with Cortex M3, LM4F120 Launch Pad

It uses a seven segment and a button to make a simple counter. It contains a button and seven segment display. When button is pressed, seven segment will show number one more than previous. After 9 it will again show 0.
It uses a common cathode type Seven Segment in which common point is supply and all the pins are provided with  positive voltage to glow.
Button is with positive logic, means it will be considered on when it will provide input pin a high value.
A function SevenSegment is used to display numbers on this seven Segment. Port B from 1 to 7 is used for seven segment. Following is the output code for seven segment. 

Code:

  1. // ***** 0. Documentation Section *****
  2. // SevenSegment.c
  3. // Runs on LM4F120/TM4C123
  4. // Use  programming structures in C Run on a  Seven Segment and Button
  5. //      Name:       Counter
  6. //      Descrption: As you press button, it will count and show numbers 0-9
  7. //      Date:       Feb 11, 2016
  8. //      Student:    Muhammad Awais 2012-EE-506
  9. //      Class:      UTAustinX: UT.6.03x Embedded Systems - Shape the World
  11. // ***** 1. Pre-processor Directives Section *****
  13. #include "tm4c123gh6pm.h"
  14. //Bit specfic adressing for PE0 and PE1
  15. //base adress of PORTE is 0x40024000
  16. #define SW_PE0   (*((volatile unsigned long *)0x40024004))
  18. // ***** 2. Global Declarations Section *****
  20. // FUNCTION PROTOTYPES: Each subroutine defined
  21. void PORTE_Init(void);
  22. void SevenSeg_Init(void);
  23. void clear7Seg(void);
  24. void SevenSegment(int data);
  25. void Delay1ms(unsigned long msec);
  28. // ***** 3. Subroutines Section *****
  29. //GPIO_PORTE_DATA_R
  30. //GPIO_PORTB_DATA_R
  31. // PE0 connected to positive logic momentary switch using 10k ohm pull down resistor
  32. // PB1-PB7 connected to Common Anode Seven Segment
  33. int main(void){
  34. //**********************************************************************
  35. // The following version tests input on PE0 and output on PE1
  36. //**********************************************************************
  37.   int count=0;
  38.     PORTE_Init();      // Initlizes PORTE for switch
  39.     SevenSeg_Init();   // Initlizes PORTB for Seven Segment
  40.   SevenSegment(0);   // Seven Segment is showing 0 on reset
  41.   while(1)           //Infinte loop
  42.         {
  43.        
  44.             /*
  45.             For Simple Counter Without Button
  46.             for(count;count<=9;count++)
  47.             {
  48.             SevenSegment(count);
  49.                 Delay1ms(1000);
  50.                 clear7Seg();
  51.             }
  52.             */
  53.         if (count>9)                            //When count=9 it makes it zero
  54.         {
  55.             count=0;
  56.             SevenSegment(count);
  57.         }
  58.        
  59.         if(SW_PE0==0x01)                        //If switch is presses
  60.         {
  61.             count=count+1;                          //incremetn counter
  62.             clear7Seg();                                //Clears seven segment to write new data
  63.             SevenSegment(count);                //Writes number on Seven Segment
  64.             Delay1ms(100);              //Dealy for button debouncing and other factors
  66.         }
  67.        
  68.   }
  70. }
  72. /*
  73. Descrption: Initilizes PE0==>Input
  74. Input: None
  75. Output: None
  76. */
  77. void PORTE_Init(void)
  78. {
  79.   volatile unsigned long delay;
  80.   SYSCTL_RCGC2_R |= 0x00000010;      // 1) E clock
  81.   delay = SYSCTL_RCGC2_R;            // delay to allow clock to stabilize    
  82.   GPIO_PORTE_AMSEL_R &= 0x00;        // 2) disable analog function
  83.   GPIO_PORTE_PCTL_R &= 0x00000000;   // 3) GPIO clear bit PCTL  
  84.   GPIO_PORTE_DIR_R &= ~0x01;         // 4.1) PE0 input,
  85.   GPIO_PORTE_AFSEL_R &= 0x00;        // 5) no alternate function      
  86.   GPIO_PORTE_DEN_R |= 0x01;          // 6) enable digital pins PE4-PE1
  88. }
  90. /*
  91. Descrption: Initilizes PB1 to PB7 as output
  92. Input: None
  93. Output: None
  94. */
  95. void SevenSeg_Init(void)
  96. {
  97.   volatile unsigned long delay;
  98.   SYSCTL_RCGC2_R |= 0x00000002;      // 1) B clock
  99.   delay = SYSCTL_RCGC2_R;            // delay to allow clock to stabilize    
  100.   GPIO_PORTB_AMSEL_R &= 0x00;        // 2) disable analog function
  101.   GPIO_PORTB_PCTL_R &= 0x00000000;   // 3) GPIO clear bit PCTL  
  102.   GPIO_PORTB_DIR_R |= 0xFF;          // 4) PB output  
  103.   GPIO_PORTB_AFSEL_R &= 0x00;        // 5) no alternate function      
  104.   GPIO_PORTB_DEN_R |= 0xFF;          // 6) enable digital AT PB
  106. }
  108. /*
  109. Descrption: Clears all 1-7 pins of PortB
  110. Input: None
  111. Output: None
  112. */
  113. void clear7Seg()
  114. {
  115.     GPIO_PORTB_DATA_R=0xff;
  116. }
  118. /*
  119. Descrption: All the pins who will show number on Seven Segment will be zero
  120. It is for common anode type, to make it for common cathode add ~ before all cases
  121. Input: Number to be printed on Seven Segment
  122. Output: None
  123. */
  125. void SevenSegment(int data){
  127.     switch(data)
  128.     {
  129.         case 0: GPIO_PORTB_DATA_R=0x11  ;
  130.         break;
  131.       case 1: GPIO_PORTB_DATA_R=0x7D;
  132.         break;
  133.         case 2: GPIO_PORTB_DATA_R=0x89;
  134.         break;
  135.         case 3: GPIO_PORTB_DATA_R=0x29;
  136.         break;
  137.         case 4: GPIO_PORTB_DATA_R=0x65;
  138.         break;
  139.         case 5: GPIO_PORTB_DATA_R=0x23;
  140.         break;
  141.         case 6: GPIO_PORTB_DATA_R=0x03;
  142.         break;
  143.         case 7: GPIO_PORTB_DATA_R=0x79;
  144.         break;
  145.         case 8: GPIO_PORTB_DATA_R=0x01;
  146.         break;
  147.         case 9: GPIO_PORTB_DATA_R=0x21;
  148.         break;
  149.     }
  151. }
  152. /*
  153. Descrption: Uses time of a instruction to delay time
  154. Almost 1ms for each cycle
  155. Input: Number of ms to delay
  156. Output: None
  157. */
  158. void Delay1ms(unsigned long msec){
  159. // write this function
  160.     unsigned long i;
  161.    
  162.   while(msec > 0){
  163.     i = 13333;  // this number means 1ms
  164.     while(i > 0){
  165.       i = i - 1;
  166.     }
  167.     msec = msec - 1; // decrements every 1 ms
  168.   }
  170. }

Practical Implementation:

A counter without button


A seven Segment code written in Energia:

Energia is a software that is used for lauch pad to write arduino like code. Here is a code for Seven Segment in Energia.\

/*
 Seven segment display
  Muhammad Awais fb/awais12506
  
  Hardware Required:
  * LaunchPad with an LED
  *Seven segment
  *Connecting wires
  
 .
*/

// most launchpads have a red LED
int A=A2;
int B=A3;
int C=A4;
int D=A1;
int E=A0;
int FI=A5;
int G=7;

//see pins_energia.h for more LED definitions

  
// the setup routine runs once when you press reset:
void setup() {                
  // initialize the digital pin as an output.
  pinMode(A, OUTPUT);
  pinMode(B, OUTPUT);
  pinMode(C, OUTPUT);
  pinMode(D, OUTPUT);
  pinMode(E, OUTPUT);
  pinMode(FI,OUTPUT);
  pinMode(G, OUTPUT);
}

// the loop routine runs over and over again forever:
void loop() {
  
    setOff();
    sendData(9);
 for(int i=0;i<10;i++)
 {
sendData(i);
delay(1000);
setOff();
 }
}
void sendData(int num)
{
  switch (num)
  {
    case 1: 
    digitalWrite(FI,LOW);
    digitalWrite(E, LOW);
    break;
    case 2:
    digitalWrite(A, LOW);
    digitalWrite(B, LOW);
    digitalWrite(G, LOW);
    digitalWrite(E, LOW);
    digitalWrite(D, LOW);
    break;
    case 3:
    digitalWrite(A, LOW);
    digitalWrite(B, LOW);
    digitalWrite(G, LOW);
    digitalWrite(C, LOW);
    digitalWrite(D, LOW);
    break;
    case 4:
    digitalWrite(FI, LOW);
    digitalWrite(G, LOW);
    digitalWrite(B, LOW);
    digitalWrite(C, LOW);
    
    break;
    case 5:
    digitalWrite(A, LOW);
    digitalWrite(FI, LOW);
    digitalWrite(G, LOW);
    digitalWrite(C, LOW);
    digitalWrite(D, LOW);
    break;
    case 6:
    digitalWrite(A, LOW);
    digitalWrite(FI, LOW);
    digitalWrite(G, LOW);
    digitalWrite(C, LOW);
    digitalWrite(D, LOW);
    digitalWrite(E, LOW);
    break;
     case 7:
    digitalWrite(A, LOW);
    digitalWrite(B, LOW);
    digitalWrite(C, LOW);
    break;
    case 8:
    digitalWrite(A, 0);
    digitalWrite(B, 0);
    digitalWrite(C, 0);
    digitalWrite(D, 0);
    digitalWrite(E, 0);
    digitalWrite(FI,0);
    digitalWrite(G, 0);
    case 9:
    digitalWrite(A, LOW);
   // digitalWrite(B, 0);
    //digitalWrite(C, 0);
    //digitalWrite(FI,0);
    //digitalWrite(G, 0);
    case 0:
    digitalWrite(A, 0);
    digitalWrite(B, 0);
    digitalWrite(C, 0);
    digitalWrite(D, 0);
    digitalWrite(E, 0);
    digitalWrite(FI,0);

  }
}
void setOff()
{
    digitalWrite(A, HIGH);
    digitalWrite(B, HIGH);
    digitalWrite(C, HIGH);
    digitalWrite(D, HIGH);
    digitalWrite(E, HIGH);
    digitalWrite(FI,HIGH);
    digitalWrite(G, HIGH);
    
}

void setOn()
{
    digitalWrite(A, 0);
    digitalWrite(B, 0);
    digitalWrite(C, 0);
    digitalWrite(D, 0);
    digitalWrite(E, 0);
    digitalWrite(FI,0);
    digitalWrite(G, 0);
    
}



Posted by at No comments:
Labels: ,

Led and button with Cortex M3, LM4F120 Microcontroller

This is simple program made on LM4f123 launch pad of texas instruments. One button and a led is interfaced with PORT E pin 0 and Port E pin 1 respectively. Led is initially on, when button is pressed, it will change its state or toggle with a delay of approximately 100ms.

Debugging:

Logic Analyzer: 


Register Window in KEIL




Following is algorithm of the program..

1) Initializes registers of ARM
2) LED is initially on
3) Check if button is on or not
    if button is on, toggle led with 100ms delay
   else nothing

Downloads


Delay function is a approximation and made by knowing the time a command takes to execute. So it is not precise.  It will take 13333 cycles of while loop for almost 1ms. This fact is used in this program.


Code:

  1. // ***** 0. Documentation Section *****
  2. // SwitchLEDInterface.c
  3. // Runs on LM4F120/TM4C123
  4. // Use simple programming structures in C to toggle an LED
  5. // while a button is pressed and turn the LED on when the
  6. //      Date:    Feb 11, 2016
  7. //      Student: Muhammad Awais 2012-EE-506
  8. //      Contact Info: Fb/awais12506
  9. //      Class:   UTAustinX: UT.6.03x Embedded Systems - Shape the World
  11. // ***** 1. Pre-processor Directives Section *****
  13. #include "tm4c123gh6pm.h"
  15. //Bit specfic adressing for PE0 and PE1
  16. //base adress of PORTE is 0x40024000
  17. #define SW_PE0   (*((volatile unsigned long *)0x40024004))
  18. #define LED_PE1   (*((volatile unsigned long *)0x40024008))
  19. // ***** 2. Global Declarations Section *****
  21. // FUNCTION PROTOTYPES: Each subroutine defined
  22. void PORTE_Init(void);
  23. void Delay1ms(unsigned long msec);
  24. // ***** 3. Subroutines Section *****
  25. //GPIO_PORTE_DATA_R
  26. // PE0, PB0, or PA2 connected to positive logic momentary switch using 10k ohm pull down resistor
  27. // PE1, PB1, or PA3 connected to positive logic LED through 470 ohm current limiting resistor
  28. int main(void){
  29. //**********************************************************************
  30. // The following version tests input on PE0 and output on PE1
  31. //**********************************************************************
  33.     PORTE_Init();      // Initlizes PORTE

Click here to read more
Posted by at 1 comment:
Labels: ,

Newton Ralphson Method using Matlab

Newton Ralphson method is  finding successively better approximations to a functions root. In this method one initial guess of root is given. Then we find value of the function at that root. A tangent is drawn at that value of function then value of that tangent where it crosses x-axis is taken. This value is comparatively better root. Again value of function is found on that point and then again a tangent is drawn at that point and so on... This process is repeated until error has become significantly small.
Following figure is explaining this in a simple way.



MATLAB Code:

%Author: Muhammad Awais 2012-ee-506 UET Lahore
%This Function uses Newton Ralphson Method to find root of a function
%Input: Function , initial guess, minmum tolerace
%Output: Roots of function, Number of iterations used.
%Please input function in following way...
%syms x
%f=x.^3-20
function [y,iteration]=NewtonRalphson(f,x0,error)

g=diff(f);      %Differentiation of f
%older and new is to hold values of x in each iteration and last iteration.
older=0;
new=1;
%Number of iterations that it has to complete
iteration=1;

while ((abs(new-older)>error ) )
    older=x0;
    x1=x0-subs(f,x0)/subs(g,x0);  %Newton Ralphson Formula
    new=x1;
    x0=x1;
    iteration=iteration+1;

end

y=double(x1);   %Syms tool doesnt produces values in double so...

Output:


Problems:

1) Derivation

Finding derivation is a expensive process when we talk about computers. They take a lot of time determining derivation.

2)Convergence

Some time this method simply did't converge so algorithm fails.

3)Poor initial estimate

Poor initial estimate may make this  algorithm non-convergent. One such example is...
f(x)=|x|^a,\quad 0 < a < \tfrac{1}{2}  [1]

References: 

[1] https://en.wikipedia.org/wiki/Newton%27s_method

Posted by at No comments:
Labels: , ,
Subscribe to: Posts (Atom)