document.write('
Data hosted with ♥ by Pastebin.com - Download Raw - See Original
  1. /*******************************************************************************
  2.  Projektname:       RC5.cprj
  3.  Benötigte Libs´s:  IntFunc_lib.cc
  4.  Routinen:          lcd.cc, PRO-BOT128C_Lib_V2.cc
  5.  Autor:             Niels
  6.  Datum:             28. 05. 2013
  7.  
  8.  Funktion:          RC5-Fernsteuerung: Kanal und Tastencode ausgeben.
  9.                     Ausgabe von Vorwärts/Links/Rechts/Halt/Rückwärts.
  10.                     Verwendet werden die Cursortasten der Fernbedienung.
  11.                     Fahrbefehle erzeugen.
  12.                     Neu: Auswertung der Kanalnummern, so dass mehrere PRO-BOT
  13.                     gleichzeitig fahren können.
  14. *******************************************************************************/
  15. // Geeignete Programme der Fernbedienung
  16. // 0027 Kanal 0
  17. // 0223 Kanal 2
  18. // 0334 Kanal 6
  19. // 0335 Kanal 5
  20.  
  21. // 0027 Kanal 0
  22. //      42
  23. // 11   43   10
  24. //      46
  25. //
  26. //0223 Kanal 2
  27. //      42
  28. // 11   43   10
  29. //      xx
  30. //
  31. // 0334 Kanal 6
  32. //      46
  33. // 50   53   52
  34. //      44
  35. //
  36. // 0335 Kanal 5
  37. //      46
  38. // 50   53   52
  39. //      44
  40.  
  41. // Compiler-Direktiven
  42. #define RC5DATAMASK 0b0000000000111111 // 6 Bit Datenwert-Maske
  43. #define RC5CHANNELMASK 0b0000000000011111 // 5 Bit Kanalinfo-Maske
  44. #define SPEED1 170
  45. #define SPEED2 250
  46.  
  47. void main(void)
  48. {
  49.  
  50. PRO_BOT128_INIT();    //PRO-BOT128 Setup
  51. LCD_Init();
  52. RC5_Init(26);
  53. AbsDelay(100);       //Wait 0,1 Sec.
  54. LCD_ClearLCD();
  55.  
  56. Akkuspg(); // Ausgabe der Akkuspannung
  57. LCD_ClearLCD();
  58.  
  59. // Definieren von Variablen (Reservierung im RAM-Speicher)
  60. int RC5Value; // Hier speichern wir die Roh-Empfangsdaten der FB
  61. int RC5Data; // Hier nur die letzten 6 Bit von RC5Value speichern
  62. int RC5Channel; // Kanal der Fernbedienung (5 Bit)
  63. int OwnRC5Channel; // Eingestellter Kanal des PRO-BOT
  64. int ChannelArray[4] = {0, 2, 5, 6};
  65. OwnRC5Channel=ChannelArray[0]; // Zuweisung des 1. Arraywertes
  66. byte ChannelCounter;
  67. ChannelCounter=0;
  68. byte SizeOfArrayChannel;
  69. SizeOfArrayChannel=3; // 4 Werte im Array
  70.  
  71. LCD_Locate(1, 1);
  72. LCD_WriteText("My Channel  = ");
  73. LCD_WriteWord(ChannelCounter, 2);
  74.  
  75. DRIVE_ON(); //Motorspannung an
  76. MOTOR_DIR(1,1); //beide Motoren vorwärts   - MOTOR DIRECTION
  77.  
  78. // Endlos-Schleife
  79.     do
  80.       {
  81.       RC5Value=RC5_Read();
  82.       // RC5-Tastencode ermitteln und ausgeben
  83.       LCD_Locate(1, 1);
  84.       RC5Data=RC5Value;
  85.       // RC5Data=RC5Data+5; // Wertzuweisung für eine Variable
  86.       // RC5Data+=5; // genau das Gleiche wie davor
  87.       // 00 1XX KKKKK DDDDDD RC5-Rohwert von der FB
  88.       // K = Kanalwert (5 Bit) - D = RC5-Daten / Tastencode (6 Bit)
  89.       // Bsp.: 110 00001 001010 - Kanal = 1 und RC5-Daten = 10
  90.       RC5Data=RC5Data&RC5DATAMASK; // Maskierung der letzten 6 Bit
  91.       // LCD_WriteWord(RC5Data, 2); // Zur Ausgabe ganzzahliger Werte auf LCD
  92.       LCD_WriteText("_");
  93.       // Kanal ausgeben
  94.       // Der Wert in RC5Value wird in RC5Channel kopiert
  95.       RC5Channel=RC5Value; // Gleichheitszeichen ist eine Zuweisung
  96.       // Rechtsverschiebung um 6 Stellen / 6 Bits:
  97.       RC5Channel=RC5Channel>>6; // Rechtsverschiebung / >> Verschiebeoperator
  98.       // Wir haben folgenen Wert in RC5Channel: z.B. 110 00001
  99.       // Die linken 3 Bit müssen weg!
  100.       // Dazu haben wir die RC5CHANNELMASK 000 11111
  101.       // Nach einer UND-Verknüpfung bleiben nur die 5 Bit (rechts) übrig
  102.       // Also in unserem Beispiel bleibt übrig: 000 00001
  103.       RC5Channel= RC5Channel&RC5CHANNELMASK; // Maskierung
  104.       //LCD_WriteWord(RC5Channel, 2);
  105.  
  106.       // Kanal einstellen auf Tastendruck
  107.        if (SW2!=0)
  108.            {
  109.                 //Tastendruck
  110.                 LCD_Locate(1, 15);
  111.                 ChannelCounter++;
  112.                 //if (ChannelCounter>(sizeof(ChannelArray)))
  113.                 if (ChannelCounter>SizeOfArrayChannel)
  114.                 {
  115.                     ChannelCounter=0;
  116.                 }
  117.                 // LCD_WriteWord(ChannelCounter, 2); // Erster Schritt
  118.                 OwnRC5Channel=ChannelArray[ChannelCounter];
  119.                 LCD_WriteWord(OwnRC5Channel, 2); // Zweiter Schritt
  120.                 SW2=0; // Muss nach Abholung zurück gesetzt werden
  121.            }
  122.  
  123.       // Tastencode erkennen und auf Zeile 2 in Klarschrift ausgeben
  124.       // Nur für Code 0223 oder 0027 - da diese dieselben Tastencodes haben
  125.       if (RC5Channel==OwnRC5Channel)
  126.       {
  127.  
  128.         LCD_Locate(2, 1);
  129.         switch(RC5Data)
  130.           {
  131.           case 42:    LCD_WriteText("Vorwaerts");
  132.                       MOTOR_DIR(1,1); //MOTOR DIRECTION
  133.                       DRIVE_ON(); //Motorspannung an
  134.                       MOTOR_POWER(SPEED2, SPEED1);
  135.                       break;
  136.           case 11:    LCD_WriteText("Links!!!!");
  137.                       MOTOR_DIR(1,1); //MOTOR DIRECTION
  138.                       DRIVE_ON(); //Motorspannung an
  139.                       MOTOR_POWER(0, SPEED1);
  140.                       break;
  141.           case 10:    LCD_WriteText("Rechts!!!");
  142.                       MOTOR_DIR(1,1); //MOTOR DIRECTION
  143.                       DRIVE_ON(); //Motorspannung an
  144.                       MOTOR_POWER(SPEED2, 0);
  145.                       break;
  146.           case 43:    LCD_WriteText("Stopp!!!!");
  147.                       DRIVE_OFF(); //Motorspannung an
  148.                       break;
  149.                       /*
  150.           case 46:    LCD_WriteText("Zurueck!!");
  151.                       MOTOR_DIR(0,0); //MOTOR DIRECTION
  152.                       DRIVE_ON(); //Motorspannung an
  153.                       MOTOR_POWER(SPEED2, SPEED1);
  154.                       break;
  155.                       */
  156.           }
  157.         }
  158.  
  159.     }
  160.     while(1);
  161. }
  162.  
  163. // Wir lagern Programmcode in eine (Unter-)Funktion aus
  164. int Akkuspg(void)
  165. {
  166.     LCD_ClearLCD();
  167.     //LCD auf Zeile 1 Position 1 setzen:
  168.     LCD_Locate(1, 1);
  169.     LCD_WriteText("Akkuspannung:"); //Begruessung
  170.     LCD_Locate(2, 1);
  171.     float Akkuspannung;
  172.     Akkuspannung=AKKU_SPG();
  173.     LCD_WriteFloat(Akkuspannung, 6);
  174.     AbsDelay(2000);       //Wait 2 Sec.
  175.     return 0;
  176. }
');