BricxCC

(Rozdíly mezi verzemi)
Přejít na: navigace, hledání
Řádka 485: Řádka 485:
 
  }  
 
  }  
 
}                                        //konec programu  
 
}                                        //konec programu  
 +
 +
 +
</source>
 +
 +
 +
==Ukázky složitějších programů:==
 +
 +
 +
 +
'''Úkol č. 12'''
 +
 +
'''Zadání:''' Balanc
 +
 +
'''Funkce:'''
 +
 +
'''Ukázka programu:'''
 +
 +
[[Soubor:Balanc.PNG|thumb]]
 +
 +
<source lang"C">
 +
 +
 +
 +
</source>
 +
 +
 +
 +
 +
 +
'''Úkol č. 13'''
 +
 +
'''Zadání:''' Tanec
 +
 +
'''Funkce:'''
 +
 +
'''Ukázka programu:'''
 +
 +
[[Soubor:Tanec.PNG|thumb]]
 +
 +
<source lang"C">
 +
 +
 +
 +
</source>
 +
 +
 +
 +
 +
 +
'''Úkol č. 14''' Barvy
 +
 +
'''Zadání:''' Tanec
 +
 +
'''Funkce:'''
 +
 +
'''Ukázka programu:'''
 +
 +
[[Soubor:Barvy.PNG|thumb]]
 +
 +
<source lang"C">
 +
#include "NXCDefs.h"                              //hlavičkový soubor
 +
 +
int Light;                                        //intenzita světla
 +
int CalibRange;                                  //kalibrační hodnota 
 +
 +
int Factor = 1;                                  //faktor rozptylu
 +
 +
const int white = 710;                            //světelné konstatny pro jednotlivé barvy
 +
const int yellow = 698;
 +
const int orange = 694;
 +
const int red = 690;
 +
const int lgreen = 630;
 +
const int lgrey = 620;
 +
const int lblue = 578;
 +
const int grey = 546;
 +
const int blue = 532;
 +
const int green = 524;
 +
const int dgrey = 482;
 +
const int dgreen = 472;
 +
const int lblack = 415;
 +
const int dblue = 409;
 +
const int black = 380; 
 +
 +
