API tools faq
paste
Advertisement
crummy

Gate driver, project part 2

crummy
May 10th, 2011
97
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 12.41 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. #   4/20/2011
  3. #   Logic Gate Driver
  4. #   Malcolm Crum
  5. #   Tests each logic gate
  6. */
  7.  
  8. #include <stdio.h>
  9. #include <stdlib.h>
  10. #include "gates.h"
  11. #include "registers.h"
  12.  
  13. int main(void) {
  14.     printf("---\n");
  15.     printf("Gates, Mux, Register, Adder Driver\n");
  16.     printf("---\n");
  17.  
  18.     if (testGates() == 1)
  19.         printf("Gates checked out OK.\n");
  20.     else
  21.         printf("Gates failed!\n");
  22.        
  23.     if (testMuxes() == 1)
  24.         printf("Muxes checked out OK.\n");
  25.     else
  26.         printf("Muxes failed!\n");
  27.        
  28.     if (testRegisters() == 1)
  29.         printf("Registers checked out OK.\n");
  30.     else
  31.         printf("Registers failed!\n");
  32.        
  33.     if (testAdders() == 1)
  34.         printf("Adders checked out OK.\n");
  35.     else
  36.         printf("Adders failed!\n");
  37. }
  38.  
  39. int testGates() {
  40.     int success = 1;
  41.    
  42.     char A[32] = "10101010101010101010101010101010";
  43.     char B[32] = "11001100110011001100110011001100";
  44.     char C[32] = "00000000000000000000000000000000";
  45.     char D[32] = "10101010101010101010101010101010";
  46.     char E[32] = "11001100110011001100110011001100";
  47.     char F[32] = "00000000000000000000000000000000";
  48.    
  49.     C[0] = NOT1_1(A[0]);
  50.     C[1] = NOT1_1(A[1]);
  51.     C[2] = NOT1_1(A[2]);
  52.     C[3] = NOT1_1(A[3]);
  53.     C[4] = NOT1_1(A[4]);
  54.     C[5] = NOT1_1(A[5]);
  55.     C[6] = NOT1_1(A[6]);
  56.     C[7] = NOT1_1(A[7]);
  57.     C[8] = NOT1_1(A[8]);
  58.     C[9] = NOT1_1(A[9]);
  59.     C[10] = NOT1_1(A[10]);
  60.     C[11] = NOT1_1(A[11]);
  61.     C[12] = NOT1_1(A[12]);
  62.     C[13] = NOT1_1(A[13]);
  63.     C[14] = NOT1_1(A[14]);
  64.     C[15] = NOT1_1(A[15]);
  65.     C[16] = NOT1_1(A[16]);
  66.     C[17] = NOT1_1(A[17]);
  67.     C[18] = NOT1_1(A[18]);
  68.     C[19] = NOT1_1(A[19]);
  69.     C[20] = NOT1_1(A[20]);
  70.     C[21] = NOT1_1(A[21]);
  71.     C[22] = NOT1_1(A[22]);
  72.     C[23] = NOT1_1(A[23]);
  73.     C[24] = NOT1_1(A[24]);
  74.     C[25] = NOT1_1(A[25]);
  75.     C[26] = NOT1_1(A[26]);
  76.     C[27] = NOT1_1(A[27]);
  77.     C[28] = NOT1_1(A[28]);
  78.     C[29] = NOT1_1(A[29]);
  79.     C[30] = NOT1_1(A[30]);
  80.     C[31] = NOT1_1(A[31]);
  81.     NOT1_32(F, D);
  82.     /*printf("\nC[0-31] = AND2_1(A[0-31], B[0-31])");
  83.     printf("\nA(%.32s) AND B(%.32s) =  C(%.32s)", A, B, C);
  84.     printf("\nAND2_32(F,D,E)  This result should match the one above.");
  85.     printf("\nD(%.32s) AND E(%.32s) =  F(%.32s) \n", D, E, F);*/
  86.     if (memcmp(C,F,32) != 0) {
  87.         printf("%.32s != %.32s (NOT)\n", C, F);
  88.         success = 0;
  89.     }
  90.    
  91.    
  92.     C[0] = AND2_1(A[0], B[0]);
  93.     C[1] = AND2_1(A[1], B[1]);
  94.     C[2] = AND2_1(A[2], B[2]);
  95.     C[3] = AND2_1(A[3], B[3]);
  96.     C[4] = AND2_1(A[4], B[4]);
  97.     C[5] = AND2_1(A[5], B[5]);
  98.     C[6] = AND2_1(A[6], B[6]);
  99.     C[7] = AND2_1(A[7], B[7]);
  100.     C[8] = AND2_1(A[8], B[8]);
  101.     C[9] = AND2_1(A[9], B[9]);
  102.     C[10] = AND2_1(A[10], B[10]);
  103.     C[11] = AND2_1(A[11], B[11]);
  104.     C[12] = AND2_1(A[12], B[12]);
  105.     C[13] = AND2_1(A[13], B[13]);
  106.     C[14] = AND2_1(A[14], B[14]);
  107.     C[15] = AND2_1(A[15], B[15]);
  108.     C[16] = AND2_1(A[16], B[16]);
  109.     C[17] = AND2_1(A[17], B[17]);
  110.     C[18] = AND2_1(A[18], B[18]);
  111.     C[19] = AND2_1(A[19], B[19]);
  112.     C[20] = AND2_1(A[20], B[20]);
  113.     C[21] = AND2_1(A[21], B[21]);
  114.     C[22] = AND2_1(A[22], B[22]);
  115.     C[23] = AND2_1(A[23], B[23]);
  116.     C[24] = AND2_1(A[24], B[24]);
  117.     C[25] = AND2_1(A[25], B[25]);
  118.     C[26] = AND2_1(A[26], B[26]);
  119.     C[27] = AND2_1(A[27], B[27]);
  120.     C[28] = AND2_1(A[28], B[28]);
  121.     C[29] = AND2_1(A[29], B[29]);
  122.     C[30] = AND2_1(A[30], B[30]);
  123.     C[31] = AND2_1(A[31], B[31]);
  124.     AND2_32(F, D, E);
  125.     /*printf("\nC[0-31] = AND2_1(A[0-31], B[0-31])");
  126.     printf("\nA(%.32s) AND B(%.32s) =  C(%.32s)", A, B, C);
  127.     printf("\nAND2_32(F,D,E)  This result should match the one above.");
  128.     printf("\nD(%.32s) AND E(%.32s) =  F(%.32s) \n", D, E, F);*/
  129.     if (memcmp(C,F,32) != 0) {
  130.         printf("%.32s != %.32s (AND)\n", C, F);
  131.         success = 0;
  132.     }
  133.    
  134.     C[0] = OR2_1(A[0], B[0]);
  135.     C[1] = OR2_1(A[1], B[1]);
  136.     C[2] = OR2_1(A[2], B[2]);
  137.     C[3] = OR2_1(A[3], B[3]);
  138.     C[4] = OR2_1(A[4], B[4]);
  139.     C[5] = OR2_1(A[5], B[5]);
  140.     C[6] = OR2_1(A[6], B[6]);
  141.     C[7] = OR2_1(A[7], B[7]);
  142.     C[8] = OR2_1(A[8], B[8]);
  143.     C[9] = OR2_1(A[9], B[9]);
  144.     C[10] = OR2_1(A[10], B[10]);
  145.     C[11] = OR2_1(A[11], B[11]);
  146.     C[12] = OR2_1(A[12], B[12]);
  147.     C[13] = OR2_1(A[13], B[13]);
  148.     C[14] = OR2_1(A[14], B[14]);
  149.     C[15] = OR2_1(A[15], B[15]);
  150.     C[16] = OR2_1(A[16], B[16]);
  151.     C[17] = OR2_1(A[17], B[17]);
  152.     C[18] = OR2_1(A[18], B[18]);
  153.     C[19] = OR2_1(A[19], B[19]);
  154.     C[20] = OR2_1(A[20], B[20]);
  155.     C[21] = OR2_1(A[21], B[21]);
  156.     C[22] = OR2_1(A[22], B[22]);
  157.     C[23] = OR2_1(A[23], B[23]);
  158.     C[24] = OR2_1(A[24], B[24]);
  159.     C[25] = OR2_1(A[25], B[25]);
  160.     C[26] = OR2_1(A[26], B[26]);
  161.     C[27] = OR2_1(A[27], B[27]);
  162.     C[28] = OR2_1(A[28], B[28]);
  163.     C[29] = OR2_1(A[29], B[29]);
  164.     C[30] = OR2_1(A[30], B[30]);
  165.     C[31] = OR2_1(A[31], B[31]);
  166.     OR2_32(F, D, E);
  167.     /*printf("\nC[0-31] = OR2_1(A[0-31], B[0-31])");
  168.     printf("\nA(%.32s) OR B(%.32s) =  C(%.32s)", A, B, C);
  169.     printf("\nOR2_32(F,D,E)  This result should match the one above.");
  170.     printf("\nD(%.32s) OR E(%.32s) =  F(%.32s) \n", D, E, F);*/
  171.     if (memcmp(C,F,32) != 0) {
  172.         printf("%.32s != %.32s (OR)\n", C, F);
  173.         success = 0;
  174.     }
  175.        
  176.     C[0] = NAND2_1(A[0], B[0]);
  177.     C[1] = NAND2_1(A[1], B[1]);
  178.     C[2] = NAND2_1(A[2], B[2]);
  179.     C[3] = NAND2_1(A[3], B[3]);
  180.     C[4] = NAND2_1(A[4], B[4]);
  181.     C[5] = NAND2_1(A[5], B[5]);
  182.     C[6] = NAND2_1(A[6], B[6]);
  183.     C[7] = NAND2_1(A[7], B[7]);
  184.     C[8] = NAND2_1(A[8], B[8]);
  185.     C[9] = NAND2_1(A[9], B[9]);
  186.     C[10] = NAND2_1(A[10], B[10]);
  187.     C[11] = NAND2_1(A[11], B[11]);
  188.     C[12] = NAND2_1(A[12], B[12]);
  189.     C[13] = NAND2_1(A[13], B[13]);
  190.     C[14] = NAND2_1(A[14], B[14]);
  191.     C[15] = NAND2_1(A[15], B[15]);
  192.     C[16] = NAND2_1(A[16], B[16]);
  193.     C[17] = NAND2_1(A[17], B[17]);
  194.     C[18] = NAND2_1(A[18], B[18]);
  195.     C[19] = NAND2_1(A[19], B[19]);
  196.     C[20] = NAND2_1(A[20], B[20]);
  197.     C[21] = NAND2_1(A[21], B[21]);
  198.     C[22] = NAND2_1(A[22], B[22]);
  199.     C[23] = NAND2_1(A[23], B[23]);
  200.     C[24] = NAND2_1(A[24], B[24]);
  201.     C[25] = NAND2_1(A[25], B[25]);
  202.     C[26] = NAND2_1(A[26], B[26]);
  203.     C[27] = NAND2_1(A[27], B[27]);
  204.     C[28] = NAND2_1(A[28], B[28]);
  205.     C[29] = NAND2_1(A[29], B[29]);
  206.     C[30] = NAND2_1(A[30], B[30]);
  207.     C[31] = NAND2_1(A[31], B[31]);
  208.     NAND2_32(F, D, E);
  209.     /*printf("\nC[0-31] = NAND2_1(A[0-31], B[0-31])");
  210.     printf("\nA(%.32s) NAND B(%.32s) =  C(%.32s)", A, B, C);
  211.     printf("\nNAND2_32(F,D,E)  This result should match the one above.");
  212.     printf("\nD(%.32s) NAND E(%.32s) =  F(%.32s) \n", D, E, F);*/
  213.     if (memcmp(C,F,32) != 0) {
  214.         printf("%.32s != %.32s (NAND)\n", C, F);
  215.         success = 0;
  216.     }
  217.    
  218.     C[0] = XNOR2_1(A[0], B[0]);
  219.     C[1] = XNOR2_1(A[1], B[1]);
  220.     C[2] = XNOR2_1(A[2], B[2]);
  221.     C[3] = XNOR2_1(A[3], B[3]);
  222.     C[4] = XNOR2_1(A[4], B[4]);
  223.     C[5] = XNOR2_1(A[5], B[5]);
  224.     C[6] = XNOR2_1(A[6], B[6]);
  225.     C[7] = XNOR2_1(A[7], B[7]);
  226.     C[8] = XNOR2_1(A[8], B[8]);
  227.     C[9] = XNOR2_1(A[9], B[9]);
  228.     C[10] = XNOR2_1(A[10], B[10]);
  229.     C[11] = XNOR2_1(A[11], B[11]);
  230.     C[12] = XNOR2_1(A[12], B[12]);
  231.     C[13] = XNOR2_1(A[13], B[13]);
  232.     C[14] = XNOR2_1(A[14], B[14]);
  233.     C[15] = XNOR2_1(A[15], B[15]);
  234.     C[16] = XNOR2_1(A[16], B[16]);
  235.     C[17] = XNOR2_1(A[17], B[17]);
  236.     C[18] = XNOR2_1(A[18], B[18]);
  237.     C[19] = XNOR2_1(A[19], B[19]);
  238.     C[20] = XNOR2_1(A[20], B[20]);
  239.     C[21] = XNOR2_1(A[21], B[21]);
  240.     C[22] = XNOR2_1(A[22], B[22]);
  241.     C[23] = XNOR2_1(A[23], B[23]);
  242.     C[24] = XNOR2_1(A[24], B[24]);
  243.     C[25] = XNOR2_1(A[25], B[25]);
  244.     C[26] = XNOR2_1(A[26], B[26]);
  245.     C[27] = XNOR2_1(A[27], B[27]);
  246.     C[28] = XNOR2_1(A[28], B[28]);
  247.     C[29] = XNOR2_1(A[29], B[29]);
  248.     C[30] = XNOR2_1(A[30], B[30]);
  249.     C[31] = XNOR2_1(A[31], B[31]);
  250.     XNOR2_32(F, D, E);
  251.     /*printf("\nC[0-31] = XNOR2_1(A[0-31], B[0-31])");
  252.     printf("\nA(%.32s) XNOR B(%.32s) =  C(%.32s)", A, B, C);
  253.     printf("\nXNOR2_32(F,D,E)  This result should match the one above.");
  254.     printf("\nD(%.32s) XNOR E(%.32s) =  F(%.32s) \n", D, E, F);*/
  255.     if (memcmp(C,F,32) != 0) {
  256.         printf("%.32s != %.32s (XNOR)\n", C, F);
  257.         success = 0;
  258.     }
  259.    
  260.     C[0] = XOR2_1(A[0], B[0]);
  261.     C[1] = XOR2_1(A[1], B[1]);
  262.     C[2] = XOR2_1(A[2], B[2]);
  263.     C[3] = XOR2_1(A[3], B[3]);
  264.     C[4] = XOR2_1(A[4], B[4]);
  265.     C[5] = XOR2_1(A[5], B[5]);
  266.     C[6] = XOR2_1(A[6], B[6]);
  267.     C[7] = XOR2_1(A[7], B[7]);
  268.     C[8] = XOR2_1(A[8], B[8]);
  269.     C[9] = XOR2_1(A[9], B[9]);
  270.     C[10] = XOR2_1(A[10], B[10]);
  271.     C[11] = XOR2_1(A[11], B[11]);
  272.     C[12] = XOR2_1(A[12], B[12]);
  273.     C[13] = XOR2_1(A[13], B[13]);
  274.     C[14] = XOR2_1(A[14], B[14]);
  275.     C[15] = XOR2_1(A[15], B[15]);
  276.     C[16] = XOR2_1(A[16], B[16]);
  277.     C[17] = XOR2_1(A[17], B[17]);
  278.     C[18] = XOR2_1(A[18], B[18]);
  279.     C[19] = XOR2_1(A[19], B[19]);
  280.     C[20] = XOR2_1(A[20], B[20]);
  281.     C[21] = XOR2_1(A[21], B[21]);
  282.     C[22] = XOR2_1(A[22], B[22]);
  283.     C[23] = XOR2_1(A[23], B[23]);
  284.     C[24] = XOR2_1(A[24], B[24]);
  285.     C[25] = XOR2_1(A[25], B[25]);
  286.     C[26] = XOR2_1(A[26], B[26]);
  287.     C[27] = XOR2_1(A[27], B[27]);
  288.     C[28] = XOR2_1(A[28], B[28]);
  289.     C[29] = XOR2_1(A[29], B[29]);
  290.     C[30] = XOR2_1(A[30], B[30]);
  291.     C[31] = XOR2_1(A[31], B[31]);
  292.     XOR2_32(F, D, E);
  293.     /*printf("\nC[0-31] = XOR2_1(A[0-31], B[0-31])");
  294.     printf("\nA(%.32s) XOR B(%.32s) =  C(%.32s)", A, B, C);
  295.     printf("\nXOR2_32(F,D,E)  This result should match the one above.");
  296.     printf("\nD(%.32s) XOR E(%.32s) =  F(%.32s) \n", D, E, F);  */
  297.     if (memcmp(C,F,32) != 0) {
  298.         printf("%.32s != %.32s (XOR)\n", C, F);
  299.         success = 0;
  300.     }
  301.    
  302.     C[0] = NOR2_1(A[0], B[0]);
  303.     C[1] = NOR2_1(A[1], B[1]);
  304.     C[2] = NOR2_1(A[2], B[2]);
  305.     C[3] = NOR2_1(A[3], B[3]);
  306.     C[4] = NOR2_1(A[4], B[4]);
  307.     C[5] = NOR2_1(A[5], B[5]);
  308.     C[6] = NOR2_1(A[6], B[6]);
  309.     C[7] = NOR2_1(A[7], B[7]);
  310.     C[8] = NOR2_1(A[8], B[8]);
  311.     C[9] = NOR2_1(A[9], B[9]);
  312.     C[10] = NOR2_1(A[10], B[10]);
  313.     C[11] = NOR2_1(A[11], B[11]);
  314.     C[12] = NOR2_1(A[12], B[12]);
  315.     C[13] = NOR2_1(A[13], B[13]);
  316.     C[14] = NOR2_1(A[14], B[14]);
  317.     C[15] = NOR2_1(A[15], B[15]);
  318.     C[16] = NOR2_1(A[16], B[16]);
  319.     C[17] = NOR2_1(A[17], B[17]);
  320.     C[18] = NOR2_1(A[18], B[18]);
  321.     C[19] = NOR2_1(A[19], B[19]);
  322.     C[20] = NOR2_1(A[20], B[20]);
  323.     C[21] = NOR2_1(A[21], B[21]);
  324.     C[22] = NOR2_1(A[22], B[22]);
  325.     C[23] = NOR2_1(A[23], B[23]);
  326.     C[24] = NOR2_1(A[24], B[24]);
  327.     C[25] = NOR2_1(A[25], B[25]);
  328.     C[26] = NOR2_1(A[26], B[26]);
  329.     C[27] = NOR2_1(A[27], B[27]);
  330.     C[28] = NOR2_1(A[28], B[28]);
  331.     C[29] = NOR2_1(A[29], B[29]);
  332.     C[30] = NOR2_1(A[30], B[30]);
  333.     C[31] = NOR2_1(A[31], B[31]);
  334.     NOR2_32(F, D, E);
  335.     /*printf("\nC[0-31] = NOR2_1(A[0-31], B[0-31])");
  336.     printf("\nA(%.32s) NOR B(%.32s) =  C(%.32s)", A, B, C);
  337.     printf("\nNOR2_32(F,D,E)  This result should match the one above.");
  338.     printf("\nD(%.32s) NOR E(%.32s) =  F(%.32s) \n", D, E, F);*/
  339.     if (memcmp(C,F,32) != 0) {
  340.         printf("%.32s != %.32s (NOR)\n", C, F);
  341.         success = 0;
  342.     }
  343.    
  344.     return success;
  345. }
  346.  
  347. int testMuxes() {
  348.     int success = 1;
  349.     int i;
  350.  
  351.     char A[32] = "10101010101010101010101010101010";
  352.     char B[32] = "11001100110011001100110011001100";
  353.     char C[32] = "11111111111111111111111111111111";
  354.     char D[32] = "10001000100010001000100010001000";
  355.     char E[32] = "10000000100000001000000010000000";
  356.     char F[32] = "10000000000000001000000000000000";
  357.     char G[32] = "11011011011011011011011011011011";
  358.     char H[32] = "10110101101011010110101101011010";
  359.     char Z[32] = "00000000000000000000000000000000"; // output
  360.    
  361.     char out[32];
  362.    
  363.     Mux_2_32(out, A, B, '1');
  364.     for (i = 0; i < 32; i++)
  365.         Z[i] = Mux_2_1(A[i], B[i], '1');
  366.     if (memcmp(out, Z, 32) != 0) {
  367.         success = 0;
  368.         printf("%.32s != %.32s\n", out, Z);
  369.     }
  370.    
  371.     Mux_4_32(out, A, B, C, D, "10");
  372.     for (i = 0; i < 32; i++)
  373.         Z[i] = Mux_4_1(A[i], B[i], C[i], D[i], "10");
  374.     if (memcmp(out, Z, 32) != 0) {
  375.         success = 0;
  376.         printf("%.32s != %.32s\n", out, Z);
  377.     }
  378.    
  379.     Mux_8_32(out, A, B, C, D, E, F, G, H, "100");
  380.     for (i = 0; i < 32; i++)
  381.         Z[i] = Mux_8_1(A[i], B[i], C[i], D[i], E[i], F[i], G[i], H[i], "100");
  382.     if (memcmp(out, Z, 32) != 0) {
  383.         success = 0;
  384.         printf("%.32s != %.32s\n", out, Z);
  385.     }
  386.    
  387.     return success;
  388. }
  389.  
  390. int testRegisters() {
  391.     int success = 1;
  392.    
  393.     char A[32] = "10101010101010101010101010101010";
  394.     char F[32] = "00000000000000000000000000000000";
  395.    
  396.     char out1[32];
  397.     char out2[32];
  398.     char read1[5];
  399.     char read2[5];
  400.     char write[5];
  401.    
  402.     // write A to 00010
  403.     // also, read $0
  404.     RegisterFileAccess(&out1[0], &out2[0], "00000", "00000", "00010", A, '1');
  405.     if (memcmp(out1, F, 32) != 0) {
  406.         success = 0;
  407.         printf("%.32s != %.32s\n", out1, F);
  408.     }
  409.     // read from 00010
  410.     RegisterFileAccess(&out1[0], &out2[0], "00000", "00010", "00010", A, '0');
  411.     if (memcmp(out2, A, 32) != 0) {
  412.         success = 0;
  413.         printf("%.32s != %.32s\n", out2, A);
  414.     }
  415.     return success;
  416. }
  417.  
  418. int testAdders() {
  419.     int success = 1;
  420.     int i;
  421.     char cin = '0';
  422.    
  423.     char A[32] = "00101010101010101010101010101010";
  424.     char B[32] = "01010101010101010101010101010101";
  425.     char Z[32] = "00000000000000000000000000000000";
  426.    
  427.     char out[32];
  428.     AddRCA_32(out, A, B, '0');
  429.     for (i = 0; i < 32; i++)
  430.         cin = AddRCA_1(&Z[i], A[i], B[i], cin);
  431.     if (memcmp(out, Z, 32) != 0) {
  432.         success = 0;
  433.         printf("%.32s != %.32s\n", out, Z);
  434.     }
  435.    
  436.     return success;
  437. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!