Smartcar

Doel SmartCar project

Smartcar is een low-cost totaalproject rond een robotwagentje met allerlei sensoren en actuatoren, waarbij wetenschappelijke onderzoeksmethoden moeten worden toegepast, technische handelingen uitgevoerd en gereedschappen gehanteerd moeten worden.  Creatieve, probleemoplossende en algoritmische talenten komen sterk aan bod.

Kortom een STEM Totaalproject. Solderen, Tekenen, Ontwerpen, Monteren, Programmeren, 3D printen, Figuurzagen, …. Alles komt aan bod.

Scholen gebruiken dit materiaal als groot STEM of Techniek project of tijdens Robotkampen of Techniekvakanties. Aankopen kan enkel via een jaarlijkse groepsaankoop.

Een samenwerking tussen St.Rembert & VTI in Torhout, Provincie WVL en E2CRE8 heeft als resultaat gehad dat onderstaand lesmateriaal kon worden uitgewerkt. Veel plezier ermee!

  • 20170331_154144
  • 20160321_102235
  • 20170531_153927
  • img_2942
  • dsc00133
  • 2017-roborkamp-programmeren-86
  • 2017-roborkamp-programmeren-75_orig
  • 2017-roborkamp-programmeren-63_orig
  • 2017-roborkamp-programmeren-102_orig
  • 20170531_132144
  • 20170703_162502
  • img 1047_orig
  • 31743704_2060321060648959_4370598444562120704_n
  • img 1052
  • IMG_0087
  • img 20170817 141228_orig
  • SMARTCAR – BRAINBOX ROBOT – ROBOTKAMP

    De Brainbox Robot (BBR) is een elektronicamodule die kan worden ingezet om zelf een intelligent robotwagentje te ontwerpen. Dit wagentje kan worden ingezet tijdens robotkampen of als TOTAAL-STEM project. Creativiteit en STEM doelstellingen staan centraal. Het robotje bevat vele sensoren en actuatoren en is naast tal van andere opties ook bestuurbaar via Bluetooth en zelfgemaakte apps. Deze module is gebaseerd op een Arduino Leonardo en is programmeerbaar met Ardublock, Flowcode en Arduino IDE (C) zodat deze bruikbaar is van de eerste tot de derde graad. Al het lesmateriaal en de demoprogramma’s zijn 100% gratis.

    Het unieke aan dit project is de groepsaankoop. Doordat we al twee jaar met een 25-tal scholen samen een 1000-tal elektronicamodules hebben aangekocht kan de prijs laag gehouden worden. Voor iets meer dan 24€/ stuk heb je heel wat functionaliteit op maat van ons onderwijs.

    Indien u interesse hebt of eens aan de slag wil met een demomodel, aarzel dan zeker niet om ons te contacteren.

    Volgende groepsaankoop start in December 2018

    INFO Groepsaankoop 2017:

    flyerbijlageexcel
    Flyer 2018 met algemene uitleg
    Bijlage met uitleg over alle componenten
    Bestellijst excel – ingevuld doormailen naar barthuyskens(at)telenet.be (at)=@

     

    FILMPJES (nu nog van oud model – binnenkort nieuw filmpje online)

Leerlijn Smartcar Eerste Graad

Leerlijn Smartcar Tweede Graad

Leerlijn Smartcar Leeg

BBR01 HOE WORDT ELEKTRONICA GEMAAKT?

Deze inleidende videolessen geven een mooi beeld van hoe elektronica gemaakt wordt.

BBR01-A Hoe worden printplaten gemaakt? Korte versie

BBR01-B Hoe worden printplaten gemaakt? Volledige versie

BBR01-C Plaatsing componenten op printplaat

BBR02 SOLDEREN

Solderen kan je leren, op slechts enkele minuten zelfs. De korte en lange versie van dit stripboek (gemaakt door Mitch Altman) scherpen je soldeertechniek aan en de powerpoint helpt je stap voor stap bij het solderen van het printplaatje van de Smartcar. Succes!