task main()                                      //hlavní funkce
 +
{ 
 +
 +
SetSensorTouch(IN_1);                            //inicializace
 +
SetSensorLight(IN_3); 
 +
 +
SetSensorMode (IN_3, IN_MODE_RAW);              //nastavení módu na základní zobrazení 
 +
 +
while (true)                                    //nekonecna smycka
 +
{ 
 +
  Off(OUT_BC);                                    //vypnutí motorů 
 +
 +
  while(true)                                    //cyklus kalibrace
 +
  { 
 +
  while(Sensor(IN_1)); 
 +
    TextOut(4, LCD_LINE1, "Kalibrace"); 
 +
 +
    SetSensorType (IN_3, IN_TYPE_LIGHT_INACTIVE); 
 +
    Light = Sensor (IN_3);   
 +
 +
    TextOut(2, LCD_LINE5, "Svetlo:", true); 
 +
    NumOut(50, LCD_LINE5, Light); 
 +
 +
    CalibRange = (Light - 70); 
 +
    TextOut(2, LCD_LINE6, "Calib:" ); 
 +
    NumOut(50, LCD_LINE6, CalibRange); 
 +
    if(Sensor(IN_1)) break;
 +
  }   
 +
 +
  while (true)                                //cyklus měření   
 +
  {   
 +
    while(Sensor(IN_1)); 
 +
    TextOut(4, LCD_LINE1, "-Mereni--"); 
 +
 +
    SetSensorType (IN_3, IN_TYPE_LIGHT_ACTIVE);   
 +
    Light = Sensor(IN_3); 
 +
    TextOut(2, LCD_LINE5, "Svetlo:" ); 
 +
    NumOut(50, LCD_LINE5, Light);   
 +
 +
 +
    if (Light >= ((white + CalibRange) - Factor))                      //bílá 
 +
    {   
 +
      TextOut(10, LCD_LINE2, "-Bila-----" );     
 +
      Factor--;   
 +
    }   
 +
    else if (Light <= ((yellow + CalibRange) + Factor) && Light >= ((yellow + CalibRange) - Factor))    //žlutá     
 +
    {     
 +
      TextOut(10, LCD_LINE2, "-Zluta----" );   
 +
      Factor--;   
 +
    }     
 +
    else if (Light <= ((orange + CalibRange) + Factor) && Light >= ((orange + CalibRange) - Factor))    //oranžová   
 +
    {     
 +
      TextOut(10, LCD_LINE2, "-Oranzova-" ); 
 +
      Factor--;   
 +
    }     
 +
    else if (Light <= ((red + CalibRange) + Factor) && Light >= ((red + CalibRange) - Factor))          //červená 
 +
    {     
 +
      TextOut(10, LCD_LINE2, "-Cervena--" ); 
 +
      Factor--;   
 +
    }   
 +
    else if (Light <= ((lgreen + CalibRange) + Factor) && Light >= ((lgreen + CalibRange) - Factor))    //světle zelená 
 +
    {     
 +
      TextOut(10, LCD_LINE2, "-S Zelena-" );   
 +
      Factor--;   
 +
    }   
 +
    else if (Light <= ((green + CalibRange) + Factor) && Light >= ((green + CalibRange) - Factor))      //zelená 
 +
    {     
 +
      TextOut(10, LCD_LINE2, "-Zelena---" ); 
 +
      Factor--; 
 +
    }   
 +
    else if (Light <= ((dgreen + CalibRange) + Factor) && Light >= ((dgreen + CalibRange) - Factor))    //tmavě zelená 
 +
    {     
 +
      TextOut(10, LCD_LINE2, "-T Zelena-" );   
 +
      Factor--;   
 +
    }   
 +
    else if (Light <= ((lblue + CalibRange) + Factor) && Light >= ((lblue + CalibRange) - Factor))      //světle modrá   
 +
    {     
 +
      TextOut(10, LCD_LINE2, "-S Modra--" );   
 +
      Factor--; 
 +
    }   
 +
    else if (Light <= ((blue + CalibRange) + Factor) && Light >= ((blue + CalibRange) - Factor))        //modrá 
 +
    {   
 +
      TextOut(10, LCD_LINE2, "-Modra----" );   
 +
      Factor--;   
 +
    }     
 +
    else if (Light <= ((dblue + CalibRange) + Factor) && Light >= ((dblue + CalibRange) - Factor))      //tmavě modrá 
 +
    {     
 +
      TextOut(10, LCD_LINE2, "-T Modra--" );     
 +
      Factor--; 
 +
    }   
 +
    else if (Light <= ((grey + CalibRange) + Factor) && Light >= ((grey + CalibRange) - Factor))        //šedá 
 +
    {     
 +
      TextOut(10, LCD_LINE2, "-Seda-----" );     
 +
      Factor--;   
 +
    }   
 +
    else if (Light <= ((black + CalibRange) + Factor))            //černá 
 +
    {     
 +
      TextOut(10, LCD_LINE2, "-Cerna----" );     
 +
      Factor--;
 +
    }   
 +
    else                                                                //CHYBA   
 +
    {   
 +
      Factor++; 
 +
    }   
 +
 +
    if(Sensor(IN_1)) break; 
 +
  } 
 +
}
 +
}
 +
 +
 +
</source>
 +
 +
 +
 +
 +
 +
'''Úkol č. 15''' Ruka
 +
 +
'''Zadání:''' Tanec
 +
 +
'''Funkce:'''
 +
 +
'''Ukázka programu:'''
 +
 +
[[Soubor:Ruka.PNG|thumb]]
 +
 +
<source lang"C">
 +
#include "NXCDefs.h"                      //vložení hlavičkového souboru
 +
#define F  3
 +
 +
