/** 
* @file main.c
*
* @brief Addressing multiple BeagleBone GPIO pins in C
* @details Self-contined program that will turn ON/OFF a specified group of
* of GPIO pins in the beaglebone board. This code was possible due to prior 
* efforts by Christian Mitchell, Markus Klink and Matt Richardson. To compile
* and run this code, type something like "gcc main.c ; ./a.out ;  rm -f a.out"
*
* @author Nuno Alves
* @date 17/March/2012 
**/

#include <stdio.h> 
#include <stdlib.h> 
#include <unistd.h> 
#include <string.h> 
#include <assert.h>
#include <time.h>

//If DEBUG is defined to TRUE (1), intermediate debug messages will be displayed 
//when code is executing. You may set it to FALSE (0) for no debug information.
#define DEBUG 0

//The following #defines make it easier for the user to add differnt pins
#define P00 0
#define P01 1
#define P02 2
#define P03 3
#define P04 4
#define P05 5
#define P06 6
#define P07 7

/** @brief Contains all elements which we need to pass into the beagleboard 
* to specify which GPIO pin we want to turn ON/OFF **/ 
struct gpioID{
    char *PINNAME;  //e.g: P07
    char * GPIOID;  //e.g: gpio0[30] 
    int GPIONUMBER; //e.g: 30
    char *GPIOMUX;  //e.g: gpmc_wait0; 
};

/** 
* @brief Writes a value to a particular GPIO, logic-HIGH or logic-LOW.
* @param GPIONUMBER The GPIO number (e.g. 38 for gpio1[6])
* @param value The logic value we want to write to the GPIO (0 or 1)
**/ 
void write_GPIO_value(int GPIONUMBER, int value){
    char export_filename[50]; 
    FILE *f = NULL; 
    
    sprintf(export_filename, "/sys/class/gpio/gpio%d/value",GPIONUMBER); 
    f = fopen(export_filename,"w");
    assert(f!=NULL);    
    fprintf(f , "%d",value); 
    pclose(f); 
}

/** 
* @brief Tells the OS that we are done with using GPIOs
* @param selected_GPIOs[] initialized array of gpioID.
* @param selectedPins[] Array with the user specified pins
* @param sizeof_selectedPins Number of pins that were specified by the user
**/ 
void cleanup_GPIO(struct gpioID selected_GPIOs[],int selectedPins[], 
												int nbr_selectedPins){
    char export_filename[50]; 
    FILE *f = NULL; 
    int i;
    
    for (i=0; i<nbr_selectedPins;i++)    {
        //unexport the pin
        f = fopen("/sys/class/gpio/unexport","w");
        assert(f!=NULL);   
        fprintf(f, "%d",selected_GPIOs[i].GPIONUMBER); 
        pclose(f);       
    }
}