BBR02-A Soldeerhandleiding

BBR02-C Stripboek 'goed solderen' volledige versie

Gemaakt door Mitch Altman

BBR02-C Strip 'goed solderen' 1 pagina

ingekleurd door Polien Huyskens (10j)

BBR03 MONTAGE & MECHANISCH ONTWERP

Elke deelnemer heeft – afhankelijk van de beschikbare tijd en de keuze van de school – de keuze om zelf een chassis te ontwerpen. Daarvoor kan hout of kunststof met de figuurzaag of lasercutter bewerkt worden. Ook 3D printers kunnen worden ingezet. Onderstaande tekeningen (met dank aan Jan Oostvogels- St.-Jozef Schoten) kunnen hier een hulp bij zijn.

BBR03-A Download dxf en visio tekening basic chassis

BBR03-B Download 3D STEP file Printplaat

BBR03-C Download 3D STEP file Motoren

BBR03-D MONTAGE & MECHANISCH ONTWERP UITDAGINGEN

  1. Gebruik de tekening van BBR03-A om alle juiste maten over te zetten op een triplex plaatje van 3mm. Maak correct en zorgvuldig gebruik van figuurzaag, boormachine, vijl en schuurpapier om uw eigen chassis te verwezenlijken. Creatieve zielen mogen de buitenvorm zelf aanpassen maar blijf er wel op letten dat de robot moet kunnen rijden.
  2. Maak gebruik van een 2D of 3D tekenpakket om uw eigen chassis te ontwerpen met de computer. Tekendata BBR03-A, B en C kunnen u hierbij helpen. Maak correct gebruik van een lasercutter om uw chassis te verwezenlijken. Het is de bedoeling dat elke student een ander chassis heeft.
  3. Maak gebruik CAD software, van 3D printer en/of lasercutter om één of meer onderdelen of mannetjes op of onder de smartcar te bevestigen. Dit kan zowel functioneel als esthetisch zijn.

BBR04 SOFTWARE (installatie en instellingen)

De elektronica van de smartcar is opgebouwd rond een Arduino Leonardo processor (ATMEGA32U4) en kan geprogrammeerd worden met verschillende programmeertalen. 

  • ARDUBLOCK (custom versie) voor de eerste & tweede graad
  • ARDUINO IDE voor de tweede & derde graad
  • AVR STUDIO voor de derde graad

De instructies voor installatie en de nodige instellingen kan u hieronder terugvinden.

BBR04-A Download Arduino IDE V1.8.5

BBR04-B Download Ardublock versie 2018

BBR04-C Videoles Installatie Ardublock

BBR04-D Videoles rondleiding door Ardublock

BBR04-D Uploaden nieuw programma naar Smartcar

BBR04-F Download Blokschema en pin layout

BBR04-G Download Spiekbrief Arduino IDE

BBR04-H Download Arduino programming notebook (Eng)

BBR04-I Powerpoint programmeren via AB

BBR04-J Downloads

  1. LCD NewLiquidCrystal library
  2. Wire.h library (is normaal reeds geïnstalleerd)

Spiekbrief Ardublock

BBR05 TESTEN

Nu de elektronica gesoldeerd is en de volledige ‘smartcar’ opgebouwd is, is het tijd om te testen of alles werkt. Daarvoor gebruiken we onderstaande hulpmiddelen.

BBR05-A Powerpoint Jumpers en Testen

BBR05-B Testprogramma's Ardublock

Dit “Smartcar_testprogramma_001” Ardublock programma doorloopt eerst 5x een loop waarin de actuatoren (luidspreker, leds, motoren) getest worden. Daarna wordt in een eeuwige loop de waarden van alle sensoren weergegeven via de Serial Monitor. Deze Checklist is op maat van dit programma gemaakt.

BBR05-C Testprogramma's Arduino IDE