task main()                              //hlavní funkce
 +
{
 +
SetSensorTouch (IN_3);                  //zapnutí tlačítkového sensoru na portu 1
 +
SetSensorTouch (IN_4);                  //zapnutí tlačítkového sensoru na portu 1 
 +
 +
int MiddleX = Sensor(IN_1);
 +
int MiddleY = Sensor(IN_2); 
 +
 +
int Touch1;                              //proměnná pro uložení stavu tlačítka
 +
int Touch2;                              //proměnná pro uložení stavu tlačítka
 +
int Joystic1;                            //joystic
 +
int Joystic2;                            //joystic 
 +
 +
int Rotate;
 +
int Altitude; 
 +
 +
int ActualRotate;
 +
int ActualAltitude; 
 +
 +
while(true)                              //nekonečná smyčka
 +
{
 +
  ActualAltitude = MotorRotationCount (OUT_B); 
 +
  ActualRotate = MotorRotationCount (OUT_C);   
 +
 +
  Joystic1 = Sensor (IN_1);              //zjištění stavu
 +
  Joystic2 = Sensor (IN_2);              //zjištění stavu
 +
  Touch1 = Sensor (IN_3);                //zjištění stavu 
 +
  Touch2 = Sensor (IN_4);                //zjištění stavu 
 +
 +
  Altitude = (Joystic1 - MiddleX) * 3;
 +
  Rotate = (Joystic2 - MiddleY) * 4; 
 +
 +
  if(Touch1) 
 +
  { 
 +
  OnFwd(OUT_A, 20);
 +
  }
 +
  else if(Touch2)
 +
  { 
 +
  OnRev(OUT_A, 20); 
 +
  } 
 +
  else 
 +
  { 
 +
  Off(OUT_A);
 +
  } 
 +
 +
  if(Altitude > (ActualAltitude + F)) 
 +
  { 
 +
  OnFwd(OUT_B, 40);
 +
  } 
 +
  else if(Altitude < (ActualAltitude - F)) 
 +
  {
 +
  OnRev(OUT_B, 30);
 +
  } 
 +
  else 
 +
  { 
 +
  Off(OUT_B);
 +
  } 
 +
 +
  if(Rotate > (ActualRotate + F)) 
 +
  { 
 +
  OnFwd(OUT_C, 50); 
 +
  } 
 +
  else if(Rotate < (ActualRotate - F))
 +
  { 
 +
  OnRev(OUT_C, 50);
 +
  } 
 +
  else 
 +
  { 
 +
  Off(OUT_C); 
 +
  }
 +
}
 +
}                                        //konec programu
  
  

Verze z 31. 5. 2011, 14:28

BrixCC – textový programovací nástroj pro vývoj robotických aplikací s LEGO roboty RXC a NXT.

SW-BricxCC 01.jpg
SW-BricxCC 02.jpg
SW-BricxCC 03.jpg


Postup: 1. Stáhněte a nainstalujte program ze stránek http://bricxcc.sourceforge.net/

2. Nainstalujte nebo nakopírujte program do složky: C:\Program Files (x86)\

3. Program spusťte. V okně nastavte vyhledání a připojení NXT. Zvolte port, který chcete využít. Nabízí se USB nebo BlueTooth. Firmware nechte na Standard.

4. Následně v novém okně můžete psát program.

5. Každý program bude na začátku vypadat následovně.






















Obsah

Ukázky programů pro zobrazování údajů:

Úkol č. 1 Zadání: Napište program tak, aby došlo k výpisu textu (i čísel) na LCD displeji robota NXT. Text musí být bez diakritiky.

Funkce: Po úvodní inicializaci a skoku do nekonečné smyčky, se vypíše text „Nahodna cisla“ a vygeneruje se náhodné číslo. Těchto 8 náhodných čísel se postupně zobrazí vedle sebe. Mezi jednotlivým generováním je zpoždění 300 ms.

Ukázka programu:

SW-BricxCC 04.jpg 
#include "NXCDefs.h"                      //vložení hlavičkového souboru
 
task main()                               //hlavní funkce
{
 int RandomValue;                         //náhodné číslo
 int X = 10;                              //poloha
 
 while(true)                              //nekonečná smyčka
  {
   TextOut (10, LCD_LINE3, "Nahodna cisla"); //výpis textu na display
 
   RandomValue = Random(10);             //vygenerování náhodného čísla od 0 do 9
 
   NumOut (X, LCD_LINE5, RandomValue);   //výpis hodnoty na display
 
   X += 10;                              //inkrementace X o 10
   if(X > 80) X = 10;                    //kontrola překročení hodnoty
 
   Wait(300);                            //spoždění o 300 milisekund
  }
}                                        //konec programu


Úkol č. 2

Zadání: Vyzkoušejte program, který řeší zobrazení grafických obrazců, pomocí kterých se zobrazuje stav baterie robota

