tablefunctions.h

00001 
00002 /* Useful Table Functions*/
00003 
00004 /*************************************************************************
00005 Function Variables
00006 **************************************************************************/
00007 int clear_time;
00008 char clear_enabled;
00009 char current_clear_function;
00010 
00011 /*************************************************************************
00012 Function Headers
00013 **************************************************************************/
00014 int get_next_function(char current);
00015 void enableLEDs(void);
00016 void disableLEDs(void);
00017 void clearPositive(void);
00018 void clearNegative(void);
00019 void clearValues(void);
00020 void clearLEDs(void);
00021 void clearArray(void);
00022 void clearFunction(void);
00023 void clear_dissolve(void);
00024 int sum_table(void);
00025 void initTable(void);
00026 void displayTable(void);
00027 
00028 int get_next_functon(char current){
00029     char function_size = sizeof(function_enable)/sizeof(char);
00030     current += 1;
00031     while((current< function_size) && (function_enable[current] == 0)){
00032         current +=1;
00033     }
00034     if(function_enable[current] == 1){
00035         return current;
00036     }
00037     else{
00038         current = 0;
00039         while((current< function_size) && (function_enable[current] == 0)){
00040             current +=1;
00041         }
00042         return current;
00043     }
00044 }
00045 
00046 void enableLEDs(void){
00047     posOE = 0;
00048     negOE = 0;
00049 }
00050 
00051 void disableLEDs(void){
00052     posOE = 1;
00053     negOE = 1;
00054 }
00055 
00056 void clearPositive(void){
00057     posC0 = 0;
00058     posC1 = 0;
00059     posC2 = 0;
00060     posC3 = 0;
00061     posC4 = 0;
00062     posC5 = 0;
00063     posC6 = 0;
00064     posC7 = 0;
00065 }
00066 
00067 void clearNegative(void){
00068     negC0 = 0;
00069     negC1 = 0;
00070     negC2 = 0;
00071     negC3 = 0;
00072     negC4 = 0;
00073     negC5 = 0;
00074     negC6 = 0;
00075     negC7 = 0;
00076 }
00077 
00078 void clearValues(void){
00079     clearPositive();
00080     clearNegative();
00081 }
00082 
00083 
00084 void clearLEDs(void){
00085     clearValues();
00086     
00087     posM0 = 0;
00088     posM1 = 0;
00089     negM0 = 0;
00090     negM1 = 0;
00091     
00092     posM0 = 1;
00093     posM1 = 0;
00094     
00095     posM0 = 0;
00096     posM1 = 1;
00097     
00098     posM0 = 1;
00099     posM1 = 1;
00100     
00101     posM0 = 0;
00102     posM1 = 0;
00103     
00104     negM0 = 1;
00105     negM1 = 0;
00106     
00107     negM0 = 0;
00108     negM1 = 1;
00109     
00110     negM0 = 1;
00111     negM1 = 1;
00112     
00113     negM0 = 0;
00114     negM1 = 0;
00115 }
00116 
00117 void clearArray(void){
00118     for(int i=0; i<16; i++){
00119         for(int j=0; j<32; j++){
00120             ledtable[i][j]=0;
00121         }
00122     }
00123 }
00124 
00125 
00126 
00127 void clearFunction(void){
00128     if(!clear_enabled){
00129         // Pick Random Clear Function
00130         current_clear_function = rand()%(sizeof(function_enable)/sizeof(char));
00131         while(clear_function_enable[current_clear_function] != 1){
00132             current_clear_function = rand()%(sizeof(function_enable)/sizeof(char));
00133         }
00134         // Enable clear function
00135         clear_enabled = 1;
00136         
00137         // Start Clear Time
00138         clear_time = tabletimer.read_ms();
00139     }
00140     else{
00141         // Run Clear Function
00142         switch (current_clear_function) {
00143                 case 0:
00144                     // Current: Dissolve
00145                     clear_dissolve();
00146                     break;
00147                 case 1:
00148                     break;
00149                 case 2:
00150                     break;
00151                 default:
00152                     // Shouldn't get in here...
00153                     break;
00154             }
00155         
00156         
00157         // If board is empty, disable clear function and move to next function
00158         if(sum_table() == 0){
00159             clear_enabled = 0;
00160             current_function = next_function;
00161             tabletimeseconds = tabletimer.read();
00162         }
00163     }
00164 }
00165     
00166 
00167 void clear_dissolve(void){
00168     int row;
00169     int col;
00170     
00171     if((tabletimer.read_ms() - clear_time)>dissolve_time){
00172         // Run Dissolve
00173         do{
00174             row = rand()%16;
00175             col = rand()%32;
00176         }
00177         while(ledtable[row][col] < 1);
00178         
00179         // Clear current pixel
00180         ledtable[row][col] = 0;
00181     }
00182 }        
00183                 
00184 int sum_table(void){
00185     int total = 0;
00186     for(int i=0; i<16; i++){
00187         for(int j=0; j<32; j++){
00188             total += ledtable[i][j];
00189         }
00190     }
00191     return total;
00192 }
00193 
00194 void initTable(void){
00195     // Start Timer
00196     tabletimer.start();
00197     tabletimeseconds = tabletimer.read();
00198     // Seed Random Number Generator with Current Time
00199     srand(tabletimeseconds);
00200     
00201     disableLEDs();
00202     clearArray();
00203     clearLEDs();
00204 }
00205 
00206 void displayTable(void){
00207     clearLEDs();
00208     int rowneg;
00209     for(int i = 1; i<=60;i++){
00210         for(rowneg = 0; rowneg < 8; rowneg ++){
00211             // Clear All Values
00212             clearValues();
00213             
00214             // ******** Turn on Lights for Each Section ******** //
00215             // Top Left Corner (1-,3+)
00216             posM0 = 1;
00217             posM1 = 1;
00218             negM0 = 1;
00219             negM1 = 0;
00220             // Set Negative Value
00221             switch (rowneg){
00222                 case 0:
00223                     negC0 = 1;
00224                     break;
00225                 case 1:
00226                     negC1 = 1;
00227                     break;
00228                 case 2:
00229                     negC2 = 1;
00230                     break;
00231                 case 3:
00232                     negC3 = 1;
00233                     break;
00234                 case 4:
00235                     negC4 = 1;
00236                     break;
00237                 case 5:
00238                     negC5 = 1;
00239                     break;
00240                 case 6:
00241                     negC6 = 1;
00242                     break;
00243                 case 7:
00244                     negC7 = 1;
00245                     break;
00246             }
00247             // Set Positive Value
00248             if(ledtable[rowneg][0] >= i)
00249                 posC0 = 1;
00250             if(ledtable[rowneg][1] >= i)
00251                 posC1 = 1;
00252             if(ledtable[rowneg][2] >= i)
00253                 posC2 = 1;
00254             if(ledtable[rowneg][3] >= i)
00255                 posC3 = 1;
00256             if(ledtable[rowneg][4] >= i)
00257                 posC4 = 1;
00258             if(ledtable[rowneg][5] >= i)
00259                 posC5 = 1;
00260             if(ledtable[rowneg][6] >= i)
00261                 posC6 = 1;
00262             if(ledtable[rowneg][7] >= i)
00263                 posC7 = 1;
00264             // Load Values in Latches and Clear Values to Prevent Loading into Other Latches
00265             posM0 = 0;
00266             posM1 = 1;
00267             negM0 = 0;
00268             negM1 = 0;
00269             clearValues();
00270             
00271             // Top Mid Left Corner (1-,2+)
00272             posM0 = 0;
00273             posM1 = 1;
00274             negM0 = 1;
00275             negM1 = 0;
00276             // Set Negative Value
00277             switch (rowneg){
00278                 case 0:
00279                     negC0 = 1;
00280                     break;
00281                 case 1:
00282                     negC1 = 1;
00283                     break;
00284                 case 2:
00285                     negC2 = 1;
00286                     break;
00287                 case 3:
00288                     negC3 = 1;
00289                     break;
00290                 case 4:
00291                     negC4 = 1;
00292                     break;
00293                 case 5:
00294                     negC5 = 1;
00295                     break;
00296                 case 6:
00297                     negC6 = 1;
00298                     break;
00299                 case 7:
00300                     negC7 = 0;
00301                     break;
00302             }
00303             // Set Positive Value
00304             if(ledtable[rowneg][8] >= i)
00305                 posC0 = 1;
00306             if(ledtable[rowneg][9] >= i)
00307                 posC1 = 1;
00308             if(ledtable[rowneg][10] >= i)
00309                 posC2 = 1;
00310             if(ledtable[rowneg][11] >= i)
00311                 posC3 = 1;
00312             if(ledtable[rowneg][12] >= i)
00313                 posC4 = 1;
00314             if(ledtable[rowneg][13] >= i)
00315                 posC5 = 1;
00316             if(ledtable[rowneg][14] >= i)
00317                 posC6 = 1;
00318             if(ledtable[rowneg][15] >= i)
00319                 posC7 = 1;
00320             // Load Values in Latches and Clear Values to Prevent Loading into Other Latches
00321             posM0 = 0;
00322             posM1 = 0;
00323             negM0 = 0;
00324             negM1 = 0;
00325             clearValues();
00326             
00327             // Top Mid Right Corner (3-,1+)
00328             posM0 = 1;
00329             posM1 = 0;
00330             negM0 = 1;
00331             negM1 = 1;
00332             // Set Negative Value
00333             switch (rowneg){
00334                 case 0:
00335                     negC0 = 1;
00336                     break;
00337                 case 1:
00338                     negC1 = 1;
00339                     break;
00340                 case 2:
00341                     negC2 = 1;
00342                     break;
00343                 case 3:
00344                     negC3 = 1;
00345                     break;
00346                 case 4:
00347                     negC4 = 1;
00348                     break;
00349                 case 5:
00350                     negC5 = 1;
00351                     break;
00352                 case 6:
00353                     negC6 = 1;
00354                     break;
00355                 case 7:
00356                     negC7 = 0;
00357                     break;
00358             }
00359             // Set Positive Value
00360             if(ledtable[rowneg][16] >= i)
00361                 posC0 = 1;
00362             if(ledtable[rowneg][17] >= i)
00363                 posC1 = 1;
00364             if(ledtable[rowneg][18] >= i)
00365                 posC2 = 1;
00366             if(ledtable[rowneg][19] >= i)
00367                 posC3 = 1;
00368             if(ledtable[rowneg][20] >= i)
00369                 posC4 = 1;
00370             if(ledtable[rowneg][21] >= i)
00371                 posC5 = 1;
00372             if(ledtable[rowneg][22] >= i)
00373                 posC6 = 1;
00374             if(ledtable[rowneg][23] >= i)
00375                 posC7 = 1;
00376             // Load Values in Latches and Clear Values to Prevent Loading into Other Latches
00377             posM0 = 0;
00378             posM1 = 0;
00379             negM0 = 0;
00380             negM1 = 1;
00381             clearValues();
00382             
00383             // Top Right Corner (3-,0+)
00384             posM0 = 0;
00385             posM1 = 0;
00386             negM0 = 1;
00387             negM1 = 1;
00388             // Set Negative Value
00389             switch (rowneg){
00390                 case 0:
00391                     negC0 = 1;
00392                     break;
00393                 case 1:
00394                     negC1 = 1;
00395                     break;
00396                 case 2:
00397                     negC2 = 1;
00398                     break;
00399                 case 3:
00400                     negC3 = 1;
00401                     break;
00402                 case 4:
00403                     negC4 = 1;
00404                     break;
00405                 case 5:
00406                     negC5 = 1;
00407                     break;
00408                 case 6:
00409                     negC6 = 1;
00410                     break;
00411                 case 7:
00412                     negC7 = 1;
00413                     break;
00414             }
00415             // Set Positive Value
00416             if(ledtable[rowneg][24] >= i)
00417                 posC0 = 1;
00418             if(ledtable[rowneg][25] >= i)
00419                 posC1 = 1;
00420             if(ledtable[rowneg][26] >= i)
00421                 posC2 = 1;
00422             if(ledtable[rowneg][27] >= i)
00423                 posC3 = 1;
00424             if(ledtable[rowneg][28] >= i)
00425                 posC4 = 1;
00426             if(ledtable[rowneg][29] >= i)
00427                 posC5 = 1;
00428             if(ledtable[rowneg][30] >= i)
00429                 posC6 = 1;
00430             if(ledtable[rowneg][31] >= i)
00431                 posC7 = 1;
00432             // Load Values in Latches and Clear Values to Prevent Loading into Other Latches
00433             posM0 = 1;
00434             posM1 = 0;
00435             negM0 = 0;
00436             negM1 = 1;
00437             
00438             //wait(displayDelay);
00439             clearLEDs();
00440         }
00441         
00442         for(rowneg = 8; rowneg < 16; rowneg ++){
00443             // Clear All Values
00444             clearValues();
00445             
00446             // ******** Turn on Lights for Each Section ******** //
00447             // Bottom Left Corner (0-,3+)
00448             posM0 = 1;
00449             posM1 = 1;
00450             negM0 = 0;
00451             negM1 = 0;
00452             // Set Negative Value
00453             switch (rowneg-8){
00454                 case 0:
00455                     negC0 = 1;
00456                     break;
00457                 case 1:
00458                     negC1 = 1;
00459                     break;
00460                 case 2:
00461                     negC2 = 1;
00462                     break;
00463                 case 3:
00464                     negC3 = 1;
00465                     break;
00466                 case 4:
00467                     negC4 = 1;
00468                     break;
00469                 case 5:
00470                     negC5 = 1;
00471                     break;
00472                 case 6:
00473                     negC6 = 1;
00474                     break;
00475                 case 7:
00476                     negC7 = 1;
00477                     break;
00478             }
00479             // Set Positive Value
00480             if(ledtable[rowneg][0] >= i)
00481                 posC0 = 1;
00482             if(ledtable[rowneg][1] >= i)
00483                 posC1 = 1;
00484             if(ledtable[rowneg][2] >= i)
00485                 posC2 = 1;
00486             if(ledtable[rowneg][3] >= i)
00487                 posC3 = 1;
00488             if(ledtable[rowneg][4] >= i)
00489                 posC4 = 1;
00490             if(ledtable[rowneg][5] >= i)
00491                 posC5 = 1;
00492             if(ledtable[rowneg][6] >= i)
00493                 posC6 = 1;
00494             if(ledtable[rowneg][7] >= i)
00495                 posC7 = 1;
00496             // Load Values in Latches and Clear Values to Prevent Loading into Other Latches
00497             posM0 = 0;
00498             posM1 = 1;
00499             negM0 = 1;
00500             negM1 = 0;
00501             clearValues();
00502             
00503             // Bottom Left Mid Corner (0-,2+)
00504             posM0 = 0;
00505             posM1 = 1;
00506             negM0 = 0;
00507             negM1 = 0;
00508             // Set Negative Value
00509             switch (rowneg-8){
00510                 case 0:
00511                     negC0 = 1;
00512                     break;
00513                 case 1:
00514                     negC1 = 1;
00515                     break;
00516                 case 2:
00517                     negC2 = 1;
00518                     break;
00519                 case 3:
00520                     negC3 = 1;
00521                     break;
00522                 case 4:
00523                     negC4 = 1;
00524                     break;
00525                 case 5:
00526                     negC5 = 1;
00527                     break;
00528                 case 6:
00529                     negC6 = 1;
00530                     break;
00531                 case 7:
00532                     negC7 = 0;
00533                     break;
00534             }
00535             // Set Positive Value
00536             if(ledtable[rowneg][8] >= i)
00537                 posC0 = 1;
00538             if(ledtable[rowneg][9] >= i)
00539                 posC1 = 1;
00540             if(ledtable[rowneg][10] >= i)
00541                 posC2 = 1;
00542             if(ledtable[rowneg][11] >= i)
00543                 posC3 = 1;
00544             if(ledtable[rowneg][12] >= i)
00545                 posC4 = 1;
00546             if(ledtable[rowneg][13] >= i)
00547                 posC5 = 1;
00548             if(ledtable[rowneg][14] >= i)
00549                 posC6 = 1;
00550             if(ledtable[rowneg][15] >= i)
00551                 posC7 = 1;
00552             // Load Values in Latches and Clear Values to Prevent Loading into Other Latches
00553             posM0 = 1;
00554             posM1 = 1;
00555             negM0 = 1;
00556             negM1 = 0;
00557             clearValues();
00558             
00559             // Bottom Right Mid Corner (2-,1+)
00560             posM0 = 1;
00561             posM1 = 0;
00562             negM0 = 0;
00563             negM1 = 1;
00564             // Set Negative Value
00565             switch (rowneg-8){
00566                 case 0:
00567                     negC0 = 1;
00568                     break;
00569                 case 1:
00570                     negC1 = 1;
00571                     break;
00572                 case 2:
00573                     negC2 = 1;
00574                     break;
00575                 case 3:
00576                     negC3 = 1;
00577                     break;
00578                 case 4:
00579                     negC4 = 1;
00580                     break;
00581                 case 5:
00582                     negC5 = 1;
00583                     break;
00584                 case 6:
00585                     negC6 = 1;
00586                     break;
00587                 case 7:
00588                     negC7 = 1;
00589                     break;
00590             }
00591             // Set Positive Value
00592             if(ledtable[rowneg][16] >= i)
00593                 posC0 = 1;
00594             if(ledtable[rowneg][17] >= i)
00595                 posC1 = 1;
00596             if(ledtable[rowneg][18] >= i)
00597                 posC2 = 1;
00598             if(ledtable[rowneg][19] >= i)
00599                 posC3 = 1;
00600             if(ledtable[rowneg][20] >= i)
00601                 posC4 = 1;
00602             if(ledtable[rowneg][21] >= i)
00603                 posC5 = 1;
00604             if(ledtable[rowneg][22] >= i)
00605                 posC6 = 1;
00606             if(ledtable[rowneg][23] >= i)
00607                 posC7 = 1;
00608             // Load Values in Latches and Clear Values to Prevent Loading into Other Latches
00609             posM0 = 0;
00610             posM1 = 0;
00611             negM0 = 1;
00612             negM1 = 1;
00613             clearValues();
00614             
00615             // Bottom Right Corner (2-,0+)
00616             posM0 = 0;
00617             posM1 = 0;
00618             negM0 = 0;
00619             negM1 = 1;
00620             // Set Negative Value
00621             switch (rowneg-8){
00622                 case 0:
00623                     negC0 = 1;
00624                     break;
00625                 case 1:
00626                     negC1 = 1;
00627                     break;
00628                 case 2:
00629                     negC2 = 1;
00630                     break;
00631                 case 3:
00632                     negC3 = 1;
00633                     break;
00634                 case 4:
00635                     negC4 = 1;
00636                     break;
00637                 case 5:
00638                     negC5 = 1;
00639                     break;
00640                 case 6:
00641                     negC6 = 1;
00642                     break;
00643                 case 7:
00644                     negC7 = 1;
00645                     break;
00646             }
00647             // Set Positive Value
00648             if(ledtable[rowneg][24] >= i)
00649                 posC0 = 1;
00650             if(ledtable[rowneg][25] >= i)
00651                 posC1 = 1;
00652             if(ledtable[rowneg][26] >= i)
00653                 posC2 = 1;
00654             if(ledtable[rowneg][27] >= i)
00655                 posC3 = 1;
00656             if(ledtable[rowneg][28] >= i)
00657                 posC4 = 1;
00658             if(ledtable[rowneg][29] >= i)
00659                 posC5 = 1;
00660             if(ledtable[rowneg][30] >= i)
00661                 posC6 = 1;
00662             if(ledtable[rowneg][31] >= i)
00663                 posC7 = 1;
00664             // Load Values in Latches and Clear Values to Prevent Loading into Other Latches
00665             posM0 = 0;
00666             posM1 = 1;
00667             negM0 = 1;
00668             negM1 = 1;
00669             clearValues();
00670             
00671             
00672             //wait(displayDelay);
00673             clearLEDs();
00674         }
00675     }
00676 }