Dit Smartcar_testprogramma_001 Arduino IDE programma doorloopt eerst 5x een loop waarin de actuatoren (luidspreker, leds, motoren) getest worden. Daarna wordt in een eeuwige loop de waarden van alle sensoren weergegeven via de Serial Monitor. Deze Checklist is op maat van dit programma gemaakt


.zip bestand met ALL_IN DEMOPROGRAMMA onder Arduino IDE waarmee alle functies (incl bluetooth en LCD) van de BBR module afzonderlijk getest kunnen worden via de twee drukknoppen. Uitleg staat in de inleiding.


.zip bestand met Demoprogramma (herwerkt door F Bremer ROC Twente) waarmee alle functies van de BBR module kunnen worden uitgetest via een aangesloten LCD.

BBR06 RIJDEN

Eindelijk zijn we zover dat we de robot kunnen programmeren om te rijden. Volg onderstaande lessen aandachtig, dan ben je zo op weg.

BBR06-A Videoles werkingsprincipe DC motor

BBR06-B Videoles opbouw motor Smartcar

BBR06-C Videoles Ardublock & Rijden

BBR06-D Rijden Uitdagingen

  1. Wetenschap & Wiskunde: Koppel 2 DC motoren met elkaar met twee draadjes zodat de ene de functie van generator heeft en de andere motor is. Niet alle energie die wordt opgewekt in de generator zal de DC motor bereiken, we hebben dus een verlies van energie. Bedenk nu zelf een methode om het verlies in onze motortjes te bepalen en uit te drukken in %.
  2. Wiskunde: Zet in de software de snelheid van de motortjes op 255. Je mag enkel gebruik maken van een rechte meetlat. Kan jij nu een methode betalen wat de snelheid van dit wagentje is in Meter per seconde of in kilometer per uur? Kan je ook nog een andere methode bedenken?
  3. Engineering: Schrijf een programma (en test dit uit) om de wagen in een rechte lijn te laten rijden en na exact 3 meter te laten stoppen.
  4. Engineering: Schrijf een programma (en test dit uit) om de wagen in een vierkant te laten rijden.
  5. Engineering: Schrijf een programma (en test dit uit) om de wagen in een driehoek te laten rijden.

BBR07 LEDS

Op de Smartcar staan er 4 leds die je kan programmeren, maar wat zijn leds juist? Waar worden leds gebruikt? Hoe kan je zelf de weerstand voor een led berekenen en wat is de kleurcode van weerstanden. Dat kom je allemaal in dit stuk te weten. 

BBR07-A Videoles LED toepassing en werking

BBR06-B Videoles LED Polariteit en Vorm

BBR06-C Videoles LED Serieweerstand Vuistregel

BBR07-D Videoles LED Serieweerstand Berekening

BBR06-E Videoles Weerstanden Kleurcode

BBR06-F Videoles leds programmeren met Ardublock

BBR07-G LEDS Uitdagingen

  1. Wetenschap: Het menselijke oog heeft een bepaalde traagheid. Dat wil zeggen dat ons oog en onze hersenen een bepaalde tijd nodig hebben om een beeld te kunnen begrijpen. Als beelden te snel afwisselen zien we geen verschil meer. Film en TV technologie zijn helemaal gebaseerd op deze traagheid. Schrijf nu een programma, of een reeks van programma’s die met behulp van de leds deze ‘traagheid’ van ons oog kan bepalen? Vanaf welke snelheid zien we het verschil niet meer tussen aan en uit?
  2. Engineering: Schrijf een programma om een looplichtje te maken. (Er is telkens maar één ledje aan en dit loopt van links naar rechts en terug)

BBR08 RINGTONE

Het luidsprekertje op de Smartcar kan elektrische signalen omzetten in hoorbaar geluid. De toonhoogte is afhankelijk van de frequentie van het elektrische signaal. Die frequentie kunnen we bepalen in ons programma. Door de juiste frequenties na elkaar te programmeren kunnen we zelf een ringtone maken. Ga jij die uitdaging aan? Rock-on!