Funkce: Načítaná hodnota, která je v mV, se vypíše a zároveň přes vzorec převede na procentuelní úroveň a ta se poté vykreslí. Navíc při poklesu napětí pod 6V se ohlásí stav nízké úrovně baterie.


Ukázka programu:

SW-BricxCC ukol 01.jpg 
#include "NXCDefs.h"                      //vložení hlavičkového souboru
 
task main()                               //hlavní funkce
{
 int BatLvl;                              //hodnota baterie
 int BatPos;                              //pozice stavu baterie
 int PercentBat;                          //procentuelní stav baterie
 
 while(true)                              //nekonečná smyčka
  {
    BatLvl = BatteryLevel ();             //stav baterie v mV
    BatPos = ((BatLvl * 78) / 8500);      //vypočítání polohy na grafu stavu baterie
    PercentBat = (BatLvl / 85);
 
    RectOut (10, 25, 80, 22, true);       //vykreslení grafu
    RectOut (11, 26, BatPos, 20);         //vykreslení stavu baterie do grafu
 
    if(BatLvl < 6000) TextOut(10, LCD_LINE1, "Low Batery"); //oznámení nízkého stavu baterie
 
    NumOut(10, LCD_LINE2, BatLvl);        //vypsání hodnoty v mV
    TextOut (36, LCD_LINE2, "mV");
    NumOut(58, LCD_LINE2, PercentBat);    //vypsání hodnoty v %
    TextOut (75, LCD_LINE2, "%");
 
    Wait(10);                             //spoždění 10ms (kvůli problikávajícímu jevu při mazání)
  }
}                                         //konec programu


Ukázky programů pro práci se senzory:

Úkol č. 3

Zadání: Naprogramujte robota tak, aby při stisknutí senzoru doteku zobrazoval na LCD displeji Stisknuto/Rozepnuto.

Funkce: Na LCD displeji je zobrazována hodnota 0=Rozepnuto. Při sepnutí tlačítka se zobrazí hodnota 1=Stisknuto.

Ukázka programu:

Dotek.PNG 
#include "NXCDefs.h"                      //vložení hlavičkového souboru
 
task main()                               //hlavní funkce
{
 SetSensorTouch (IN_1);                   //zapnutí tlačítkového sensoru na portu 1
 
 //SetSensorMode (IN_1, SENSOR_MODE_PULSE); //zapne mod pro čítač - reaguje jen na sestupnou hranu (vypínaní)
 //SetSensorMode (IN_1, SENSOR_MODE_EDGE);  //zapne mod pro čítač - reaguje na vzestupnou i sestupnou hranu
 
 int Touch;                               //proměnná pro uložení stavu tlačítka
 
 while(true)                              //nekonečná smyčka
 { 
  Touch = Sensor (IN_1);                  //zjištění stavu
 
  NumOut (10, LCD_LINE2, Touch);          //vypsání hodnoty na display
 
  if(Touch == true)                       //pokud je stisknuto tlačítko 
  { 
   TextOut (10, LCD_LINE3, "Stisknuto");  //vypsání stavu
  } 
  else 
  {  
   TextOut (10, LCD_LINE3, "Rozepnuto");
  }
 }
}                                         //konec programu



Úkol č. 4

Zadání: Naprogramujte robota tak, aby zobrazoval na LCD displeji hlasitost okolního ruchu.

Funkce: Robot pomocí senzoru hluku snímá hlasitost okolí a tu poté zobrazuje na LCD displeji.

Ukázka programu:

Zvuk.PNG 
#include "NXCDefs.h"                      //vložení hlavičkového souboru
 
task main()                               //hlavní funkce
{ 
 SetSensorSound (IN_2);                   //zapnutí tlačítkového senzoru na portu 1
 
 int Sound;                               //proměná pro uložení hodnoty světla 
 int SoundPos;                            //poloha ekvalizéru
 
 while(true)                              //nekonečná smyčka
 {   
    Sound = Sensor (IN_2);                //stav baterie 
 
    SoundPos = (((Sound * 76) / 100));    //vypočítání polohy ekvalizéru 
 
    RectOut (12,27, SoundPos, 1, true);   //vykreslení ekvalizéru  
    RectOut (10, 25, 80, 5);              //vykreslení grafu   
 
    NumOut(10, LCD_LINE2, Sound);         //vypsání hodnoty   
    Wait(1);                              //spoždění 1ms 
 }
}                                         //konec programu



