main.cpp

00001 #include "mbed.h"
00002 #include "MMA8451Q.h" //kniznica akcelerometra
00003 
00004 #define MMA8451_I2C_ADDRESS (0x1d<<1) //definicia pre akcelerometer
00005 
00006 Ticker disptick;    //definovanie casoveho prerusenia pre volanie funkcie vysvietenia
00007 AnalogIn   randAdc(A3);
00008 // definovanie pinov pre zelenu farbu
00009 DigitalOut gr0(PTC7);
00010 DigitalOut gr1(PTC6);
00011 DigitalOut gr2(PTC5);
00012 DigitalOut gr3(PTC4);
00013 DigitalOut gr4(PTC3);
00014 DigitalOut gr5(PTC2);
00015 DigitalOut gr6(PTC1);
00016 DigitalOut gr7(PTC0);
00017 
00018 //definovanie pinov pre cervenu farbu
00019 DigitalOut rd0(PTC17);
00020 DigitalOut rd1(PTC16);
00021 DigitalOut rd2(PTC13);
00022 DigitalOut rd3(PTC12);
00023 DigitalOut rd4(PTC11);
00024 DigitalOut rd5(PTC10);
00025 DigitalOut rd6(PTC9);
00026 DigitalOut rd7(PTC8);
00027 
00028 //definovanie pinov pre adresaciu riadkov
00029 DigitalOut ln0(PTB0);
00030 DigitalOut ln1(PTB1);
00031 DigitalOut ln2(PTB2);
00032 
00033 // prototypy funkcii
00034 short RandSegment(void);                                            //funkcia nahodne vybera novy segment pomocou citania A/D vstupu
00035 void SegmentInit(void);                                             //prida jednotlivym segmentom informacie o ich vlastnostiach - pocet riadkov, stlpcov, rotovany segment, priradi pole s vlastnostou farby
00036 void SegmentCopy(struct segments *psgm, int segmentIn[2][4]);       //v SegmentInit skopiruje vytvorene pole segmentu do pola v strukture (struct segments)
00037 void MoveDown(int array[8][16], int line);                          //posun pola smerom dole po odstranení zaplneneho riadku
00038 void LineCheck(void);                                               //funkcia kontroluje zaplneny riadok
00039 void SegmentMove(struct segments *psgm);                            //funkcia sa stara o pohyby segmentu
00040 void WriteClrSeg(int wrtEnab, struct segments *psgm);               //zmazanie alebo zapis segmentu pri pohybe maticou
00041 int DecLvl(void);                                                   //obsluha akcelerometra  (preco prave Dec som zabudol)
00042 void LineAdd(int line);                                             //adresacia riadkov
00043 void Display(void);                                                 //rozsvecovanie farieb v riadkoch podla hlavnej matice
00044 void OutPortInit(void);                                             //nastavenie portov do pociatocneho stavu - vypnutie/zhasnutie
00045 
00046 //_____________________________________________________
00047 int collision = 0;  //globalna premenna zaznamenania kolizie pricom dany segment ostane ulozeny na danom mieste a vyberie sa novy
00048 short choice = 0;   //globálna premenna vybranej struktury segmentu (pr. seg[choice])
00049 
00050 //nasledujuce segmenty si nesu o sebe vlastnost farby(nulovy a parny stlpec v 1 - svieti zelena, neparny - cervena, obe - oranzova), neskor su priradene do struktury a su pridane dalsie vlastnosti
00051 //____________________________________________________kocka                   
00052 int segment0[2][4] = {{1,1, 1,1},   //oranzova
00053                      {1,1, 1,1},};                  
00054 int segment1[2][4] = {{1,0, 1,0},   //zelena
00055                      {1,0, 1,0},};                     
00056 int segment2[2][4] = {{0,1, 0,1},   //cervena
00057                      {0,1, 0,1},};
00058 //_____________________________________________________bodka
00059                      
00060 int segment3[2][4] = {{1,1, 0,0},   //oranzova
00061                      {0,0, 0,0},};
00062 int segment4[2][4] = {{1,0, 0,0},   //zelena  
00063                      {0,0, 0,0},}; 
00064 int segment5[2][4] = {{0,1, 0,0},   //cervena 
00065                      {0,0, 0,0},}; 
00066 //____________________________________________________I
00067 
00068 int segment6[2][4] = {{1,1, 1,1},   //oranzova
00069                      {0,0, 0,0},};
00070 int segment61[2][4] = {{1,1, 0,0},   //oranzova rot1
00071                      {1,1, 0,0},};
00072                      
00073 int segment7[2][4] = {{1,0, 1,0},   //zelena
00074                      {0,0, 0,0},};
00075 int segment71[2][4] = {{1,0, 0,0},   //zelena rot1
00076                      {1,0, 0,0},};
00077                      
00078 int segment8[2][4] = {{0,1, 0,1},   //cervena
00079                      {0,0, 0,0},};
00080 int segment81[2][4] = {{0,1, 0,0},   //cervena rot1
00081                      {0,1, 0,0},};
00082 //______________________________________________________L                                        
00083                      
00084 int segment9[2][4] = {{1,1, 1,1},   //oranzova
00085                      {1,1, 0,0},};
00086 int segment91[2][4] = {{1,1, 1,1},   //oranzova rot1
00087                      {0,0, 1,1},};
00088 int segment92[2][4] = {{0,0, 1,1},   //oranzova rot2
00089                      {1,1, 1,1},};
00090 int segment93[2][4] = {{1,1, 0,0},   //oranzova rot3
00091                      {1,1, 1,1},};                     
00092                                           
00093 int segment10[2][4] = {{1,0, 1,0},   //zelena
00094                      {1,0, 0,0},};
00095 int segment101[2][4] = {{1,0, 1,0},   //zelena rot1
00096                      {0,0, 1,0},};
00097 int segment102[2][4] = {{0,0, 1,0},   //zelena rot2
00098                      {1,0, 1,0},};
00099 int segment103[2][4] = {{1,0, 0,0},   //zelena rot3
00100                      {1,0, 1,0},};
00101                      
00102 int segment11[2][4] = {{0,1, 0,1},   //cervena
00103                      {0,1, 0,0},};
00104 int segment111[2][4] = {{0,1, 0,1},   //cervena rot1
00105                      {0,0, 0,1},};
00106 int segment112[2][4] = {{0,0, 0,1},   //cervena rot2
00107                      {0,1, 0,1},};
00108 int segment113[2][4] = {{0,1, 0,0},   //cervena rot3
00109                      {0,1, 0,1},};
00110 //________________________________________________________________                     
00111 struct segments {           //struktura segmentov
00112     char line;              //pocet riadkov
00113     char colum;             //pocet stlpcov
00114     char nextRot;           //cislo noveho rotovaneho segmentu
00115     int segmentx[2][4];     //pole pre segmnet
00116 }seg[30];
00117 //_________________________________________________________________                     
00118                 // | 1  | 2  | 3  | 4  | 5  | 6  | 7  | 8 |    
00119 int dispArray[8][16] = {                                        //pracovne pole, v ktorom sa vsetko odohrava, nulovy a parny stlpec v 1 - svieti zelena, neparny - cervena, obe - oranzova
00120                    {0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0},    //1         
00121                    {0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0},    //2
00122                    {0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0},    //3
00123                    {0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0},    //4
00124                    {0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0},    //5
00125                    {0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0},    //6
00126                    {0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0},    //7
00127                    {0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0},  };//8
00128                    
00129 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
00130 /*+++                    MAIN                          +++*/
00131 /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
00132 
00133 int main() {
00134     SegmentInit();                          //nahranie informacii do struktur segmentov (struct segments)
00135     OutPortInit();                          //porty vypnute - zhasnuta matica
00136     disptick.attach(&Display, 0.002);       //nastavenie prerusenia pre vysvecovanie displeja
00137     while(1) {
00138             choice = RandSegment();         //nahodny vyber segmentu
00139             while(collision != 1){          //pokial nenastane kolizia spodnej hrany segmentu
00140                 SegmentMove(&seg[choice]);  //pohybuj segmentov - v pravo, v lavo, dole, rotacia
00141             }
00142             LineCheck();                    //skontroluje riadoky ci nie su zaplnene ak hej posunie sa vrchna cast dole
00143             collision = 0;                  
00144     }
00145 }
00146 /*--------------------------------------------------------*/
00147 /*---                    MAIN                          ---*/
00148 /*--------------------------------------------------------*/
00149 
00150 /*___________________________________________________________________________________________*/
00151 
00152 
00153 /*++++++++++++++++++++++RandSegment+++++++++++++++++++++++*/
00154 //funkcia nahodne vybera novy segment pomocou citania A/D vstupu
00155 short RandSegment(void){                    
00156     static short num = 0;
00157     num = randAdc.read_u16()%12;            //precitanie A/D s %12 - zvysok od 0 do 11 <-> zakladne segmenty od 0 do 11
00158     return(num);                            
00159 }
00160 /*---------------------RandSegment-----------------------*/
00161 
00162 /*++++++++++++++++++++++SegmentInit+++++++++++++++++++++++*/
00163 //prida jednotlivym segmentom informacie o ich vlastnostiach - pocet riadkov, stlpcov, rotovany segment, priradi pole s vlastnostou farby
00164 void SegmentInit(void){                     
00165     seg[0].line = 2;    
00166     seg[0].colum = 4;
00167     seg[0].nextRot = 0;
00168     SegmentCopy(&seg[0], segment0);  //oranzova kocka 2x2
00169     seg[1].line = 2;
00170     seg[1].colum = 4;
00171     seg[1].nextRot = 1;
00172     SegmentCopy(&seg[1], segment1);  //zelena kocka 2x2
00173     seg[2].line = 2;
00174     seg[2].colum = 4;
00175     seg[2].nextRot = 2;
00176     SegmentCopy(&seg[2], segment2);  //cervena kocka 2x2
00177 //_________________________________________________________________    
00178     seg[3].line = 1;
00179     seg[3].colum = 2;
00180     seg[3].nextRot = 3;
00181     SegmentCopy(&seg[3], segment3);  //oranzova bodka
00182     seg[4].line = 1;
00183     seg[4].colum = 2;
00184     seg[4].nextRot = 4;
00185     SegmentCopy(&seg[4], segment4);  //zelena bodka
00186     seg[5].line = 1;
00187     seg[5].colum = 2;
00188     seg[5].nextRot = 5;
00189     SegmentCopy(&seg[5], segment5);  //cervena bodka
00190 //__________________________________________________________________    
00191     seg[6].line = 1;    
00192     seg[6].colum = 4;
00193     seg[6].nextRot = 12;
00194     SegmentCopy(&seg[6], segment6);  //oranzova ciara 
00195     seg[12].line = 2;    
00196     seg[12].colum = 2;
00197     seg[12].nextRot = 6;
00198     SegmentCopy(&seg[12], segment61);  //oranzova ciara rot
00199     
00200     seg[7].line = 1;
00201     seg[7].colum = 4;
00202     seg[7].nextRot = 13;
00203     SegmentCopy(&seg[7], segment7);  //zelena ciara
00204     seg[13].line = 2;
00205     seg[13].colum = 2;
00206     seg[13].nextRot = 7;
00207     SegmentCopy(&seg[13], segment71);  //zelena ciara rot
00208     
00209     seg[8].line = 1;
00210     seg[8].colum = 4;
00211     seg[8].nextRot = 14;
00212     SegmentCopy(&seg[8], segment8);  //cervena ciara 
00213     seg[14].line = 2;
00214     seg[14].colum = 2;
00215     seg[14].nextRot = 8;
00216     SegmentCopy(&seg[14], segment81);  //cervena ciara rot
00217 //__________________________________________________________________    
00218     seg[9].line = 2;    
00219     seg[9].colum = 4;
00220     seg[9].nextRot = 15;
00221     SegmentCopy(&seg[9], segment9);  //oranzova L
00222     seg[15].line = 2;    
00223     seg[15].colum = 4;
00224     seg[15].nextRot = 16;
00225     SegmentCopy(&seg[15], segment91);  //oranzova L rot1
00226     seg[16].line = 2;    
00227     seg[16].colum = 4;
00228     seg[16].nextRot = 17;
00229     SegmentCopy(&seg[16], segment92);  //oranzova L rot2
00230     seg[17].line = 2;    
00231     seg[17].colum = 4;
00232     seg[17].nextRot = 9;
00233     SegmentCopy(&seg[17], segment93);  //oranzova L  rot3
00234     
00235     seg[10].line = 2;
00236     seg[10].colum = 4;
00237     seg[10].nextRot = 18;
00238     SegmentCopy(&seg[10], segment10);  //zelena L
00239     seg[18].line = 2;
00240     seg[18].colum = 4;
00241     seg[18].nextRot = 19;
00242     SegmentCopy(&seg[18], segment101);  //zelena L rot1
00243     seg[19].line = 2;
00244     seg[19].colum = 4;
00245     seg[19].nextRot = 20;
00246     SegmentCopy(&seg[19], segment102);  //zelena L rot2
00247     seg[20].line = 2;
00248     seg[20].colum = 4;
00249     seg[20].nextRot = 10;
00250     SegmentCopy(&seg[20], segment103);  //zelena L rot3
00251     
00252     seg[11].line = 2;
00253     seg[11].colum = 4;
00254     seg[11].nextRot = 21;
00255     SegmentCopy(&seg[11], segment11);  //cervena L 
00256     seg[21].line = 2;
00257     seg[21].colum = 4;
00258     seg[21].nextRot = 22;
00259     SegmentCopy(&seg[21], segment111);  //cervena L rot1
00260     seg[22].line = 2;
00261     seg[22].colum = 4;
00262     seg[22].nextRot = 23;
00263     SegmentCopy(&seg[22], segment112);  //cervena L rot2
00264     seg[23].line = 2;
00265     seg[23].colum = 4;
00266     seg[23].nextRot = 11;
00267     SegmentCopy(&seg[23], segment113);  //cervena L rot3
00268     
00269 }
00270 /*----------------------SegmentInit-----------------------*/
00271 
00272 /*++++++++++++++++++++++SegmentCopy+++++++++++++++++++++++*/
00273 //v SegmentInit skopiruje vytvorene pole segmentu do pola v strukture (struct segments)
00274 void SegmentCopy(struct segments *psgm, int segmentIn[2][4]){       
00275     static int i,j;
00276     for(i = 0 ; i < (psgm->line); i++){ //riadok
00277         for(j = 0 ; j < (psgm->colum); j++ ){    //slpec
00278             psgm->segmentx[i][j] = segmentIn[i][j];
00279         }
00280     }
00281 }
00282 /*--------------------SegmentCopy------------------------*/
00283 
00284 /*++++++++++++++++++++++LineCheck+++++++++++++++++++++++*/
00285 //funkcia kontroluje zaplneny riadok
00286 void LineCheck(void){
00287     static int ch=0;
00288     static int lnCh, colCh;
00289         
00290     for(lnCh = 0; lnCh < 8; lnCh++){
00291         ch = 0;
00292         for(colCh=0; colCh < 15; colCh+=2){
00293             if((dispArray[lnCh][colCh]==1) || (dispArray[lnCh][colCh+1]==1)){       //ak je bod vysvieteny
00294                 ch++;}                                                              //pripocita k premennej
00295             else {
00296                 colCh = 15;                                                         //ak bod v riadku nie je vysvieteny nema cenu ho cely kontrolovat a skoci sa tak na dalsi riadok
00297                 ch = 0;
00298                 }    
00299         }
00300         if((ch == 8)){                                                              //ak je cely riadok vysvieteny
00301             for(colCh=0; colCh < 16; colCh++){                                      //nuluj riadok
00302                 dispArray[lnCh][colCh] = 0;
00303             }
00304             MoveDown(dispArray, lnCh);                                              //posunie zvysok pola dole a kontroluje sa zvysok a teda proces sa opakuje kym sa neskontroluje cele pole
00305         }
00306     }    
00307 }
00308 
00309 /*-------------------------LineCheck----------------------------*/
00310 
00311 /*++++++++++++++++++++++++MoveDown++++++++++++++++++++++++++++++*/
00312 //posun pola smerom dole po odstranení zaplneneho riadku
00313 void MoveDown(int dispArray[8][16], int line){
00314     static int ln, col;
00315     for(ln = line; ln>=0; ln--){
00316         for(col=0; col < 16; col++){
00317             if(ln>=1){
00318                 dispArray[ln][col] = dispArray[ln-1][col];
00319             }
00320             if(ln<1){
00321                 dispArray[ln][col] = 0;
00322             }
00323         }   
00324     }
00325 }
00326 
00327 /*-----------------------MoveDown-------------------------------*/
00328 
00329 /*+++++++++++++++++++++SegmentMove++++++++++++++++++++++++*/
00330 //funkcia sa stara o pohyby segmentu
00331 static int x=6, y=0;                                        //suradnice segmentu pricom hodnotu na suradnici x,y je vzdy lavy horny roh segmentu
00332 
00333 void SegmentMove(struct segments *psgm){
00334     static long int counter=0;                              //vytvara zdrzanie pri pohybe
00335     static int col, ln, dm;                                 //col, ln - premenne v cykloch pri kontrole kolizii, dm detekcia kolizie, zakaze pohyb danym smerom
00336     
00337     if( ((x == 6) && (y == 0)) && counter == 0){            //kontrola pri novom segmente ci nedojde ku kolizii
00338         for(ln = 0; ln < psgm->line; ln++){                 //skontroluje ci v priestore nedojde ku kolizii
00339             for(col=0; col < psgm->colum; col+=2){
00340                 if((dispArray[y+ln][x+col] | dispArray[y+ln][x+col+1]) & (psgm->segmentx[ln][col] | psgm->segmentx[ln][col+1]) == 1){       //zistuje ci nie je v danom bode kolizia so segmentom
00341                     ln = psgm->line;                                //ak je kolizia nema cenu kontrolovat zvysok
00342                     col = psgm->colum;                              //
00343                     static int lnclr, colclr;                       //vynulovanie celeho pola
00344                     for(lnclr = 0; lnclr < 8; lnclr++){             //
00345                         for(colclr=0; colclr < 16; colclr++){       //
00346                             dispArray[lnclr][colclr] = 0;           //
00347                         }
00348                     }
00349                 }
00350             }
00351         }
00352     }
00353     
00354     WriteClrSeg(1, &seg[choice]);                     //zapise segment do pola
00355     counter++;                                        //counter zacina pocitat
00356     if((counter%4000 == 0)){                          //ak je counter nasobkom 4000 je umozneny pohyb pomocou akcelerometra
00357         if(DecLvl()==3) {       //podmienka pre pohyb v pravo 
00358             WriteClrSeg(0, &seg[choice]);        //zmaze segment z pola, inak by za sebou nechaval zapisane hodnoty
00359             for(ln = 0; ln < psgm->line; ln++){         //skontroluje ci v priestore pohybu nedojde ku kolizii
00360                 for(col=0; col < psgm->colum; col+=2){
00361                     if((dispArray[y+ln][x+col+2] | dispArray[y+ln][x+col+1+2]) & (psgm->segmentx[ln][col] | psgm->segmentx[ln][col+1]) == 1){
00362                         ln = psgm->line;
00363                         col = psgm->colum;
00364                         dm = 1;                     //doslo ku kolizii
00365                     }
00366                 }
00367             }
00368             if (dm == 0){                       //nedoslo ku kolizii, segment sa moze pohnut
00369                 x+=2;
00370                 if (x>16-(psgm->colum)){
00371                     x=16-(psgm->colum);
00372                 }
00373             }
00374             dm = 0;                             //po kolizii sa premenna vynuluje
00375             WriteClrSeg(1, &seg[choice]);       //opatovne zapisanie segmentu do pola
00376         }
00377         if((DecLvl()==4) ){    //opodmienka pre pohohyb v lavo - analogia s pohybom v pravo
00378             WriteClrSeg(0, &seg[choice]);
00379             for(ln = 0; ln < psgm->line; ln++){     //skontroluje ci v priestore pohybu nedojde ku kolizii
00380                 for(col=0; col < psgm->colum; col+=2){
00381                     if((dispArray[y+ln][x+col-2] | dispArray[y+ln][x+col+1-2]) & (psgm->segmentx[ln][col] | psgm->segmentx[ln][col+1]) == 1){
00382                         ln = psgm->line;
00383                         col = psgm->colum;
00384                         dm = 1;
00385                     }
00386                 }
00387             }
00388             if (dm == 0){
00389                     x-=2;
00390                     if (x<0){
00391                         x=0;
00392                     }
00393             }
00394             dm = 0;
00395             WriteClrSeg(1, &seg[choice]); 
00396         }
00397         if(DecLvl()==1){    //pohyb k sebe - segment pada zrychlene dole
00398             counter = 40001;    
00399         }
00400         if(DecLvl()==2){    //pohyb od seba - rotacia segmentu
00401             WriteClrSeg(0, &seg[choice]);       //zmaze segment z pola
00402             for(ln = 0; ln < seg[psgm->nextRot].line; ln++){        //skontroluje ci v priestore rotovaneho segmentu nedojde ku kolizii
00403                 for(col=0; col < seg[psgm->nextRot].colum; col+=2){
00404                     if(((dispArray[y+ln][x+col] | dispArray[y+ln][x+col+1]) & (seg[psgm->nextRot].segmentx[ln][col] | seg[psgm->nextRot].segmentx[ln][col+1]) == 1) || ((seg[psgm->nextRot].line-1+y) > 7) || ((seg[psgm->nextRot].colum-1+x) > 15)){
00405                         ln = seg[psgm->nextRot].line;           //parametre orotovaneho segmentu
00406                         col = seg[psgm->nextRot].colum;         //
00407                         dm = 1;                                 //premenna naznacujuca koliziu 
00408                     }
00409                 }
00410             }
00411             if (dm == 0){
00412                 choice = psgm->nextRot;     //nahradi segment za rotovany
00413             }
00414             dm = 0;
00415             WriteClrSeg(1, &seg[choice]);   //zapise segment do pola
00416         }
00417     }
00418     
00419     if(counter >= 40001){         //zdrzanie 
00420         WriteClrSeg(0, &seg[choice]);       //zmaze segment z pola
00421         counter = 0;                        //vynuluje counter
00422         y++;                                //segment sa posunie dole ak splni podmnienku nizsie
00423         for(ln = 0; ln < psgm->line; ln++){         //skontroluje ci v priestore pohybu nedojde ku kolizii
00424             for(col=0; col < psgm->colum; col+=2){
00425                 if(((dispArray[y+ln][x+col] | dispArray[y+ln][x+col+1]) & (psgm->segmentx[ln][col] | psgm->segmentx[ln][col+1]) == 1) || ((y+psgm->line-1) > 7) ){
00426                         y--;                    //segment sa dostal mimo pola alebo sa dostal do kolizie, suradnica sa vracia
00427                         ln = psgm->line;        //aby sa nemusel kontrolovat pripadne zvysok 
00428                         col = psgm->colum;      //
00429                         dm = 1;                 
00430                         collision = 1;          //detekuje sa kolizia a vyberie sa novy segment
00431                   }
00432              }
00433         }
00434         WriteClrSeg(1, &seg[choice]);
00435         if (dm == 1){                   //po detekcii kolizie sa nastavia pociatocne suradnice
00436             y = 0;
00437             x = 6; 
00438             dm = 0; 
00439         }
00440     }
00441 }
00442 /*---------------------------SegmentMove---------------------------*/
00443 
00444 /*+++++++++++++++++++++++++++WriteClrSeg+++++++++++++++++++++++++++*/
00445 //zmazanie alebo zapis segmentu pri pohybe maticou
00446 void WriteClrSeg(int wrtEnab, struct segments *psgm){          //ak je wrtEnab 0 zmaze sa ak 1 zapise sa dany segment do pola, segment sa cita zo struktury vybranej randomom
00447     static int ln, col;
00448     
00449     for(ln = 0; ln < psgm->line; ln++){
00450         for(col=0; col < psgm->colum; col++){
00451             if(wrtEnab == 1){
00452                 dispArray[ln+y][col+x] |= psgm->segmentx[ln][col];}
00453             else{
00454                 dispArray[ln+y][col+x] = (psgm->segmentx[ln][col] == 1 ? 0:dispArray[ln+y][col+x] );}
00455         }
00456     }
00457 }
00458 /*-------------------------WriteClrSeg-----------------------------*/
00459 
00460 /*++++++++++++++++++++++++++++++DecLvl+++++++++++++++++++++++++++++*/
00461 //obsluha akcelerometra
00462 MMA8451Q acc(PTE25, PTE24, MMA8451_I2C_ADDRESS);
00463 
00464 int DecLvl(void){
00465 
00466     static float ax, ay;
00467     static float point = 0.34;          //nastavenie uhla...cca 30° +- nieco
00468     
00469     ax = float(acc.getAccX());          //citanie hodnoty v x-ovej osi akcelerometra
00470     ay = float(acc.getAccY());          //citanie hodnoty v y-ovej osi akcelerometra
00471 
00472     if((ax > point)){        //k sebe
00473             return(1);
00474         }
00475     else if((ax < -point)){       //od seba
00476             return(2);
00477         }
00478     else if((ay > point)){        //naklon v pravo
00479             return(3);
00480         }
00481     else if((ay < -point)){   //naklon v lavo
00482             return(4);
00483         }
00484     return 0;
00485 }
00486 /*--------------------------------DecLvl-------------------------------*/
00487 
00488 /*++++++++++++++++++++++++++++++Display+++++++++++++++++++++++++++++*/
00489 //rozsvecovanie farieb v riadkoch podla hlavnej matice
00490 void Display(void){
00491     static int line = 0;
00492 
00493     LineAdd(line);                      //adresacia riadku pomocou funkcie, 
00494         gr0 = !dispArray[line][0];      //parny a nulovy stlpec znaci zelenu farbu (dany bod svieti po pripojeni na zem, ale zapis svietecej casti v poli je pomocou 1)
00495         gr1 = !dispArray[line][2];
00496         gr2 = !dispArray[line][4];
00497         gr3 = !dispArray[line][6];
00498         gr4 = !dispArray[line][8];
00499         gr5 = !dispArray[line][10];
00500         gr6 = !dispArray[line][12];
00501         gr7 = !dispArray[line][14];
00502         
00503         rd0 = !dispArray[line][1];      //neparny riadok znaci cervenu farbu
00504         rd1 = !dispArray[line][3];
00505         rd2 = !dispArray[line][5];
00506         rd3 = !dispArray[line][7];
00507         rd4 = !dispArray[line][9];
00508         rd5 = !dispArray[line][11];
00509         rd6 = !dispArray[line][13];
00510         rd7 = !dispArray[line][15];
00511                                         //ak su vysvietene obe, svieti oranzova
00512         wait(0.001);
00513             line++;                     //nasledujuci riadok
00514             if(line == 8){          
00515                 line = 0;
00516             }
00517 }
00518 /*--------------------------------Display-------------------------------*/
00519 
00520 /*++++++++++++++++++++++++++++++++LineAdd++++++++++++++++++++++++++++++++++*/
00521 //adresacia riadkov
00522 void LineAdd(int line){
00523     switch(line){
00524         case 0: ln0 = 0;
00525                 ln1 = 0;
00526                 ln2 = 0;
00527                 break;
00528         case 1: ln0 = 1;
00529                 ln1 = 0;
00530                 ln2 = 0;
00531                 break;
00532         case 2: ln0 = 0;
00533                 ln1 = 1;
00534                 ln2 = 0;
00535                 break;
00536         case 3: ln0 = 1;
00537                 ln1 = 1;
00538                 ln2 = 0;
00539                 break;
00540         case 4: ln0 = 0;
00541                 ln1 = 0;
00542                 ln2 = 1;
00543                 break;
00544         case 5: ln0 = 1;
00545                 ln1 = 0;
00546                 ln2 = 1;
00547                 break;
00548         case 6: ln0 = 0;
00549                 ln1 = 1;
00550                 ln2 = 1;
00551                 break;
00552         case 7: ln0 = 1;
00553                 ln1 = 1;
00554                 ln2 = 1;
00555                 break;
00556         default: break;
00557         }    
00558 }
00559 /*-----------------------LineAdd------------------------*/
00560 
00561 /*+++++++++++++++++++++++OutPortInit++++++++++++++++++++*/
00562 //nastavenie portov do pociatocneho stavu - vypnutie/zhasnutie
00563 void OutPortInit(void){
00564     rd0 = 1;
00565     rd1 = 1;
00566     rd2 = 1;
00567     rd3 = 1;
00568     rd4 = 1;
00569     rd5 = 1;
00570     rd6 = 1;
00571     rd7 = 1;
00572     gr0 = 1;
00573     gr1 = 1;
00574     gr2 = 1;
00575     gr3 = 1;
00576     gr4 = 1;
00577     gr5 = 1;
00578     gr6 = 1;
00579     gr7 = 1;
00580 }
00581 /*---------------------OutPortInit--------------------*/