BBR08-A Videoles Ringtone

BBR08-B Ringtone - tabel

BBR08-D RINGTONE Uitdagingen

  1. Wetenschap: Het menselijke oor heeft beperkingen. Zo kunnen kleine kinderen in theorie frequenties horen tussen 20Hz en 20KHz. Door blootstelling aan harde geluiden is ons oor na verloop van tijd niet meer in staat om die hoge frequenties te horen. Zo is het mogelijk dat volwassenen bepaalde tonen – die voor jongeren nog perfect hoorbaar zijn – niet meer horen. Kan jij een programma, of een reeks van programma’s schrijven waarmee je kan uittesten wat de hoogste frequenties zijn die jij nog kan horen? Test dit ook bij je klasgenoten en bij enkele volwassenen. Wat besluit je?
  2. Engineering: Schrijf een programma dat een originele sirene laat horen.
  3. Engineering & Kunst: gebruik de tabellen in bijlage en muziekstukken die je op het internet kan terugvinden om een programma te schrijven dat uw muziekstuk hoorbaar maakt met de luidspreker op de BBR.

BBR09 LICHTSENSOREN

De Smartcar elektronica heeft 2 lichtsensoren die elk afzonderlijk kunnen meten hoeveel licht er op invalt. Zo kan je de Smartcar programmeren om te reageren op licht of om naar een lichtbron te rijden.

BBR09-A Videoles Analoge tov Digitale sensoren

BBR09-B Videoles Lichtsensor Toepassing en Werking

BBR09-C Videoles Lichtsensor & Ardublock

BBR09-D LICHTSENSOR Uitdagingen

  1. Wetenschap: Sensoren zijn niet in alle richtingen even gevoelig. De mate waarin een sensor gevoelig is in een bepaalde richting wordt weergegeven met een polair diagramma. Kan jij het polair diagramma van de lichtsensor op de Smartcar bepalen? Je mag gebruikmaken van het blad in bijlage en van een klein led lampje.
  2. Engineering & Milieu: schrijf een programma dat de leds van de BBR aan laat gaan als het licht in het lokaal uit gaat. Zo zou je het licht in een gebouw zo kunnen programmeren dat het pas aangaat als het buiten donker begint te worden om zo energie te besparen.
  3. Engineering & Milieu: schrijf een programma dat de leds van de BBR harder laat branden als de lichtsensor minder licht meet. Zo zou je het niveau van de lichten in een gebouw kunnen regelen in functie van de hoeveelheid buitenlicht om zo energie te besparen.
  4. Engineering & Milieu: schrijf een programma dat de robot ter plaatse laat ronddraaien en zo in de richting van de felste lichtbron blijft stilstaan door gebruik te maken van de twee lichtsensoren. Dit zelfde programma kan je ook gebruiken om bijvoorbeeld een draaibare installatie met zonnepanelen altijd naar de zon te richten voor een optimale opbrengst.
  5. Engineering: schrijf een programma dat de robot in de richting van de felste lichtbron te laten rijden door gebruik te maken van de twee lichtsensoren. Zo kan je met een zaklamp de robot besturen.

Werkblad Polair Diagramma

BBR10 AFSTANDSENSOREN

De Smartcar elektronica heeft 2 afstandsensoren die d.m.v. onzichtbaar infrarood licht een afstand tot obstakels kunnen meten. Zo kan je de Smartcar programmeren om obstakels te ontwijken, heel gelijkaardig aan de sensoren die op moderne wagens gebruikt worden om te parkeren of aanrijdingen te voorkomen.

BBR010-A Videoles Analoge tov Digitale sensoren

BBR10-B Afstandsensor Werking

BBR10-C Videoles Afstandsensoren, Variabelen en Seriële monitor