Úkol č. 5

Zadání: Naprogramujte robota tak, aby pomocí senzoru světla zobrazoval na LCD dipleji hodnotu intenzity světla.

Funkce: Na LCD displeji je zobrazována intenzita světla která se nachází pod senzorem světla.

Ukázka programu:

Svetlo.PNG 
#include "NXCDefs.h"                      //vložení hlavičkového souboru
 
task main()                               //hlavní funkce
{
 SetSensorTouch (IN_1);                   //zapnutí tlačítka
 SetSensorLight (IN_3);                   //zapnutí světelného senzoru  
 
 SetSensorMode (IN_3, IN_MODE_RAW);       //přepnutí módu na rolišení 0 až 1023
 
 int Light;                               //proměná pro uložení hodnoty světla
 bool Touch;                              //proměná pro uložení stavu tlačítka 
 
 while(true)                              //nekonečná smyčka
 {
  Light = Sensor (IN_3);                  //načtení intenzity světla
  Touch = Sensor (IN_1);                  //zjistí stav tlačítka
 
  NumOut (10, LCD_LINE2, Light, true);    //výpis hodnoty 
 
  if(Touch == true)
  {
   SetSensorType (IN_3, IN_TYPE_LIGHT_INACTIVE); //vypnutí LED u světelného senzoru
  }
  else
  {
   SetSensorType (IN_3, IN_TYPE_LIGHT_ACTIVE); //zapnutí LED u světelného senzoru
  }  
 }
}                                         //konec programu



Úkol č. 6

Zadání: Sonar

Funkce:

Ukázka programu:

Sonar.PNG 
#include "NXCDefs.h"                      //vložení hlavičkového souboru
 
task main()                               //hlavní funkce
{
 SetSensorTouch (IN_1);                   //zapnutí tlačítka 
 SetSensorLowspeed (IN_4);                //zapnutí sonaru 
 
 SetSensorMode (IN_1, IN_MODE_PERIODCOUNTER); //přepnutí módu na čítač  
 
 int Tone;                                //tón
 int Frequency;                           //frekvence
 int Distance;                            //vzdálenost 
 int Touch;                               //stav tlačítka  
 
 while(true)                              //nekonečná smyčka
 {   
   //Distance = SensorUS (IN_4);          //načte vzdálenost ze sonaru v cm 
   Touch = Sensor (IN_1);                 //zjistí stav tlačítka 
   Distance = 1;  
 
   if(Touch > 10) ClearSensor (IN_1);     //zajištění přetečení   
 
   Tone = Touch * 100;                    //výpočet tónu   
   Frequency = Tone + Distance;           //výpočet frekvence     
 
   PlayTone(Frequency, 0);                //zahrání zvuku     
 
   TextOut(10, LCD_LINE2, "Ton:", true);  //vypsání hodnot   
   TextOut(10, LCD_LINE4, "Frekvence:"); 
   NumOut (50, LCD_LINE2, Tone);  
   NumOut (50, LCD_LINE4, Frequency); 
 }
}                                         //konec programu



Úkol č. 7

Zadání: Enkodér

Funkce:

Ukázka programu:

Enkoder.PNG 
#include "NXCDefs.h"                      //vložení hlavičkového souboru
 
task main()                               //hlavní funkce
{
 SetSensorTouch (IN_1);                   //zapnutí tlačítkového senzoru na portu 1  
 
 int NXTCounter;                          //proměné pro uložení hodnot z čítačů
 int ServoCounter;
 bool Touch;                              //uložení stavu tlačítka  
 
 while(true)                              //nekonečná smyčka 
 { 
  Touch = Sensor (IN_1);                  //zjištění stavu tlačítka 
  NXTCounter = MotorRotationCount (OUT_B);//zjískání natočení z čítače v NXT 
  ServoCounter = MotorTachoCount (OUT_B); //zjískání natočení z čítače serva   
 
  if(Touch == true) ResetRotationCount (OUT_B); //vynulování čítače v NXT   
 
  TextOut (10, LCD_LINE3, "NXT citac:", true); //zobrazení textu 
  TextOut (10, LCD_LINE4, "Servo citac:");  
 
  NumOut (82, LCD_LINE3, NXTCounter);     //zobrazení hodnot 
  NumOut (82, LCD_LINE4, ServoCounter);  
 
  Wait (1);                               //spoždění 1ms 
 }
}                                         //konec programu



