/Users/erickgrant/Documents/Computer Programming/Software-Class/swe350MS/main.c

Go to the documentation of this file.

// ============================================================================
// The following code uses excerpts from Terasic Technologies Inc.
// These are used primarily for the LCD.
// Below is the copyright for their portion of code
//
// Copyright (c) 2013 by Terasic Technologies Inc.
// ============================================================================
//
// Permission:
//
//   Terasic grants permission to use and modify this code for use
//   in synthesis for all Terasic Development Boards and Altera Development 
//   Kits made by Terasic.  Other use of this code, including the selling 
//   ,duplication, or modification of any portion is strictly prohibited.
//
// Disclaimer:
//
//   This VHDL/Verilog or C/C++ source code is intended as a design reference
//   which illustrates how these types of functions can be implemented.
//   It is the user's responsibility to verify their design for
//   consistency and functionality through the use of formal
//   verification methods.  Terasic provides no warranty regarding the use 
//   or functionality of this code.
//
// ============================================================================
//           
//  Terasic Technologies Inc
//  9F., No.176, Sec.2, Gongdao 5th Rd, East Dist, Hsinchu City, 30070. Taiwan
//  
//  
//                     web: http://www.terasic.com/  
//                     email: support@terasic.com
//
// ============================================================================
 
// Standard Libraries
// User defined libraries
#include "LCD/terasic_os_includes.h"
#include "LCD/LCD_Lib.h"
#include "LCD/lcd_graphic.h"
#include "LCD/font.h"
// Random Key Generator
#include "randomKey/randomKey.h"
//#include "pushbutton/pushbutton_irq_handler.h"
#include "address_map_arm.h"
// Increment LEDS (for seconds remaining)
#include "HPS-incrementLEDS/increment_leds/increment_leds.h"
 
// 7-segment displays
#include "7-segment/7seg.h"
 
// QR Code
// #include "qr_code/qrcode.h"
#include  "QRCode/src/qrcode.h"
 
#include <stdio.h>
#include "TOTP-MCU-master/TOTP.h"
#include <time.h>
 
#include <stdint.h>
#include <string.h>
 
 
 
//#include "pushbutton/pushbutton_irq_handler.h"
#include "address_map_arm.h"
 
 
 
 
// Define register locations for the DE-10 Standard Board
 
    #define HW_REGS_BASE ( ALT_STM_OFST )
    #define HW_REGS_SPAN ( 0x04000000 )
    #define HW_REGS_MASK ( HW_REGS_SPAN - 1 )
 
// 7-segment lights
    #define HEX3_HEX0_BASE         0x00000020 // 3,4,5,6
 
    #define HEX5_HEX4_BASE         0x00000030 // 1, 2
 
 
 
// uint8_t* decoded_array; // Will be used to hold the key
 
//  \brief Holds the clone of the key in uint8_t format
//
//  The key is cloned to prevent issues with key regeneration,
//  stores about 20 bytes for a standard 32-bit key.
//*/
//uint8_t* clonedArray;     // Clones the decoded array
char knownKey[32];      // Holds the random key
size_t output_len;      // Size of decoded array
 
// General setup, including LCD
void *virtual_base;
volatile int *HEX_ptr; // virtual address pointer to the HEX displays (7-seg)
volatile int *HEX45_ptr; // virtual address pointer to the HEX 45 displays (7-seg)
 
int fd = -1;               // used to open /dev/mem for access to physical addresses
void *LW_virtual;          // used to map physical addresses for the light-weight bridge
 
 
// Reset Button
// Define the button address
//#define BUTTON_ADDR 0x00000050 // WILL BE DEVELOPED IN A FUTURE VERSION
volatile int *KEY_ptr;     // virtual address for the KEY port
 
time_t seconds; // Time in seconds from epoch
 
LCD_CANVAS LcdCanvas; // Create canvas object
 
// Display Key (QR Code)
QRCode qrcode;
 
 
char codeStr[6]; // Character array for the code
 
int secondsRemaining = 0; // Prep the time remaining
 
uint32_t newCode;
 
 
 
 
 