BBR10-D AFSTANDSENSOR Uitdagingen

  1. Wetenschap: Sensoren zijn niet in alle richtingen even gevoelig. De mate waarin een sensor gevoelig is in een bepaalde richting wordt weergegeven met een polair diagramma. Kan jij het polair diagramma van de afstandsensor op de Smartcar bepalen? Je mag gebruikmaken van het blad in bijlage.
  2. Wetenschap: Verschillende lichtbronnen (Gloeilamp, Halogeenlamp, TL lamp, LED lamp, Zonlicht, …) stralen een bepaalde mate van Infrarood licht uit. IR licht is onzichtbaar voor het menselijke oog en is in dat geval een vorm van licht waar we wel energie in moeten steken, maar waar we niets mee zijn.  Kan jij, door gebruik te maken van de IR sensor van de Smartcar, experimenteel bepalen hoeveel IR licht deze verschillende lichtbronnen uitstralen?
  3. Wetenschap: Niet alle oppervlakken reflecteren even goed. Kan jij m.b.v. de IR sensor in een proefopstelling bepalen welke oppervlakken beter of minder goed licht reflecteren? Formuleer ook je besluit.
  4. Engineering : Schrijf een programma dat de robot achteruit laat rijden als je dichterbij komt met je hand. De robot heeft in dit geval ‘schrik’ van je hand.
  5. Engineering : Schrijf een programma dat de robot laat rondrijden zonder tegen obstakels te botsen.
  6. Engineering : Richt de IR sensoren van twee Smartcars naar elkaar. Smartcar 1 gebruikt enkel de zender en Smartcar 2 enkel de ontvanger. Kan jij nu een programma schrijven waarmee je met de drukknoppen van Smartcar 1 de leds op Smartcar 2 aan laat gaan? 

Werkblad Polair Diagramma

BBR11 LIJNVOLGSENSOREN

De Smartcar elektronica heeft onderaan twee lijnvolgsensoren. Deze digitale sensoren geven een “1” terug als ze een zwarte lijn zien en een “0” wanneer ze een wit oppervlak zien. 

BBR11-A Videoles Werking lijnsensor

BBR11-B Videoles Strategie Lijnvolgen

BBR10-C Videoles Lijnsensoren & Ardublock

BBR11-D LIJNSENSOR Uitdagingen

  1. Engineering: Teken een groot zwart vierkant met dikke lijnen (30mm). Programmeer de Smartcar om rond te rijden in dit vierkant zonder over de lijnen te komen.
  2. Engineering: Schrijf een programma om de Smartcar een zwarte lijn op een witte achtergrond te laten volgen. Test je programma uit en pas het aan zodat je smartcar ook moeilijkere parcours kan volgen.

BBR12 LCD

LCD’s kunnen tijdens het uitvoeren van het programma meetgegevens tonen. Onze LCD’s communiceren met de BBR module via het I2C protocol. Er zijn twee types: 2 lijnen van 16 karakters of 4 lijnen van 20 karakters.

LCD 1

BBR12-A LCD Handleiding

BBR13 BLUETOOTH

De Smartcar besturen met je Smartphone of meetgegevens van de sensoren weergeven op je Smartphone. Het is allemaal perfect mogelijk via een low-cost HC06 Bluetooth module. De Apps maak je trouwens helemaal zelf in Appinventor.

hc06

BBR13-A Videoles Sturen en Meten met BT

BBR13-B Aansluitschema & Strategie

BBR13-C Appinventor programma (AIA & APK)