Úkol č. 8

Zadání: Joystick

Funkce:

Ukázka programu:

Joystick.PNG 
#include "NXCDefs.h"                      //vložení hlavičkového souboru 
 
task main()                               //hlavní funkce 
{
 int MiddleY = (Sensor (IN_1) / 3);      //určení Y středu 
 int MiddleX = (Sensor (IN_2) / 3);      //určení X středu  
 
 int PositionX = 0;                       //X pozice kurzoru 
 int PositionY = 0;                       //Y pozice kurzoru  
 
 while(true)                              //nekonečná smyčka  
 {  
  PositionY = (MiddleY - (Sensor (IN_1) / 3)) + 32; //vypočítání pozice 
  PositionX = (MiddleX - (Sensor (IN_2) / 3)) + 50;   
 
  ClearScreen ();                         //smazání obrazovky  
  CircleOut (PositionX, PositionY, 2);    //vykreslení kurzoru  
  Wait(1);                                //čekání 1ms pro odstranění blikání 
 }
}                                         //konec programu


Ukázky programů pro rozpohybování robota:

Úkol č. 9

Zadání: Jízda

Funkce:

Ukázka programu:

Jizda.PNG 
#include "NXCDefs.h"                      //vložení hlavičkového souboru  
task main()                               //hlavní funkce 
{ 
  while(true)                             //nekonečná smyčka  
  {
//jizda bet regulace 
//s brzdou  
   TextOut(1, LCD_LINE3, "Bez regulace", true);  
   TextOut(1, LCD_LINE5, "Brzda");  
   OnFwd (OUT_BC, 60);  
   Wait(1000);  
   Off (OUT_BC);                          //elektronická brzda  
   Wait(1000); 
 
//jizda s regulaci napeti 
//bez brzdy   
   TextOut(1, LCD_LINE3, "Regulace napeti", true); 
   TextOut(1, LCD_LINE5, "Bez brzdy");  
   OnFwdReg (OUT_BC, 60, OUT_REGMODE_SPEED);  
   Wait(1000);  
   Coast (OUT_BC);                        //pozvolné zastavení  
   Wait(1000); 
 
//jizda s regulaci otacek 
//bez brzdy    
   TextOut(1, LCD_LINE3, "Regulace otacek", true);   
   TextOut(1, LCD_LINE5, "Bez brzdy");  
   OnFwdReg (OUT_BC, 60, OUT_REGMODE_SYNC);  
   Wait(1000);   
   Coast (OUT_BC);                        //pozvolné zastavení  
   Wait(1000); 
 } 
}                                         //konec programu



Úkol č. 10

Zadání: Rotace

Funkce:

Ukázka programu:

Rotace.PNG 
#include "NXCDefs.h"                      //vložení hlavičkového souboru  
task main()                               //hlavní funkce 
{ 
  while(true)                             //nekonečná smyčka 
  {
   RotateMotor (OUT_C, 50, 360);          //rotování s kontrolou podle enkodéru  
   Wait(1000);                            //čekání 1s      
 
   OnFwd (OUT_C, 50);                     //rotování jen na základě času  
   Wait(1000);                            //-> rotování 1s  
   Off(OUT_C);                            //zastavení motoru  
   Wait(1000);                            //čekání 1s 
 }
}                                         //konec programu



Úkol č. 11

Zadání: RotSEnkod

Funkce:

Ukázka programu:

Rotsenkod.PNG 
#include "NXCDefs.h"                      //vložení hlavičkového souboru 
 
task main()                               //hlavní funkce
{
 int Rotation;                            //proměná pro uložení natočení 
 
  while(true)                             //nekonečná smyčka 
  {  
   Rotation = MotorTachoCount (OUT_B);    //zjištění natočení motoru B   
 
   NumOut (20, LCD_LINE4, Rotation, true);//vypsání   
 
   RotateMotor (OUT_C, 50, Rotation);     //rotace motoru C stejně jako byl natočen motor B  
 
   ResetTachoCount (OUT_B);               //vynulování natočení 
 } 
}                                         //konec programu