/** 
* @brief Initializes all the user specified pins  
* @param selected_GPIOs[] Un-initialized array of gpioID. At the end of this 
* function, the selected_GPIOs[] array will be initialized.
* @param selectedPins[] Array with the user specified pins
* @param sizeof_selectedPins Number of pins that were specified by the user
**/ 
void initialize_each_enabled_gpio(struct gpioID selected_GPIOs[],
							int selectedPins[], int nbr_selectedPins){
    int i;
    //this variable will contain the location of the file that we need to 
    //set to mode 7
    char export_filename[50]; 

    FILE *f = NULL; 
    //You are not allowed to use more than 32 active pins. This is not a 
    //beagleboard limitation, but a limitation of this code.
    assert (nbr_selectedPins<=32);
    
    //cycles every userdefined pin, and inializes its contents in the 
    //selected_GPIOs[] array.
    for (i=0; i<nbr_selectedPins;i++){
        switch (selectedPins[i]){
            case P00:
                selected_GPIOs[i].PINNAME="P00";
                selected_GPIOs[i].GPIOID="gpio0[5]";
                selected_GPIOs[i].GPIONUMBER=5;
                selected_GPIOs[i].GPIOMUX="spi0_cs0";
                break;

            case P01:
                selected_GPIOs[i].PINNAME="P01";
                selected_GPIOs[i].GPIOID="gpio0[4]";
                selected_GPIOs[i].GPIONUMBER=4;
                selected_GPIOs[i].GPIOMUX="spi0_d1";
                break;

            case P02:
                selected_GPIOs[i].PINNAME="P02";
                selected_GPIOs[i].GPIOID="gpio0[13]";
                selected_GPIOs[i].GPIONUMBER=13;
                selected_GPIOs[i].GPIOMUX="uart1_rtsn";
                break;

            case P03:
                selected_GPIOs[i].PINNAME="P03";
                selected_GPIOs[i].GPIOID="gpio0[12]";
                selected_GPIOs[i].GPIONUMBER=12;
                selected_GPIOs[i].GPIOMUX="uart1_ctsn";
                break;

            case P04:
                selected_GPIOs[i].PINNAME="P04";
                selected_GPIOs[i].GPIOID="gpio0[7]";
                selected_GPIOs[i].GPIONUMBER=7;
                selected_GPIOs[i].GPIOMUX="ecap0_in_pwm0_out";
                break;

             case P05:
                selected_GPIOs[i].PINNAME="P05";
                selected_GPIOs[i].GPIOID="gpio0[20]";
                selected_GPIOs[i].GPIONUMBER=20;
                selected_GPIOs[i].GPIOMUX="xdma_event_intr1";
                break;

            case P06:
                selected_GPIOs[i].PINNAME="P06";
                selected_GPIOs[i].GPIOID="gpio0[31]";
                selected_GPIOs[i].GPIONUMBER=31;
                selected_GPIOs[i].GPIOMUX="gpmc_wpn";
                break;

            case P07:
                selected_GPIOs[i].PINNAME="P07";
                selected_GPIOs[i].GPIOID="gpio0[30]";
                selected_GPIOs[i].GPIONUMBER=30;
                selected_GPIOs[i].GPIOMUX="gpmc_wait0";
                break;

           default:
                //This statement should never be reached... since
                //the program won't even compile if the user 
                //specified a bad pin specification.
                break;
        }
    }
    
    //set the each mux pin to mode 7
    for (i=0; i<nbr_selectedPins;i++)
    {
        //set mux to mode 7 
        sprintf(export_filename, "/sys/kernel/debug/omap_mux/%s", selected_GPIOs[i].GPIOMUX); 
        f = fopen(export_filename,"w");
      
        if (f == NULL){
            printf( "\nERROR: There was a problem opening /sys/kernel/debug/omap_mux/%s\n", selected_GPIOs[i].GPIOMUX); 
            printf("\n%s\t%s\t%s\t%d\n\n", selected_GPIOs[i].PINNAME, selected_GPIOs[i].GPIOID, selected_GPIOs[i].GPIOMUX, selected_GPIOs[i].GPIONUMBER);
            assert(f!=NULL);
        } 
        fprintf(f, "7"); 
        pclose(f); 

        //export the pin
        f = fopen("/sys/class/gpio/export","w");
      
        if (f == NULL){
            printf( "\nERROR: There was a problem opening /sys/kernel/debug/omap_mux/%s\n", selected_GPIOs[i].GPIOMUX); 
            printf("\n%s\t%s\t%s\t%d\n\n", selected_GPIOs[i].PINNAME,selected_GPIOs[i].GPIOID,selected_GPIOs[i].GPIOMUX,selected_GPIOs[i].GPIONUMBER);

            assert(f!=NULL);
        } 
        fprintf(f, "%d",selected_GPIOs[i].GPIONUMBER); 
        pclose(f); 
        
        //set the appropriate io direction (out)
        sprintf(export_filename, "/sys/class/gpio/gpio%d/direction", selected_GPIOs[i].GPIONUMBER); 
        f = fopen(export_filename,"w");
      
        if (f == NULL){
            printf( "\nERROR: There was a problem opening /sys/class/gpio/gpio%d/direction\n", selected_GPIOs[i].GPIONUMBER); 
            printf("\n%s\t%s\t%s\t%d\n\n",selected_GPIOs[i].PINNAME,selected_GPIOs[i].GPIOID,selected_GPIOs[i].GPIOMUX,selected_GPIOs[i].GPIONUMBER);
            assert(f!=NULL);
        } 
        fprintf(f , "out" ); 
        pclose(f); 
        
        write_GPIO_value(selected_GPIOs[i].GPIONUMBER,0);
    }
}