BBR13-D Arduino IDE code

  • // code written by Bart Huyskens  05/01/2018  for www.e2cre8.be
    // hardware: Brainbox Robot (www.e2cre8.be >> Brainbox Robot)(Based on Arduino Leonardo) ; HC06 Bluetooth module www.e2cre8.be ; Android Smartphone ; I2C LCD 4x20 www.e2cre8.be
    // software: Arduino IDE 1.6.11 ; Appinventor
    // Principle of communication:
    // The app sends data to the uC in this format: "L:xxx;R:xxx;" where xxx is data between 0-255. 
    // The speed is determined by the TimerInterval of Timer1 in Appinventor and this needs to be identical to the variable "TimerIntervalAppinventor" in this program
    // Speeds up to 100msec seem to be OK, but if you do not need this speed, use 1000msec
    // The uC waits checks for incoming data at half of "TimerIntervalAppinventor" -time to be sure to not miss to much
    // The uC send 4 sensor values to the app, every 2x "TimerIntervalAppinventor". This needs to be double the time for appinventor to be ready to receive the next data
    // comment out the LCD lines if you do not have a I2C LCD connected
    
    // Arduino preprocessor directives //
    #include 
    #include 
    #include 
    
    #define TimerIntervalAppinventor 100 // this value needs to be equal to the value of the timer in Appinventor
                                        // tested & works pretty stable at 100msec, but if you don't need the speed, set it at 1000msec both here and in Appinventor
    #define PWM_LEFTMOTOR 6             // pin number for speed left motor
    #define DIR_LEFTMOTOR 14            // pin number for direction (forward / backward) left motor
    #define PWM_RIGHTMOTOR 5            // pin number for speed right motor
    #define DIR_RIGHTMOTOR 16           // pin number for direction (forward / backward) right motor
    
    #define tx 1                        // pin number for TX pin
    #define rx 0                        // pin number for RX pin
    #define LIGHTSENSL A0   
    #define LIGHTSENSR A1  
    #define IRSENSL A2   
    #define IRSENSR A3   
    #define IRLEDL 9   
    #define IRLEDR 10  
    #define BUZZER 7 
    #define LED11 11
    #define LED13 13
    #define LED30 30
    #define LED17 17
    #define LINEL 4
    #define LINER 12
    #define SWL 8
    #define SWR 22
    
    // Declaration of variables //
    
    int NrOfCycles;       // to slow down the transmission of data
    int YValue = 127;
    int XValue = 127;
    int YValueOld = 127;
    int XValueOld = 127;
    int i=0;
    int z=0;
    int connectionOK = 0;
    int DC_LEFT = 0;
    byte DIR_LEFT = 0;
    int DC_RIGHT = 0;
    byte DIR_RIGHT = 0;
    byte ReceiveX = 127;
    byte ReceiveY = 127;
    int DISTSENSL = 0;
    int DISTSENSR = 0;
    int LIGHTSENSVALUEL = 0;
    int LIGHTSENSVALUER = 0;
    
    char inSerial[25]="L:0;R:0;Z";    // Array of characters (is not a string)- used to read the received data
    String myString;                  // used to do string manipulations on the received data    
    
    LiquidCrystal_I2C lcd_I2C_27(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
    
    void setup()
      {
      Serial.begin(9600);             //Bautrate speed For Serial monitor 
      Serial1.begin(9600);            //Bautrate speed For comms with HC06 - baudrate 9600
    
    // configuration of input/output pins 
      pinMode(DIR_LEFTMOTOR, OUTPUT);
      pinMode(DIR_RIGHTMOTOR, OUTPUT);
      pinMode(PWM_LEFTMOTOR, OUTPUT);
      pinMode(PWM_RIGHTMOTOR, OUTPUT);
      pinMode(tx, OUTPUT);
      pinMode(rx, INPUT);
      pinMode(IRLEDL, OUTPUT);
      pinMode(IRLEDR, OUTPUT);
      pinMode(BUZZER, OUTPUT);
      pinMode(LED11, OUTPUT);
      pinMode(LED13, OUTPUT);
      pinMode(LED30, OUTPUT);
      pinMode(LED17, OUTPUT);
      pinMode(LINEL, INPUT);
      pinMode(LINER, INPUT);
      pinMode(SWL, INPUT);
      pinMode(SWR, INPUT);
        
      lcd_I2C_27.begin (20, 4);
      lcd_I2C_27.setBacklight(HIGH);
      }
    
    void loop()
    {
     delay(TimerIntervalAppinventor/2);       // timerInterval of Appinventor devided by 2, to be ready to receive all incoming data
     NrOfCycles = NrOfCycles + 1;             // transmission of data can only execute after 4 receive cycles
    
     //***RECEIVING DATA ***//
     if (Serial1.available() > 0)             // If receiving serial data from HC06
        {
        connectionOK = 1;                    // only start sending data after reception of first data -else uC crashes
        i=0;
        while (Serial1.available())         // while receiving serial data from HC06
          {
          inSerial[i]=Serial1.read();        // load incoming bytes in array
          i++;                              // increment i 
          }
        }
    
      //***TRANSMITTING DATA ****//
      if ((NrOfCycles >= 4)&& connectionOK)        // transmission of data can only execute after 4 receive cycles for Appinventor to be ready to receive data
      {
      Serial1.print(DISTSENSL);            // send varialble via Serial1 to HC06
      Serial1.print('|');                 // send '|' character - appinventor uses this to split the data
      Serial1.print(LIGHTSENSVALUEL);
      Serial1.print('|');
      Serial1.print(LIGHTSENSVALUER);
      Serial1.print('|');
      Serial1.print(DISTSENSR);
      Serial1.print('|');
      NrOfCycles = 0;
      }
    
      // Decode incoming data (ascii format) to usable values
        Serial.print(inSerial);               // Serial Monitor print received data 
        myString = String(inSerial);          // convert array to string to be able to use string manipulation instructions (indexOf...)
    
        int Xpos = myString.indexOf('X');                           // find the position of character 'R' in the string
        int m = 0;
        XValueOld = XValue;
        XValue = 0; // reset L value
        while ((myString.charAt(Xpos+2+m)) != ';')                  //convert characters into RValue numbers untill character ';'
          {                                                         // start 2 positions after character 'R'
          XValue = XValue *10 + ((myString.charAt(Xpos+2+m))-48);   //char '0' has ascii value 48
          if ((XValue > 255) || (XValue <0)) XValue = XValueOld;    // protection from corrupt data
          m++;
          }
        
        int Ypos = myString.indexOf('Y');                           // find the position of character 'R' in the string
        m = 0;
        YValueOld = YValue;
        YValue = 0;                                                 // Reset R Value
        while ((myString.charAt(Ypos+2+m)) != ';')                  //convert characters into RValue numbers untill character ';'
          {                                                         // start 2 positions after character 'R'
          YValue = YValue *10 + ((myString.charAt(Ypos+2+m))-48);   //char '0' has ascii value 48
          if ((YValue > 255) || (YValue <0)) YValue = YValueOld;    // protection from corrupt data
          m++;
          }
    
    
        Serial.print("\t");                   // Serial monitor - TAB
        Serial.println(XValue);               // Serial monitor Value of R
        Serial.print("\t");                   // Serial monitor - TAB
        Serial.println(YValue);               // Serial monitor Value of L
      
      lcd_I2C_27.clear(); 
      lcd_I2C_27.setCursor( (1) - 1, (1) - 1 );
      lcd_I2C_27.print( "WWW.E2CRE8.BE BT" );   
       
      lcd_I2C_27.setCursor( (1) - 1, (2) - 1 );
      lcd_I2C_27.print( "L:" );
      lcd_I2C_27.print( String(ReceiveX));
      lcd_I2C_27.setCursor( (9) - 1, (2) - 1 );
      lcd_I2C_27.print( "R:" );
      lcd_I2C_27.print( String(ReceiveY));
      
      if (connectionOK != 1)
    {
      lcd_I2C_27.setCursor( (1) - 1, (3) - 1 );
      lcd_I2C_27.print( "NO CONNECT. WITH APP" ); 
    }
    else
    {
      lcd_I2C_27.setCursor( (1) - 1, (3) - 1 );
      lcd_I2C_27.print( "CONNECTED WITH APP" ); 
    }
    
    ///****DRIVING MOTORS****///
    // recalculating Left-right values from X/Y values - 4 quadrants
    
    ReceiveY = YValue;      // copy received value to workvariable
    ReceiveX = XValue;
      if ((ReceiveY >=128)&&(ReceiveX >= 128)) // forward - right
        {
        DIR_LEFT = 0; // forward
        DIR_RIGHT = 0; // forward
        DC_LEFT = ((ReceiveY - 127)*2);
        if (DC_LEFT > 254)DC_LEFT = 255;
        if (DC_LEFT < 0)DC_LEFT = 0;
        DC_RIGHT = ((ReceiveY - 127)*2)-(ReceiveX - 127);
        if (DC_RIGHT > 254)DC_RIGHT = 255;
        if (DC_RIGHT < 0)DC_RIGHT = 0;
        }
        
      else if ((ReceiveY >= 128)&&(ReceiveX <= 127)) // forward left
        {
        DIR_LEFT = 0; // forward
        DIR_RIGHT = 0; // forward
        DC_LEFT = ((ReceiveY - 127)*2)-(127-ReceiveX);
        if (DC_LEFT > 254)DC_LEFT = 255;
        if (DC_LEFT < 0)DC_LEFT = 0;
        DC_RIGHT = ((ReceiveY - 127)*2);
        if (DC_RIGHT > 254)DC_RIGHT = 255;
        if (DC_RIGHT < 0)DC_RIGHT = 0;
        }
        
       else if ((ReceiveY <= 127)&&(ReceiveX <= 127)) // forward left
        {
        DIR_LEFT = 1; // backwards
        DIR_RIGHT = 1; // backwards
        DC_LEFT = 255-(((127-ReceiveY)*2)-(127-ReceiveX));
        if (DC_LEFT > 254)DC_LEFT = 255;
        if (DC_LEFT < 0)DC_LEFT = 0;
        DC_RIGHT = 255-((127-ReceiveY)*2);
        if (DC_RIGHT > 254)DC_RIGHT = 255;
        if (DC_RIGHT < 0)DC_RIGHT = 0;
        }
        else if ((ReceiveY <= 127)&&(ReceiveX >= 128)) // forward left
        {
        DIR_LEFT = 1; // backwards
        DIR_RIGHT = 1; // backwards
        DC_LEFT = 255-((127-ReceiveY)*2);
        if (DC_LEFT > 254)DC_LEFT = 255;
        if (DC_LEFT < 0)DC_LEFT = 0;
        DC_RIGHT = 255-(((127-ReceiveY)*2)-(ReceiveX-127));
        if (DC_RIGHT > 254)DC_RIGHT = 255;
        if (DC_RIGHT < 0)DC_RIGHT = 0;
        }
        else
        {
        DIR_LEFT = 0; // forward
        DIR_RIGHT = 0; // forward
        DC_LEFT =0;
        DC_RIGHT =0;
        }
        
        // these lines write the calculated values to the two motors of the BBR
        analogWrite(PWM_LEFTMOTOR, DC_LEFT);
        digitalWrite(DIR_LEFTMOTOR, DIR_LEFT);
        analogWrite(PWM_RIGHTMOTOR, DC_RIGHT);
        digitalWrite(DIR_RIGHTMOTOR, DIR_RIGHT);
     
     
     // READING SENSOR VALUES
        digitalWrite( IRLEDL , HIGH );              // IR emittor ON
        delay( 1 );                                 // wait 1msec to stabilize
        DISTSENSL = analogRead(IRSENSL) ;             // read IR sensor
        digitalWrite( IRLEDL , LOW );               // IR emittor OFF
        digitalWrite( IRLEDR , HIGH );              // IR emittor ON
        delay( 1 );                                 // wait 1msec to stabilize
        DISTSENSR = analogRead(IRSENSR) ;             // read IR sensor  
        digitalWrite( IRLEDR , LOW );               // IR emittor OFF
    
        LIGHTSENSVALUEL = analogRead(LIGHTSENSL) ;    // read lightsensor value
        LIGHTSENSVALUER = analogRead(LIGHTSENSR) ;    // read lightsensor value
        
    }