Ukázky složitějších programů:

Úkol č. 12

Zadání: Balanc

Funkce:

Ukázka programu:

Balanc.PNG 
 



Úkol č. 13

Zadání: Tanec

Funkce:

Ukázka programu:

Tanec.PNG 
 



Úkol č. 14 Barvy

Zadání: Tanec

Funkce:

Ukázka programu:

Barvy.PNG 
#include "NXCDefs.h"                              //hlavičkový soubor 
 
int Light;                                        //intenzita světla 
int CalibRange;                                   //kalibrační hodnota  
 
int Factor = 1;                                   //faktor rozptylu 
 
const int white = 710;                            //světelné konstatny pro jednotlivé barvy 
const int yellow = 698; 
const int orange = 694; 
const int red = 690; 
const int lgreen = 630; 
const int lgrey = 620; 
const int lblue = 578; 
const int grey = 546; 
const int blue = 532; 
const int green = 524; 
const int dgrey = 482; 
const int dgreen = 472; 
const int lblack = 415; 
const int dblue = 409; 
const int black = 380;  
 
task main()                                       //hlavní funkce
{  
 
 SetSensorTouch(IN_1);                            //inicializace 
 SetSensorLight(IN_3);  
 
 SetSensorMode (IN_3, IN_MODE_RAW);               //nastavení módu na základní zobrazení  
 
 while (true)                                     //nekonecna smycka 
 {  
  Off(OUT_BC);                                    //vypnutí motorů  
 
  while(true)                                     //cyklus kalibrace 
  {  
   while(Sensor(IN_1));   
    TextOut(4, LCD_LINE1, "Kalibrace");   
 
    SetSensorType (IN_3, IN_TYPE_LIGHT_INACTIVE);   
    Light = Sensor (IN_3);     
 
    TextOut(2, LCD_LINE5, "Svetlo:", true);  
    NumOut(50, LCD_LINE5, Light);  
 
    CalibRange = (Light - 70);   
    TextOut(2, LCD_LINE6, "Calib:" );  
    NumOut(50, LCD_LINE6, CalibRange);   
    if(Sensor(IN_1)) break; 
  }    
 
   while (true)                                 //cyklus měření    
   {    
    while(Sensor(IN_1));   
    TextOut(4, LCD_LINE1, "-Mereni--");   
 
    SetSensorType (IN_3, IN_TYPE_LIGHT_ACTIVE);    
    Light = Sensor(IN_3);   
    TextOut(2, LCD_LINE5, "Svetlo:" );   
    NumOut(50, LCD_LINE5, Light);    
 
 
     if (Light >= ((white + CalibRange) - Factor))                       //bílá   
     {    
       TextOut(10, LCD_LINE2, "-Bila-----" );      
       Factor--;     
     }    
     else if (Light <= ((yellow + CalibRange) + Factor) && Light >= ((yellow + CalibRange) - Factor))    //žlutá      
     {      
       TextOut(10, LCD_LINE2, "-Zluta----" );    
       Factor--;     
     }      
     else if (Light <= ((orange + CalibRange) + Factor) && Light >= ((orange + CalibRange) - Factor))    //oranžová     
     {       
       TextOut(10, LCD_LINE2, "-Oranzova-" );   
       Factor--;    
     }      
     else if (Light <= ((red + CalibRange) + Factor) && Light >= ((red + CalibRange) - Factor))          //červená   
     {      
       TextOut(10, LCD_LINE2, "-Cervena--" );   
       Factor--;     
     }    
     else if (Light <= ((lgreen + CalibRange) + Factor) && Light >= ((lgreen + CalibRange) - Factor))    //světle zelená   
     {      
       TextOut(10, LCD_LINE2, "-S Zelena-" );    
       Factor--;    
     }    
     else if (Light <= ((green + CalibRange) + Factor) && Light >= ((green + CalibRange) - Factor))      //zelená   
     {      
       TextOut(10, LCD_LINE2, "-Zelena---" );   
       Factor--;   
     }     
     else if (Light <= ((dgreen + CalibRange) + Factor) && Light >= ((dgreen + CalibRange) - Factor))    //tmavě zelená   
     {       
       TextOut(10, LCD_LINE2, "-T Zelena-" );    
       Factor--;    
     }    
     else if (Light <= ((lblue + CalibRange) + Factor) && Light >= ((lblue + CalibRange) - Factor))      //světle modrá    
     {      
       TextOut(10, LCD_LINE2, "-S Modra--" );     
       Factor--;  
     }     
     else if (Light <= ((blue + CalibRange) + Factor) && Light >= ((blue + CalibRange) - Factor))        //modrá   
     {     
       TextOut(10, LCD_LINE2, "-Modra----" );     
       Factor--;     
     }      
     else if (Light <= ((dblue + CalibRange) + Factor) && Light >= ((dblue + CalibRange) - Factor))      //tmavě modrá  
     {       
       TextOut(10, LCD_LINE2, "-T Modra--" );      
       Factor--;   
     }     
     else if (Light <= ((grey + CalibRange) + Factor) && Light >= ((grey + CalibRange) - Factor))        //šedá   
     {      
       TextOut(10, LCD_LINE2, "-Seda-----" );      
       Factor--;    
     }     
     else if (Light <= ((black + CalibRange) + Factor))             //černá  
     {      
       TextOut(10, LCD_LINE2, "-Cerna----" );      
       Factor--; 
     }     
     else                                                                //CHYBA     
     {     
       Factor++;   
     }     
 
     if(Sensor(IN_1)) break;   
   }  
 } 
}