// Unit Testing
void runTests() {
    test7Segment2(); // 7 segment Unit Tests
     testRandomKey();
}
 
 
/* GPIO Bit Structure, 6 nibbles (or 24 bits) are tied to Hex 0- Hex 5 BCD Decoders inputs */
typedef struct
{
    unsigned int gpio0 : 4; // lsb
    unsigned int gpio1 : 4;
    unsigned int gpio2 : 4;
    unsigned int gpio3 : 4;
    unsigned int gpio4 : 4;
    unsigned int gpio5 : 4;
    unsigned int gpiou : 11;    // msb
}GpioRegister;
GpioRegister* gpioRegister;
 
volatile unsigned int *JP1_ptr; // Virtual address pointer to JP1 Expansion Port
 
void displayCode(int x) {
    int og = x;
    int b1 = (x % 10);
    x = x / 10;
    int b2 = (x % 10);
    x = x / 10;
    int b3 = (x % 10);
    x = x / 10;
    int b4 = (x % 10);
    x = x / 10;
    int b5 = (x % 10);
    x = x / 10;
    int b6 = (x % 10);
 
    gpioRegister->gpio0 = b1;
    gpioRegister->gpio1 = b2;
    gpioRegister->gpio2 = b3;
    gpioRegister->gpio3 = b4;
    gpioRegister->gpio4 = b5;
    gpioRegister->gpio5 = b6;
    printf("Wrote value of %d\r\n", og);
 
}
 
