7seg.c

Go to the documentation of this file.

//
// Created by Erick Grant on 10/27/24.
//
 
#include "7seg.h"
 
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <tgmath.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 )
int fd = -1;               // used to open /dev/mem for access to physical addresses
// General setup, including LCD
void *virtual_base;
void *LW_virtual;          // used to map physical addresses for the light-weight bridge
 
int setup() {
 
 
 
 
 
long long decimalValue;
 
 
 
 
// Partial ChatGPT used Nov 30 2024
static const char *digitChar(char A) {
 
    // 0: 00111111
    // 1: 00000110
    // 2: 01011011
    // 3: 01001111
    // 4: 01100110
    // 5: 01101101
    // 6: 01111101
    // 7: 00000111
    // 8: 01111111
    // 9: 01101111
 
        switch (A) {
            case '0':
                return "00111111";
            case '1':
                return "00000110";
            case '2':
                return "01011011";
            case '3':
                return "01001111";
            case '4':
                return "01100110";
            case '5':
                return "01101101";
            case '6':
                return "01111101";
            case '7':
                return "00000111";
            case '8':
                return "01111111";
            case '9':
                return "01101111";
}
        return "X";
}
 
 
// Documentation provided by ChatGPT November 30, 2024
static char *dectobcd7bin(char * buf, int ABCD) {
 
    char inputChar[7];
 
    char outputChar[50] = "";
 
    // Check if the input number exceeds 6 digits
    if (ABCD > 999999) {
          printf("ABCD > 999999\n ERROR");
 
        return "FAILURE";
 
    }
 
    sprintf(inputChar, "%06d", ABCD);   // Convert the integer to a zero-padded 6-character string
    // printf("The char input is %s\n", inputChar);
 
    // Loop through each character in the input string
    for (int i = 0; i < 6; i++) {
        strcat(outputChar, digitChar(inputChar[i]));  // Append the 7-segment binary representation of each digit to outputChar
    }
    // Copy the final concatenated string into the provided buffer
    strncpy(buf, outputChar, 50);
    return buf;
 
}
 
long long dectodec7(int ABCD) {
    char outputChar[50] = "";
    //char array[50]; // Define an array to house the display
 
    memset(outputChar, 0, 50); /* All bytes are set to '\0' */
    if ((ABCD > 999999) || (ABCD < 0)) {
 
      printf("FAILURE, input ABCD n dectodec7 is greater than 999999");
    }
    const char* binaryOutput = dectobcd7bin(outputChar, ABCD);
 
 
    // const char* binaryOutput = dectobcd7bin(564522);
  //  printf("The output %s\n",binaryOutput);
    decimalValue = strtoll(binaryOutput, NULL, 2);
 
 
  // printf("The decimal value for %d is in bigInt: %lld\n", ABCD, decimalValue);
 
    return decimalValue;
}
 
long long leftDec2Dec7(int ABCD) {
    char arrayLeft[17]; // Space for two numbers in binary
    char arrayLeftTotal[50];
        memset(arrayLeftTotal, 0, 50); /* All bytes are set to '\0' */
        const char* binaryOutput2 = dectobcd7bin(arrayLeftTotal, ABCD); // Fill up the binaryOutput2 with the left binary
 
 
    strncpy (arrayLeft, binaryOutput2, 16); // Copy the binaryOutput2 into arrayLeft
    //printf("%s\n", arrayLeft);
 
    decimalValue = strtoll(arrayLeft, NULL, 2); // Convert the binary into a decimal
    //printf("The decimal value for LEFT %d is in bigInt: %lld\n", ABCD, decimalValueLeft);
 
    return decimalValue;
 
 
}
 
 
// Testing
#include <assert.h> // Testing
 
 
// Most of the test cases were generated with some use of AI, using ChatGPT.
void test7segDigitChar() {
  // digitChars
    // Valid input tests
    assert(digitChar('0') == "00111111");
    assert(digitChar('1') == "00000110");
    assert(digitChar('2') == "01011011");
    assert(digitChar('3') == "01001111");
    assert(digitChar('4') == "01100110");
    assert(digitChar('5') == "01101101");
    assert(digitChar('6') == "01111101");
    assert(digitChar('7') == "00000111");
    assert(digitChar('8') == "01111111");
    assert(digitChar('9') == "01101111");
 
    // Invalid input tests
    assert(digitChar('a') == "X");
    assert(digitChar('#') == "X");
    assert(digitChar(' ') == "X");
    assert(digitChar('\n') == "X");
    assert(digitChar('-') == "X");
 
    // Testing input boundaries
    assert(digitChar('9') == "01101111");
    assert(digitChar('9' + 1) == "X");
 
  //  printf("All test cases for digitChar within 7-segment passed!\n");
 
}
 
void testDectobcd7bin() {
    char buffer[50];
 
    // using test cases from chatgpt Nov 15, 2024, used the associated method as input.
    // Test Case 1: Maximum valid input
    assert(strcmp(dectobcd7bin(buffer, 999999), "011011110110111101101111011011110110111101101111") == 0);
 
    // Test Case 2: Boundary condition (greater than 1,000,000)
     assert(strcmp(dectobcd7bin(buffer, 1000000), "FAILURE") == 0);
 
    // Test Case 3: Smallest valid input
 
    assert(strcmp(dectobcd7bin(buffer, 0), "001111110011111100111111001111110011111100111111") == 0);
 
    // Test Case 4: Typical input in range
    assert(strcmp(dectobcd7bin(buffer, 123456), "000001100101101101001111011001100110110101111101") == 0);
 
    // Test Case 5: Input with repeating digits
    assert(strcmp(dectobcd7bin(buffer, 888888), "011111110111111101111111011111110111111101111111") == 0);
 
    // Test Case 6: Input greater than 1,000,000
    assert(strcmp(dectobcd7bin(buffer, 1000001), "FAILURE") == 0);
 
    // Test Case 7: Single-digit number padded with zeros
    assert(strcmp(dectobcd7bin(buffer, 5), "001111110011111100111111001111110011111101101101") == 0);
 
   // printf("All test cases passed for the Decimal to BCD 7-segment\n");
 
  }
 
  // The numbers were generated without AI, and were created from a binary to decimal website
  void testDectoDec7() {
    // Test Case 1: Convert 0 to its binary representation and then to decimal
   // assert(dectodec7(0) == 6860473343); 17802464409370431
    assert(dectodec7(0) == 69540876599103);
    // Binary: "001111110011111100111111001111110011111100111111"
 
    // Test Case 2: Convert 123456 to its binary representation and then to decimal
    assert(dectodec7(123456) == 6989243903357);
    // Binary: "000001100101101101001111011001100110110101111101"
 
    // Test Case 3: Convert the maximum 6-digit value (999999)
    assert(dectodec7(999999) == 122524401626991);
    // Binary: "011011110110111101101111011011110110111101101111"
 
    // Test Case 4: Convert a number with repeating digits (111111)
    assert(dectodec7(111111) == 6622940628486);
    // Binary: "000001100000011000000110000001100000011000000110"
 
    // Test Case 5: Convert a single-digit number padded with zeros (5)
    assert(dectodec7(5) == 69540876599149);
    // Binary: "00111111001111110011111100111111001101101011101"
 
    // Test Case 6: Boundary value test (smallest 6-digit number)
    assert(dectodec7(100000) == 6868713815871);
 
    // Test Case 7: Random number for typical input testing
    assert(dectodec7(359977) == 87331439576839);
  //  printf("All test cases passed successfully within testDectoDec7!\n");
 
    }
 
 void testLeftDec2Dec7() {
 
    // Test Case 1: Convert 0 to binary and extract the first 16 bits
    assert(leftDec2Dec7(0) == 16191); // "0011111100111111"
 
    // Test Case 2: Convert 123456 and extract the first 16 bits
    assert(leftDec2Dec7(123456) == 1627); // "1111011010011101"
 
    // Test Case 3: Convert 999999 and extract the first 16 bits
    assert(leftDec2Dec7(999999) == 28527); // "0110111101101111"
 
    // Test Case 4: Convert a single-digit number padded with zeros
    assert(leftDec2Dec7(5) == 16191); // "0011111100111111"
 
    // Test Case 5: Convert 100010 and extract the first 16 bits
    assert(leftDec2Dec7(100010) == 1599); // "0101100110010010"
 
    // Test Case 6: Edge case - 111111 (first 16-bits of the sequence)
    assert(leftDec2Dec7(111111) == 1542); // Custom validation
 
  //  printf("All test cases passed successfully within testLeftDec2Dec7!\n");
 }
 
 int test7Segment2()
     {
    test7segDigitChar();
    testDectobcd7bin();
    testDectoDec7();
    testLeftDec2Dec7();
    printf("All test cases passed successfully within 7-segment\n");
    return 1;
   }