Like Tree2Likes
  • 2 Post By jimblumberg

Seven Segment Display Problem !

This is a discussion on Seven Segment Display Problem ! within the C Programming forums, part of the General Programming Boards category; Hello Every one, I wrote a code which is A program that manipulates and controls a bit pattern that is ...

  1. #1
    Registered User
    Join Date
    Mar 2013
    Posts
    2

    Seven Segment Display Problem !

    Hello Every one,

    I wrote a code which is A program that manipulates and controls a bit pattern that is sent to an LED display.The bit pattern is controlled by three switches and one button The button acts as a gun shooting out the Least Significant LED of the Altera DE0. *
    Two switches must be used to determine four speeds the LEDs rotate to One switch controls the direction of the rotating pattern and should display the number of shots on the seven segment display.

    Now my problem is that I have to increment the seven seg every time I press the button under all conditions; killed a duck , missed a duck or any thing.
    This is my code below I though it would be good that you have a look at the whole code . My code somehow relates the sev seg count with the speed of the LEDs because when they are really fast and I press the button , it counts like 10 or 20 times per press !!!

    Any advice would be appreciated

    Many thanks
    Code:
     /*********************************************************************************
     * Duckshoot Program *
      * Author: *
     * Date: 11th April *
      * Description: A program that manipulates and controls a bit pattern that is sent*
     * to an LED display.The bit pattern is controled by three switches and one button *
     * The button acts as a gun shooting out the Least Significant LED of the DE0. *
     * Two switches must be used to determine four speeds the LEDs rotate to*
      * One switch controls the direction of the rotating pattern. *
     
     *List of Functions and Sub sections of functions: *
     * Main Program *
      which includes the code that edits the number of ducks written on the DE0 LEDs, taking into
      account penultys
      
     * Functions *
     
     * WRITE LIGHTS *
     * LIGHTS *
     * SPEED SETTING *
     * DIRECTION *
      *  END OF GAME *
     
     * *
     *********************************************************************************/
    /* # Include Section*/
    
    
    #include "system.h"
    #include "altera_avalon_pio_regs.h"
    #include "alt_types.h"
    
    /* Function Prototype Section
    * Prototypes for all functions called by this module, with the exception of USLEEP function whcih does exist in the Standard C Library*/
    
    int main (void) __attribute__ ((weak, alias ("alt_main")));
    void lights (unsigned int *sleep, unsigned int *data);
    int endofgame (unsigned int *data);
    /********************************************************************************/
    
    
    
    /*********************************************************************************
     *MAIN PROGRAM *
     *********************************************************************************/
    
    int alt_main (void) 
    {
    unsigned int sleep;/*Asssigned to USLEEP*/
    unsigned int data=0x2aa; /*set initial light pattern and store in lights to be sent to DE0*/
    /*Number of Ducks on the DE0 - should be 2AA for alternate */
    
    int count=0,d=0,n=0,x=0;
    
    while(1)
    { 
    alt_u32 sev[10]; /*Array for 0-9 hex*/
    sev[0]=0xc0;
    sev[1]=0xf9;
    sev[2]=0xa4;
    sev[3]=0xb0;
    sev[4]=0x99;
    sev[5]=0x92;
    sev[6]=0x82;
    sev[7]=0xf8;
    sev[8]=0x80;
    sev[9]=0x98;
       alt_u16 buttons=0x00;
       alt_u8 state=0;
    /**********************************************************************************
      When the button is on it will shootout the LSB led or add a penulty *
      duck if there is no duck to shoot. *
      *********************************************************************************/
    buttons = IORD_ALTERA_AVALON_PIO_DATA(BUTTONS_BASE); /*READ the shoot button*/
        buttons = (~buttons & 0x07);
        
        /*Shoot or Relight the Lights*/
        
            
          if((buttons &0x04)&& !state){ /*if button_2 is pressed*/
                count++;   /*First display*/
               if(count>9){
                d++;         /*Second display*/
                count=0;
                      }
               if(d>9){
               n++;           /*Third display*/
               count=0;
               d=0;
                      }
               if(n>9){
                x++;           /*Forth display*/
                n=0;
                count=0;
                d=0;
                      }
               if(x>9){
                x=0;
                n=0;
                count=0;
                d=0;
              
                     }
            state=1;
          }
          IOWR_ALTERA_AVALON_PIO_DATA(SEG7_BASE,sev[x]*16777216 + sev[n]*65536 + sev[d]*256 + sev[count]); /*Display the number of shots  on the SEV-SEG*/
          if(state==1)
          {
            if(data & 0x01){ /*if the LSB LED is on*/
            
               data=data^0x01; /*Invert it "shoot it"*/
            
                state=0;
                /*Control the SEV-SEG */
           
                             
                       }
            else if(!(data & 0x01)){ /*if LSB LED is not on*/
            
            data=data^0x01; /*Invert it , turn it on*/
            state=1;
            }
              
          }
    
            
          
          
     IOWR_ALTERA_AVALON_PIO_DATA(LEDS_BASE,data);    /*Display the shots taken on the SEV-SEG*/ 
             
    usleep(sleep);
       
        
    
    
     lights (&sleep,&data);   /*function edits ducks, in which they are displayed on the DE0 in the
    sense of their direction and speed.*/
    
    if (endofgame(&data)) /*if testend() returns 1 then program will
    end normally*/
    
    return(0); /*return 0 to break out of while loop in order to exit
    the program*/
    
       
     }
    return 0;
    
    }
    
    /************************************************************************************
                                     FUNCTIONS
     *************************************************************************************/
     
     
     /*************************************************************************************
     * Lights Function *
     
     * Function name : void lights (unsigned int *sleep, unsigned int *data) *
     * Returns : return value data (Ducks) *
     * Description : This funtction reads the Speed Switches to work out what speed for *
     * the program to run at. It runs 1 of 4 speeds *
     * This function also reads the direction switch to find out what *
     * direction to rotate the LEDS in. Either right or left. *
     * This function will then write the results and update the LEDS (Data).*
     *************************************************************************************/
     
    void lights (unsigned int *sleep, unsigned int *data){
    alt_u16 speedswitch;    
    unsigned int directionswitch;
    
    int delay1=600000; /*USleep 1 Option */
    int delay2=400000; /*USleep 2 Option */
    int delay3=100000; /*USleep 3 Option */
    int delay4=10000;  /*USleep 4 Option */
    
    
    /****************************************************
     ** SPEED SETTING **
     **test the two speed switches and returns a value **
     **to go into USLEEP. **
     ****************************************************/
    speedswitch = IORD_ALTERA_AVALON_PIO_DATA(SWITCHES_BASE);  /*Reads the Speed Switch */
    speedswitch = (~speedswitch & 0xE0);
    
    if(!(speedswitch&0x40)) /*test if SW6 is on*/
    *sleep=delay2;
    else if(!(speedswitch&0x80)) /*test if SW7   is on*/
    *sleep=delay3;
    else if(!(speedswitch&0xc0))/*test if SW6 and SW7   is on*/
    *sleep=delay4;
    else
    *sleep=delay1; /* if no switches are on DEFAULT speed*/
    
    /****************************************************
               ** DIRECTION AND ROTATE **
     
     **test the direction switch and rotate in the **
     **corresponding direction **
     ****************************************************/
    
    
    directionswitch = IORD_ALTERA_AVALON_PIO_DATA(SWITCHES_BASE);     /*READ Direction Switch*/
    directionswitch = (~directionswitch & 0x07);
    
    /*Move Lights - in association with the direction switch.Whether to
      make the LEDS rotate LEFT or RIGHT*/
    if (directionswitch&0x01) /*if SW0 is on "UP"*/
    {
    if((*data & 0x01)==1){   /*If LSB (LED) is on*/
              *data=*data&0x3FE;  /*1111111110*/
              *data=*data>>1;       /*move all the lights to the right*/
              *data=*data|0x200;   /*keep on MSB LED  "1000000000"*/
    }
    else
    *data=*data>>1;  /*move all the lights to the right*/
    }
    else  /*if the switch is in the off position*/
    {
        if((*data & 0x200)==0x200){ /*If MSB (LED)  is off*/
             *data=*data&0x1FF;     /*111111111*/
             *data=*data<<1;       /*move all the lights to the left*/
    =         *data=*data|0x01;   /*keep on the LSB LED"0000000001"*/
             
       
           
        }
       else
        *data=*data<<1;   /* move lights to the left*/
       
    }
    
     IOWR_ALTERA_AVALON_PIO_DATA(LEDS_BASE,*data); /*dispaly data on LEDs*/
        usleep(*sleep);/*Run the USLEEP time*/
    
    
    }
    
    /*************************************************************************************
                                  TEST END OF GAME FUNCTION *
    
     * Function name : int endofgame(unsigned int *data) *
     * Returns : return value data (Ducks) *
     * Description : This function will test for the different options in terms of *
     * whether or not you have won the game. *
     * The funtion will find out how many ducks are lit, by working out *
     * the hex equivalent, and checking it against the if statement. *
     * I.E Either 0x00 (0) - No ducks lit, or 0xFF (225) *
     *************************************************************************************/
    
    int endofgame (unsigned int *data){
    if ((*data == 0x3FF)|(*data ==0)) /*test whether all LEDs are on or off*/
    {
    
    if (*data == 0) /* if no LEDS (ducks) are on .*/
    {
        
        alt_u32 val0=0xA1C0C886; /* The game will stop and display "dONE" on the SEV-SEG.*/
     IOWR_ALTERA_AVALON_PIO_DATA(SEG7_BASE,val0); 
     
    return 1;
    }
    else
    /* if all LEDS (ducks) are on .*/
        alt_u32 val=0xC7C09286; /* The game will stop and display "LOSE" on the SEV-SEG.*/
     IOWR_ALTERA_AVALON_PIO_DATA(SEG7_BASE,val); 
    return 1;
    }
    }
    return 0;
    
    }

  2. #2
    Registered User
    Join Date
    Mar 2013
    Posts
    2
    Any help would be appreciated !

  3. #3
    Registered User
    Join Date
    May 2010
    Posts
    2,919
    You have a program that is using many non-standard features so you will need to be patient.

    One question I have is how are you debouncing your switches?

    Jim

  4. #4
    and the hat of int overfl Salem's Avatar
    Join Date
    Aug 2001
    Location
    The edge of the known universe
    Posts
    32,854
    Well indenting the code properly would be a start.
    SourceForge.net: Indentation - cpwiki

    It's impossible to tell just by inspection exactly what the structure of the loop in main is.

    Line 223 won't even compile.

    How about producing a simpler test program which simply counts the number of times your switch changes state.
    This for example would allow you to answer Jim's debouncing question.
    If you dance barefoot on the broken glass of undefined behaviour, you've got to expect the occasional cut.
    If at first you don't succeed, try writing your phone number on the exam paper.
    I support http://www.ukip.org/ as the first necessary step to a free Europe.

  5. #5
    TEIAM - problem solved
    Join Date
    Apr 2012
    Location
    Melbourne Australia
    Posts
    1,501
    It sounds like a de-bouncing issue to me.
    Fact - Beethoven wrote his first symphony in C

Popular pages Recent additions subscribe to a feed

Similar Threads

  1. Display problem
    By Creatlv3 in forum C++ Programming
    Replies: 1
    Last Post: 05-08-2010, 01:28 AM
  2. 7 segment display through C
    By rags123 in forum Networking/Device Communication
    Replies: 0
    Last Post: 03-29-2010, 10:45 PM
  3. Seven Segment Display???
    By John_L in forum C Programming
    Replies: 5
    Last Post: 10-02-2007, 10:55 AM
  4. Display problem
    By crzy1 in forum C++ Programming
    Replies: 2
    Last Post: 04-01-2003, 11:00 PM
  5. about scan 7-segment display via parallel port
    By mobdawg in forum C Programming
    Replies: 4
    Last Post: 09-11-2002, 07:11 AM

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21