Úkol č. 15 Ruka

Zadání: Tanec

Funkce:

Ukázka programu:

Ruka.PNG 
#include "NXCDefs.h"                      //vložení hlavičkového souboru 
#define F  3 
 
task main()                               //hlavní funkce 
{ 
 SetSensorTouch (IN_3);                   //zapnutí tlačítkového sensoru na portu 1 
 SetSensorTouch (IN_4);                   //zapnutí tlačítkového sensoru na portu 1  
 
 int MiddleX = Sensor(IN_1);
 int MiddleY = Sensor(IN_2);  
 
 int Touch1;                              //proměnná pro uložení stavu tlačítka 
 int Touch2;                              //proměnná pro uložení stavu tlačítka 
 int Joystic1;                            //joystic 
 int Joystic2;                            //joystic  
 
 int Rotate; 
 int Altitude;   
 
 int ActualRotate; 
 int ActualAltitude;  
 
 while(true)                              //nekonečná smyčka 
 { 
  ActualAltitude = MotorRotationCount (OUT_B);  
  ActualRotate = MotorRotationCount (OUT_C);    
 
  Joystic1 = Sensor (IN_1);               //zjištění stavu 
  Joystic2 = Sensor (IN_2);               //zjištění stavu 
  Touch1 = Sensor (IN_3);                 //zjištění stavu  
  Touch2 = Sensor (IN_4);                 //zjištění stavu   
 
  Altitude = (Joystic1 - MiddleX) * 3; 
  Rotate = (Joystic2 - MiddleY) * 4;  
 
  if(Touch1)  
  {   
   OnFwd(OUT_A, 20); 
  }
  else if(Touch2) 
  {   
   OnRev(OUT_A, 20);  
  }  
  else  
  {  
   Off(OUT_A); 
  }  
 
  if(Altitude > (ActualAltitude + F))   
  {   
   OnFwd(OUT_B, 40); 
  }  
  else if(Altitude < (ActualAltitude - F))  
  { 
   OnRev(OUT_B, 30); 
  }  
  else   
  {  
   Off(OUT_B); 
  }   
 
  if(Rotate > (ActualRotate + F))  
  {   
   OnFwd(OUT_C, 50);  
  }   
  else if(Rotate < (ActualRotate - F)) 
  {  
   OnRev(OUT_C, 50); 
  }   
  else  
  {  
   Off(OUT_C);  
  } 
 } 
}                                         //konec programu



literatura:

Citováno z „http://wiki.sps-pi.cz/index.php?title=BricxCC&oldid=11367“
Osobní nástroje
Jmenné prostory
Varianty
Akce
Rychlá navigace
NEJ aktivity
Nejlepší předměty
Nejlepší MCU
SW-HW
Ostatní
Utility
Nástroje
Tisk/export