/** 
* @brief Displays all information for each of the user specified pins. 
* This function has no purpose besides live debugging.
* @param selected_GPIOs[] An valid (initialized) array of gpioID
* @param nbr_selectedPins Number of pins that were specified by the user
**/ 
void display_each_enabled_gpio(struct gpioID selected_GPIOs[],int nbr_selectedPins)
{
    int i;
    printf("\n");
    printf("PINNAME\tGPIOID\t\tGPIOMUX\t\tGPIONBR\n");
    printf("++++++++++++++++++++++++++++++++++++++++++++++++\n");

    for (i=0; i< nbr_selectedPins; i++){
        printf("%s\t%s\t%s\t%d\n",selected_GPIOs[i].PINNAME,selected_GPIOs[i].GPIOID,selected_GPIOs[i].GPIOMUX,selected_GPIOs[i].GPIONUMBER);
    }
    printf("\n");
}

/** 
* @brief Cycles through the entire array of selected_GPIOs[] and turns ON/OFF
* each associated GPIO.
* @param selected_GPIOs[] An valid (initialized) array of gpioID
* @param data_to_write An unsigned integer (32 bits), where each bit contains the 
* information regarding the status of each pin: 1=turn pin ON, 0=turn pin OFF
* @param nbr_selectedPins Number of pins that were specified by the user
**/ 
void turn_ON_OFF_pins(struct gpioID selected_GPIOs[],unsigned int data_to_write,int nbr_selectedPins)
{
    int i;
    
    for (i=0;i<nbr_selectedPins;i++){
        //code that turns ON/OFF a pin
        write_GPIO_value(selected_GPIOs[i].GPIONUMBER,bitRead(data_to_write,i));

        //this is just for debugging purposes
        if (DEBUG){ 
            if (bitRead(data_to_write,i) == 1) 
				printf("turning ON");    
            else 
				printf("turning OFF");    
            printf("\t%s (%s %d %s)\n",selected_GPIOs[i].PINNAME,selected_GPIOs[i].GPIOID,selected_GPIOs[i].GPIONUMBER,selected_GPIOs[i].GPIOMUX);                
        }
    }
    if (DEBUG) 
		printf("\n");
}

/** 
* @brief Writes a bit into a particular location in an unsigned int variable (32 bits)
* @param groupOfBits Some data resides in these 32 bits 
* @param bitVal The bitVal is wither a 1 or a 0
* @param bitLoc Where in the groupOfBits, the value of bitVal will be written. 
* Keep in mind that the bitLoc values ranges 0 to 31
* @return Returns the updated groupOfBits
**/ 
unsigned int bitWrite(unsigned int groupOfBits, int bitVal, int bitLoc){
    if (bitVal==1) 
		groupOfBits |= 1 << bitLoc;
    else 
		groupOfBits &= ~(1 << bitLoc);     
    return(groupOfBits);
}

/** 
* @brief Returns the bit value of a particular location in an unsigned int variable (32 bits)
* @param groupOfBits Some data resides in these 32 bits 
* @param bitLoc Where in the groupOfBits, the value of bitVal will be written 
* @return Retuns an integer with the bit value (1 or 0) that resides in bitLoc
**/ 
int bitRead(unsigned int groupOfBits, int bitLoc)
{
    unsigned int bit = groupOfBits & (1 << bitLoc);
    if (bit!=0) bit=1;

    return(bit);
}

void vDelay(int ms){
	usleep(ms*1000);
}

/** 
* @brief This is the main function with a sample test program.
* @return Returns a 1 upon succesful program termination
**/ 
int main(){
    int selectedPins[]={P00,P01,P02,P03,P04,P05,P06,P07};
    int nbr_selectedPins=sizeof(selectedPins)/sizeof(*selectedPins);

    //This variable data_to_write will contain the information which specified
    //the pins that will be ON or OFF
    unsigned int data_to_write=1;
    
    //Define an array of gpios which will contain all the user selected pins and
    //its associated information
    struct gpioID enabled_gpio[nbr_selectedPins];

    //Initializes all user defined pins
    initialize_each_enabled_gpio(enabled_gpio,selectedPins,nbr_selectedPins);
    if (DEBUG) 
		display_each_enabled_gpio(enabled_gpio,nbr_selectedPins);
      
    for(data_to_write=0x1; data_to_write <= 0x80 ; data_to_write <<=1){
		turn_ON_OFF_pins(enabled_gpio,data_to_write,nbr_selectedPins);
		vDelay(150); 
	}
    for(data_to_write=0x40; data_to_write >= 0x01 ; data_to_write >>=1){
		turn_ON_OFF_pins(enabled_gpio,data_to_write,nbr_selectedPins);
		vDelay(150); 
	}
    //we should now tell the OS that we are done with the GPIOs
    cleanup_GPIO(enabled_gpio,selectedPins,nbr_selectedPins);
    
    return 0;
}