Michael Balourdas / Mbed 2 deprecated TriviaGame

Dependencies:   4DGL-uLCD-SE SDFileSystem mbed wave_player

Fork of MPR121_Demo by jim hamblen

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers main.cpp Source File

main.cpp

00001 #include "mbed.h"
00002 #include "SDFileSystem.h"
00003 #include "uLCD_4DGL.h"
00004 #include "wave_player.h"
00005 #include "mpr121.h"
00006 #include <vector>
00007 
00008 AnalogOut DACout(p18); // used to play sound on speaker
00009 //wave player plays a *.wav file to D/A and a PWM
00010 wave_player waver(&DACout);
00011 InterruptIn interrupt(p26);
00012 I2C i2c(p9, p10);
00013 Mpr121 mpr121(&i2c, Mpr121::ADD_VSS);
00014 
00015 uLCD_4DGL uLCD(p28,p27,p29); // serial tx, serial rx, reset pin;
00016 SDFileSystem sd(p5, p6, p7, p8, "sd"); //SD card setup
00017 int Score;
00018 int HighScore = 0;
00019 int question = 0;
00020 bool answer = 1;
00021 int index = 0;
00022 bool check = 0;
00023 int value = 0;
00024 std::vector<int> v;
00025 
00026 
00027 int main()
00028 {
00029     srand(time(NULL));
00030     while (true){
00031         answer = 1;
00032         for (int i=0; i<10; i++){
00033             v.push_back(i+1);
00034         }
00035         check = 0;
00036         question = 0;
00037         uLCD.baudrate(3000000);
00038         uLCD.background_color(BLACK);
00039         uLCD.color(BLUE);
00040         uLCD.cls();
00041         if (Score > HighScore){
00042             HighScore = Score;
00043             uLCD.printf("NEW HIGH SCORE!\n %d", HighScore);
00044             wait(2);
00045         }
00046         Score = 0;
00047         uLCD.cls();
00048         uLCD.printf("\nTrivia Game \n Main Menu\n\n"); 
00049         uLCD.printf("High Score: %d \n", HighScore);
00050         uLCD.printf("\nFor New Game \n Press 0");
00051         while (value != 1){
00052             value=mpr121.read(0x00);
00053             value +=mpr121.read(0x01)<<8;  
00054             }
00055         uLCD.cls();
00056         if (v.size() !=0){
00057         while (answer == 1){
00058             if (v.size() == 0){
00059                 break;
00060                 }
00061             index = rand() %v.size();
00062             question = v.at(index);
00063             v.erase(v.begin()+index);
00064             check = 0;
00065             uLCD.cls();
00066             wait(1);
00067             if (question == 1){
00068                 value = 0;
00069                 uLCD.cls();
00070                 uLCD.locate(1,2);
00071                 uLCD.printf("Who won the World Series in 2016?\n\n\n");
00072                 uLCD.printf("1) Cleveland\nIndians\n");
00073                 uLCD.printf("2) Chicago Cubs\n");
00074                 uLCD.printf("3) San Diego\nPadres\n");
00075                 while (check == 0){
00076                     int value=mpr121.read(0x00);
00077                     value +=mpr121.read(0x01)<<8;
00078                     if (value == 2){
00079                         //play game over
00080                         uLCD.cls();
00081                         uLCD.media_init();
00082                         uLCD.set_sector_address(0x0000, 0x009F);
00083                         uLCD.display_image(0,0);
00084                         FILE *wave_file;   
00085                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00086                         waver.play(wave_file);
00087                         fclose(wave_file);
00088                         wait(1);
00089                         uLCD.cls();
00090                         answer = 0;
00091                         check = 1;
00092                         }
00093                     if (value == 4){
00094                         //play correct image
00095                         uLCD.cls();
00096                         uLCD.media_init();
00097                         uLCD.set_sector_address(0x0000, 0x005E);
00098                         uLCD.display_image(0,0);
00099                         FILE *wave_file;   
00100                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
00101                         waver.play(wave_file);
00102                         fclose(wave_file);
00103                         wait(1);
00104                         uLCD.cls();
00105                         Score = Score+1;
00106                         uLCD.printf("Score: %d", Score);
00107                         wait(1);
00108                         answer = 1;
00109                         check = 1;
00110                         }
00111                     if (value == 8){
00112                         //play game over
00113                         uLCD.cls();
00114                         uLCD.media_init();
00115                         uLCD.set_sector_address(0x0000, 0x009F);
00116                         uLCD.display_image(0,0);
00117                         FILE *wave_file;   
00118                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00119                         waver.play(wave_file);
00120                         fclose(wave_file);
00121                         wait(1);
00122                         uLCD.cls();
00123                         answer = 0;
00124                         check = 1;
00125                     }
00126                 }
00127             }
00128             if (question == 2){
00129                 value = 0;
00130                 uLCD.cls();
00131                 uLCD.locate(1,2);
00132                 uLCD.printf("What is the\n capital of South\n Dakota?\n\n");
00133                 uLCD.printf("1) Pierre\n");
00134                 uLCD.printf("2) Bismarck\n");
00135                 uLCD.printf("3) Lakota\n");
00136                 while (check == 0){
00137                     int value=mpr121.read(0x00);
00138                     value +=mpr121.read(0x01)<<8;
00139                     if (value == 4){
00140                         //play game over
00141                         uLCD.cls();
00142                         uLCD.media_init();
00143                         uLCD.set_sector_address(0x0000, 0x009F);
00144                         uLCD.display_image(0,0);
00145                         FILE *wave_file;   
00146                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00147                         waver.play(wave_file);
00148                         fclose(wave_file);
00149                         wait(1);
00150                         uLCD.cls();
00151                         answer = 0;
00152                         check = 1;
00153                         }
00154                     if (value == 2){
00155                         //play correct image
00156                         uLCD.cls();
00157                         uLCD.media_init();
00158                         uLCD.set_sector_address(0x0000, 0x005E);
00159                         uLCD.display_image(0,0);
00160                         FILE *wave_file;   
00161                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
00162                         waver.play(wave_file);
00163                         fclose(wave_file);
00164                         wait(1);
00165                         uLCD.cls();
00166                         Score=Score+1;;
00167                         uLCD.printf("Score: %d", Score);
00168                         wait(1);
00169                         answer = 1;
00170                         check = 1;
00171                         }
00172                     if (value == 8){
00173                         //play game over
00174                         uLCD.cls();
00175                         uLCD.media_init();
00176                         uLCD.set_sector_address(0x0000, 0x009F);
00177                         uLCD.display_image(0,0);
00178                         FILE *wave_file;   
00179                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00180                         waver.play(wave_file);
00181                         fclose(wave_file);
00182                         wait(1);
00183                         uLCD.cls();
00184                         answer = 0;
00185                         check = 1;
00186         }
00187     }
00188             
00189   }
00190   if (question == 3){
00191                 value = 0;
00192                 uLCD.cls();
00193                 uLCD.locate(1,2);
00194                 uLCD.printf("Who wrote The \nGrapes of Wrath?\n\n\n");
00195                 uLCD.printf("1)Ernest Hemingway");
00196                 uLCD.printf("2)George Orwell\n");
00197                 uLCD.printf("3)John Steinbeck\n");
00198                 while (check == 0){
00199                     int value=mpr121.read(0x00);
00200                     value +=mpr121.read(0x01)<<8;
00201                     if (value == 2){
00202                         //play game over
00203                         uLCD.cls();
00204                         uLCD.media_init();
00205                         uLCD.set_sector_address(0x0000, 0x009F);
00206                         uLCD.display_image(0,0);
00207                         FILE *wave_file;   
00208                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00209                         waver.play(wave_file);
00210                         fclose(wave_file);
00211                         wait(1);
00212                         uLCD.cls();
00213                         answer = 0;
00214                         check = 1;
00215                         }
00216                     if (value == 8){
00217                         //play correct image
00218                         uLCD.cls();
00219                         uLCD.media_init();
00220                         uLCD.set_sector_address(0x0000, 0x005E);
00221                         uLCD.display_image(0,0);
00222                         FILE *wave_file;   
00223                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
00224                         waver.play(wave_file);
00225                         fclose(wave_file);
00226                         wait(1);
00227                         uLCD.cls();
00228                         Score = Score+1;
00229                         uLCD.printf("Score: %d", Score);
00230                         wait(1);
00231                         answer = 1;
00232                         check = 1;
00233                         }
00234                     if (value == 4){
00235                         //play game over
00236                         uLCD.cls();
00237                         uLCD.media_init();
00238                         uLCD.set_sector_address(0x0000, 0x009F);
00239                         uLCD.display_image(0,0);
00240                         FILE *wave_file;   
00241                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00242                         waver.play(wave_file);
00243                         fclose(wave_file);
00244                         wait(1);
00245                         uLCD.cls();
00246                         answer = 0;
00247                         check = 1;
00248                     }
00249                 }
00250             }
00251             if (question == 4){
00252                 value = 0;
00253                 uLCD.cls();
00254                 uLCD.locate(1,2);
00255                 uLCD.printf("What year was \nEinstein born?\n\n\n");
00256                 uLCD.printf("1) 1900\n");
00257                 uLCD.printf("2) 1879\n");
00258                 uLCD.printf("3) 1873\n");
00259                 while (check == 0){
00260                     int value=mpr121.read(0x00);
00261                     value +=mpr121.read(0x01)<<8;
00262                     if (value == 2){
00263                         //play game over
00264                         uLCD.cls();
00265                         uLCD.media_init();
00266                         uLCD.set_sector_address(0x0000, 0x009F);
00267                         uLCD.display_image(0,0);
00268                         FILE *wave_file;   
00269                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00270                         waver.play(wave_file);
00271                         fclose(wave_file);
00272                         wait(1);
00273                         uLCD.cls();
00274                         answer = 0;
00275                         check = 1;
00276                         }
00277                     if (value == 4){
00278                         //play correct image
00279                         uLCD.cls();
00280                         uLCD.media_init();
00281                         uLCD.set_sector_address(0x0000, 0x005E);
00282                         uLCD.display_image(0,0);
00283                         FILE *wave_file;   
00284                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
00285                         waver.play(wave_file);
00286                         fclose(wave_file);
00287                         wait(1);
00288                         uLCD.cls();
00289                         Score = Score+1;
00290                         uLCD.printf("Score: %d", Score);
00291                         wait(1);
00292                         answer = 1;
00293                         check = 1;
00294                         }
00295                     if (value == 8){
00296                         //play game over
00297                         uLCD.cls();
00298                         uLCD.media_init();
00299                         uLCD.set_sector_address(0x0000, 0x009F);
00300                         uLCD.display_image(0,0);
00301                         FILE *wave_file;   
00302                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00303                         waver.play(wave_file);
00304                         fclose(wave_file);
00305                         wait(1);
00306                         uLCD.cls();
00307                         answer = 0;
00308                         check = 1;
00309                     }
00310                 }
00311             }
00312             if (question == 5){
00313                 value = 0;
00314                 uLCD.cls();
00315                 uLCD.locate(1,2);
00316                 uLCD.printf("Which song is by the Rolling Stones?\n\n\n");
00317                 uLCD.printf("1) Paint It Black\n");
00318                 uLCD.printf("2) Feel For \nThe Devil\n");
00319                 uLCD.printf("3) Let It Be\n");
00320                 while (check == 0){
00321                     int value=mpr121.read(0x00);
00322                     value +=mpr121.read(0x01)<<8;
00323                     if (value == 4){
00324                         //play game over
00325                         uLCD.cls();
00326                         uLCD.media_init();
00327                         uLCD.set_sector_address(0x0000, 0x009F);
00328                         uLCD.display_image(0,0);
00329                         FILE *wave_file;   
00330                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00331                         waver.play(wave_file);
00332                         fclose(wave_file);
00333                         wait(1);
00334                         uLCD.cls();
00335                         answer = 0;
00336                         check = 1;
00337                         }
00338                     if (value == 2){
00339                         //play correct image
00340                         uLCD.cls();
00341                         uLCD.media_init();
00342                         uLCD.set_sector_address(0x0000, 0x005E);
00343                         uLCD.display_image(0,0);
00344                         FILE *wave_file;   
00345                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
00346                         waver.play(wave_file);
00347                         fclose(wave_file);
00348                         wait(1);
00349                         uLCD.cls();
00350                         Score = Score+1;
00351                         uLCD.printf("Score: %d", Score);
00352                         wait(1);
00353                         answer = 1;
00354                         check = 1;
00355                         }
00356                     if (value == 8){
00357                         //play game over
00358                         uLCD.cls();
00359                         uLCD.media_init();
00360                         uLCD.set_sector_address(0x0000, 0x009F);
00361                         uLCD.display_image(0,0);
00362                         FILE *wave_file;   
00363                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00364                         waver.play(wave_file);
00365                         fclose(wave_file);
00366                         wait(1);
00367                         uLCD.cls();
00368                         answer = 0;
00369                         check = 1;
00370                     }
00371                 }
00372             }
00373              if (question == 6){
00374                 value = 0;
00375                 uLCD.cls();
00376                 uLCD.locate(1,2);
00377                 uLCD.printf("Where was Hitler born?\n\n\n");
00378                 uLCD.printf("1) Poland\n");
00379                 uLCD.printf("2) Germany\n");
00380                 uLCD.printf("3) Austria\n");
00381                 while (check == 0){
00382                     int value=mpr121.read(0x00);
00383                     value +=mpr121.read(0x01)<<8;
00384                     if (value == 4){
00385                         //play game over
00386                         uLCD.cls();
00387                         uLCD.media_init();
00388                         uLCD.set_sector_address(0x0000, 0x009F);
00389                         uLCD.display_image(0,0);
00390                         FILE *wave_file;   
00391                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00392                         waver.play(wave_file);
00393                         fclose(wave_file);
00394                         wait(1);
00395                         uLCD.cls();
00396                         answer = 0;
00397                         check = 1;
00398                         }
00399                     if (value == 8){
00400                         //play correct image
00401                         uLCD.cls();
00402                         uLCD.media_init();
00403                         uLCD.set_sector_address(0x0000, 0x005E);
00404                         uLCD.display_image(0,0);
00405                         FILE *wave_file;   
00406                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
00407                         waver.play(wave_file);
00408                         fclose(wave_file);
00409                         wait(1);
00410                         uLCD.cls();
00411                         Score = Score+1;
00412                         uLCD.printf("Score: %d", Score);
00413                         wait(1);
00414                         answer = 1;
00415                         check = 1;
00416                         }
00417                     if (value == 2){
00418                         //play game over
00419                         uLCD.cls();
00420                         uLCD.media_init();
00421                         uLCD.set_sector_address(0x0000, 0x009F);
00422                         uLCD.display_image(0,0);
00423                         FILE *wave_file;   
00424                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00425                         waver.play(wave_file);
00426                         fclose(wave_file);
00427                         wait(1);
00428                         uLCD.cls();
00429                         answer = 0;
00430                         check = 1;
00431                     }
00432                 }
00433             }
00434              if (question == 7){
00435                 value = 0;
00436                 uLCD.cls();
00437                 uLCD.locate(1,2);
00438                 uLCD.printf("The best selling\nmusic single of all time is?\n\n\n");
00439                 uLCD.printf("1) Billie Jean\n");
00440                 uLCD.printf("2) White Christmas\n");
00441                 uLCD.printf("3) Candle in the \nWind\n");
00442                 while (check == 0){
00443                     int value=mpr121.read(0x00);
00444                     value +=mpr121.read(0x01)<<8;
00445                     if (value == 4){
00446                         //play game over
00447                         uLCD.cls();
00448                         uLCD.media_init();
00449                         uLCD.set_sector_address(0x0000, 0x009F);
00450                         uLCD.display_image(0,0);
00451                         FILE *wave_file;   
00452                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00453                         waver.play(wave_file);
00454                         fclose(wave_file);
00455                         wait(1);
00456                         uLCD.cls();
00457                         answer = 0;
00458                         check = 1;
00459                         }
00460                     if (value == 8){
00461                         //play correct image
00462                         uLCD.cls();
00463                         uLCD.media_init();
00464                         uLCD.set_sector_address(0x0000, 0x005E);
00465                         uLCD.display_image(0,0);
00466                         FILE *wave_file;   
00467                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
00468                         waver.play(wave_file);
00469                         fclose(wave_file);
00470                         wait(1);
00471                         uLCD.cls();
00472                         Score = Score+1;
00473                         uLCD.printf("Score: %d", Score);
00474                         wait(1);
00475                         answer = 1;
00476                         check = 1;
00477                         }
00478                     if (value == 2){
00479                         //play game over
00480                         uLCD.cls();
00481                         uLCD.media_init();
00482                         uLCD.set_sector_address(0x0000, 0x009F);
00483                         uLCD.display_image(0,0);
00484                         FILE *wave_file;   
00485                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00486                         waver.play(wave_file);
00487                         fclose(wave_file);
00488                         wait(1);
00489                         uLCD.cls();
00490                         answer = 0;
00491                         check = 1;
00492                     }
00493                 }
00494             }
00495              if (question == 8){
00496                 value = 0;
00497                 uLCD.cls();
00498                 uLCD.locate(1,2);
00499                  uLCD.printf("What is the \ncurrency of \nJapan?\n\n\n");
00500                 uLCD.printf("1) Pounds\n");
00501                 uLCD.printf("2) Yen\n");
00502                 uLCD.printf("3) Riki\n");
00503                 while (check == 0){
00504                     int value=mpr121.read(0x00);
00505                     value +=mpr121.read(0x01)<<8;
00506                     if (value == 2){
00507                         //play game over
00508                         uLCD.cls();
00509                         uLCD.media_init();
00510                         uLCD.set_sector_address(0x0000, 0x009F);
00511                         uLCD.display_image(0,0);
00512                         FILE *wave_file;   
00513                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00514                         waver.play(wave_file);
00515                         fclose(wave_file);
00516                         wait(1);
00517                         uLCD.cls();
00518                         answer = 0;
00519                         check = 1;
00520                         }
00521                     if (value == 4){
00522                         //play correct image
00523                         uLCD.cls();
00524                         uLCD.media_init();
00525                         uLCD.set_sector_address(0x0000, 0x005E);
00526                         uLCD.display_image(0,0);
00527                         FILE *wave_file;   
00528                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
00529                         waver.play(wave_file);
00530                         fclose(wave_file);
00531                         wait(1);
00532                         uLCD.cls();
00533                         Score = Score+1;
00534                         uLCD.printf("Score: %d", Score);
00535                         wait(1);
00536                         answer = 1;
00537                         check = 1;
00538                         }
00539                     if (value == 8){
00540                         //play game over
00541                         uLCD.cls();
00542                         uLCD.media_init();
00543                         uLCD.set_sector_address(0x0000, 0x009F);
00544                         uLCD.display_image(0,0);
00545                         FILE *wave_file;   
00546                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00547                         waver.play(wave_file);
00548                         fclose(wave_file);
00549                         wait(1);
00550                         uLCD.cls();
00551                         answer = 0;
00552                         check = 1;
00553                     }
00554                 }
00555             }
00556              if (question == 9){
00557                 value = 0;
00558                 uLCD.cls();
00559                 uLCD.locate(1,2);
00560                 uLCD.printf("Who was Harry \nHoudini?\n\n\n");
00561                 uLCD.printf("1)An Escape Artist\n");
00562                 uLCD.printf("2)Fighter Pilot in WWII\n");
00563                 uLCD.printf("3) Harry Potter's Cousin\n");
00564                 while (check == 0){
00565                     int value=mpr121.read(0x00);
00566                     value +=mpr121.read(0x01)<<8;
00567                     if (value == 4){
00568                         //play game over
00569                         uLCD.cls();
00570                         uLCD.media_init();
00571                         uLCD.set_sector_address(0x0000, 0x009F);
00572                         uLCD.display_image(0,0);
00573                         FILE *wave_file;   
00574                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00575                         waver.play(wave_file);
00576                         fclose(wave_file);
00577                         wait(1);
00578                         uLCD.cls();
00579                         answer = 0;
00580                         check = 1;
00581                         }
00582                     if (value == 2){
00583                         //play correct image
00584                         uLCD.cls();
00585                         uLCD.media_init();
00586                         uLCD.set_sector_address(0x0000, 0x005E);
00587                         uLCD.display_image(0,0);
00588                         FILE *wave_file;   
00589                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
00590                         waver.play(wave_file);
00591                         fclose(wave_file);
00592                         wait(1);
00593                         uLCD.cls();
00594                         Score = Score+1;
00595                         uLCD.printf("Score: %d", Score);
00596                         wait(1);
00597                         answer = 1;
00598                         check = 1;
00599                         }
00600                     if (value == 8){
00601                         //play game over
00602                         uLCD.cls();
00603                         uLCD.media_init();
00604                         uLCD.set_sector_address(0x0000, 0x009F);
00605                         uLCD.display_image(0,0);
00606                         FILE *wave_file;   
00607                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00608                         waver.play(wave_file);
00609                         fclose(wave_file);
00610                         wait(1);
00611                         uLCD.cls();
00612                         answer = 0;
00613                         check = 1;
00614                     }
00615                 }
00616             }
00617              if (question == 10){
00618                 value = 0;
00619                 uLCD.cls();
00620                 uLCD.locate(1,2);
00621                 uLCD.printf("What is glass \nmainly made up \nof?\n\n\n");
00622                 uLCD.printf("1) Sand\n");
00623                 uLCD.printf("2) Crystals\n");
00624                 uLCD.printf("3) Highly \nCompressed \nWater\n");
00625                 while (check == 0){
00626                     int value=mpr121.read(0x00);
00627                     value +=mpr121.read(0x01)<<8;
00628                     if (value == 4){
00629                         //play game over
00630                         uLCD.cls();
00631                         uLCD.media_init();
00632                         uLCD.set_sector_address(0x0000, 0x009F);
00633                         uLCD.display_image(0,0);
00634                         FILE *wave_file;   
00635                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00636                         waver.play(wave_file);
00637                         fclose(wave_file);
00638                         wait(1);
00639                         uLCD.cls();
00640                         answer = 0;
00641                         check = 1;
00642                         }
00643                     if (value == 2){
00644                         //play correct image
00645                         uLCD.cls();
00646                         uLCD.media_init();
00647                         uLCD.set_sector_address(0x0000, 0x005E);
00648                         uLCD.display_image(0,0);
00649                         FILE *wave_file;   
00650                         wave_file=fopen("/sd/sounds/right_taught.wav","r");
00651                         waver.play(wave_file);
00652                         fclose(wave_file);
00653                         wait(1);
00654                         uLCD.cls();
00655                         Score = Score+1;
00656                         uLCD.printf("Score: %d", Score);
00657                         wait(1);
00658                         answer = 1;
00659                         check = 1;
00660                         }
00661                     if (value == 8){
00662                         //play game over
00663                         uLCD.cls();
00664                         uLCD.media_init();
00665                         uLCD.set_sector_address(0x0000, 0x009F);
00666                         uLCD.display_image(0,0);
00667                         FILE *wave_file;   
00668                         wave_file=fopen("/sd/sounds/wrong_last.wav","r");
00669                         waver.play(wave_file);
00670                         fclose(wave_file);
00671                         wait(1);
00672                         uLCD.cls();
00673                         answer = 0;
00674                         check = 1;
00675                     }
00676                 }
00677             }
00678   }
00679                         
00680                         
00681                         
00682                 
00683                 
00684      }   
00685      else{
00686                 uLCD.printf("CONGRATS!");
00687                 wait(1);
00688             }
00689          
00690 }    
00691 }