int main() {
 
 
    runTests(); // Runs Unit Testing before running rest of project.
 
    // Generate initial key, at launch
    generateStringKey(knownKey,32); // todo: may generate a 134 exit code
 
    // printf("Redo of known key: %s\n",knownKey);
    char totpSetupURIinit[100] = "otpauth://totp/EG:MS?secret=";
 
    // Copy the key to the setup URI
    strcat(totpSetupURIinit, knownKey);
    // Print the key to the console
    printf("Setup key: %s\n", totpSetupURIinit);
    // Base32 encoded string
    const char* input = knownKey;
    // Length of the key in bytes (typically 20)
    size_t output_len;
    // Key for the TOTP generator
    uint8_t* decoded_array = base32_decode2(input, &output_len);
 
    // Define the TOTP key, 20 for the uin8_t key (20 bytes), 30 seconds for period between codes.
    TOTP(decoded_array, 20, 30); // Third arg should be 30 for 30 seconds // Set the data for the TOTP
 
    setTimezone(-7); // Arizona for timezone // leave this on
    // Begin Showing to user
 
 
// Code from Terasic
       // Create virtual memory access to the FPGA light-weight bridge
       if ((fd = open_physical (fd)) == -1)
          return (-1);
       if ((LW_virtual = map_physical (fd, LW_BRIDGE_BASE, LW_BRIDGE_SPAN)) == NULL)
          return (-1);
        JP1_ptr = (unsigned int *) (LW_virtual + JP1_BASE);
    *(JP1_ptr + 1) = 0x00FFFFFF;
    gpioRegister = (GpioRegister*) (JP1_ptr + 0);
 
 
    // 7-segment displays creator
       // HEX_ptr = (unsigned int *) (LW_virtual + HEX3_HEX0_BASE);
       // HEX45_ptr = (unsigned int *) (LW_virtual + HEX5_HEX4_BASE);
 
     //  *LEDR_ptr = 0;
     //*HEX_ptr = 0;
       // *HEX45_ptr = 0;
// End code from Terasic
    // Buttons
    KEY_ptr = LW_virtual + KEY_BASE;    // init virtual address for KEY port
 
    // map the address space for the LED registers into user space so we can interact with them.
    // we'll actually map in the entire CSR span of the HPS since we want to access various registers within that span
    if( ( fd = open( "/dev/mem", ( O_RDWR | O_SYNC ) ) ) == -1 ) {
        printf( "ERROR: could not open \"/dev/mem\"...\n" );
        return( 1 );
    }
 
    virtual_base = mmap( NULL, HW_REGS_SPAN, ( PROT_READ | PROT_WRITE ), MAP_SHARED, fd, HW_REGS_BASE );
 
    if( virtual_base == MAP_FAILED ) {
        printf( "ERROR: mmap() failed...\n" );
        close( fd );
        return( 1 );
    }
 
        
        LcdCanvas.Width = LCD_WIDTH;
        LcdCanvas.Height = LCD_HEIGHT;
        LcdCanvas.BitPerPixel = 1;
        LcdCanvas.FrameSize = LcdCanvas.Width * LcdCanvas.Height / 8;
        LcdCanvas.pFrame = (void *)malloc(LcdCanvas.FrameSize);
        
    if (LcdCanvas.pFrame == NULL){
            printf("failed to allocate lcd frame buffer\r\n");
    }else{          
        
    
        LCDHW_Init(virtual_base);
 
        // turn on LCD backlight
        LCDHW_BackLight(true);
 
    // Output to display
    LCD_Init();
   
    // clear screen
    DRAW_Clear(&LcdCanvas, LCD_WHITE);
 
        //strcat(totpSetupURIinit, knownKey); // Copy the key to the setup URI
 
        // Print the setup URI (contents of QR code) to the console
        printf("Key URI: %s\n", totpSetupURIinit);
 
 
        // Allocate a chunk of memory to store the QR code
        uint8_t qrcodeBytes[qrcode_getBufferSize(11)];
 
        // Generate QR code
        qrcode_initText(&qrcode, qrcodeBytes, 11, ECC_LOW, totpSetupURIinit);
 
 
 
        // Print QR Code welcome
          DRAW_Clear(&LcdCanvas, LCD_WHITE); // Clear LCD
          DRAW_PrintString(&LcdCanvas, 60, 30, "Scan the", LCD_BLACK, &font_16x16);
          DRAW_PrintString(&LcdCanvas, 65, 40, "Key", LCD_BLACK, &font_16x16);
        // Output the QR code
          DRAW_Refresh(&LcdCanvas);
 
           // Print QR Code
        for (int y = 0; y < qrcode.size; y++) {
            for (int x = 0; x < qrcode.size; x++) {
                if (qrcode_getModule(&qrcode, x, y)) {
                    //Serial.print("**");
                        DRAW_Pixel(&LcdCanvas,x,y,1);
                } else {
 
                }
            }
        }
        // Refresh display with new QR code
        DRAW_Refresh(&LcdCanvas);
 
 
        // Update the current time for initial run
        // Current seconds from epoch
        seconds = time(NULL);
        // Get current time code
         newCode = getCodeFromTimestamp(seconds);
        // Output the code to the console
        printf("\nThe init Code is: %d\n", newCode);
        // Pointers for hex displays
        // Output to the last four 7-segment displays
       //*HEX_ptr = dectodec7(newCode);
        // Output to the first two 7-segment displays
      // *HEX45_ptr = leftDec2Dec7(newCode);
        displayCode(newCode);
 
// Output the current code
        // infinite loop
        for (;;) {
            // set seconds to current
            seconds = time(NULL);
            snprintf(codeStr, sizeof(codeStr), "%6d", newCode); // Character array, copy newcode (int) into the codeStr as string,
 
            // Runs every 30 seconds
            if (seconds % 30 == 0 ) {
                newCode = getCodeFromTimestamp(seconds); // Update the code in uint8_t
                printf("The code in dec form: %d", newCode);
 
                // Output to 7-segment displays
               //    *HEX_ptr = dectodec7(newCode); // Output to the 3-6 7-segment displays
                 //  *HEX45_ptr = leftDec2Dec7(newCode); // Control left 2 digits of the 7-segment displays.
                displayCode(newCode);
                snprintf(codeStr, sizeof(codeStr), "%6d", newCode); // Convert the int into a character array of the pin
                printf("The Code is: %s\n",codeStr); // print the code to the console
 
                sleep(1); // Prevent duplication, wait one second between runs
            } else
            {
                // Update the clock on the 7-segment display
                secondsRemaining = 30 - (seconds % 30); // calculate the time remaining as int.
                increment_leds(secondsRemaining); // Output to the 10 lights
            }
 
        }
 
    }    
  unmap_physical(LW_virtual, LW_BRIDGE_SPAN);
    close_physical(fd);
    return 0;
    // // clean up  memory mapping and exit
    // if( munmap( virtual_base, HW_REGS_SPAN ) != 0 ) {
    //  printf( "ERROR: munmap() failed...\n" );
    //  close( fd );
    //  return( 1 );
    // }
    // close( fd );
    //
    // // end
    // return( 0 );
}