Arduino C

English

YN AROS AM GYFIEITHIAD - DYCHWELWCH YN FUAN

Cyflwyniad i Raglennu yn Arduino C

Rydym wedi addasu'r deunydd a grëwyd ar gyfer ein Clwb Roboteg i unrhyw un allu ei ddefnyddio gartref neu yn yr ysgol.

Mae pob un o'r sesiynau isod yn cynnwys gwers fideo gan un o'n staff a set o ymarferion er mwyn asesu eich dealltwriaeth. Gan fod y dudalen hon ar gyfer dysgwyr annibynnol, mae'r atebion wedi'u cynnwys.

Rydym yn argymell bod dysgwyr yn ymweld â'n Cyfres Micro:Bit Ar-lein yn gyntaf i gael cyflwyniad i raglennu, a'n Cyfres Electroneg Ar-lein i ddeall mwy am y caledwedd a'r feddalwedd a ddefnyddir.

Dewiswch bennawd sesiwn i ddechrau arni.

Gwers Fideo (yn Saesneg)

Ymarferion:

Bydd angen i chi gopïo ein 'Valiant' Robot Tinkercad circuit i'ch cyfrif Tinkercad ar gyfer yr ymarferion hyn

I gael eich atgoffa o sut i fewngofnodi a defnyddio Tinkercad, gweler Sesiwn Un o'n Cyfres Electroneg Ar-lein

Mae'r heriau hyn yn golygu dechrau rhaglennu robot 'Valiant'.

Dylai pob dysgwr ddechrau ar lefel efydd a gweithio eu ffordd i fyny cyn belled ag y bo modd.

Cliciwch ar bennawd pob her i'w ehangu.



Pwysig: Gwnewch yn siŵr bod panel cod ar Tinkercad wedi'i osod i Text, fel y dangosir yma:

Sgrinlun o banel cod Tinkercad gyda'r bocs cwymp chwith ar y brig yn dangos 'Text'.

Y rhaglen a ddarperir yw rhaglen Arduino ddiofyn Tinkercad sy'n goleuo LED yr Arduino ac yn ei ddifodd.

Dilëwch gynnwys y void setup() a'r void loop() fel bod eich cod cychwyn yn edrych fel hyn:

              
    //C++ code
    //
    void setup ()
    {
      
    }

    void loop ()
    {

    }
  1. Diffiniwch pin 13 (lle mae'r LED wedi'i gysylltu) fel pin allbwn yn y void setup() (ar ddechrau).


    • Wrth ddefnyddio rhaglennu bloc, mae llawer o'r gosodiad wedi ei gynnwys yn awtomatig ar ein cyfer. Nawr mae'n rhaid i ni ysgrifennu hwn ein hunain.

    • Rydym yn defnyddio pinMode() i ganfod pin sy'n cael ei ddefnyddio a gweld a yw'n INPUT neu'n OUTPUT.

    • Y tu mewn i gromfachau pinMode() mae angen i ni ychwanegu rhif y pin a'i fod yn OUTPUT.

    • Peidiwch ag anghofio'r hanner colon (;) ar ddiwedd y cyfarwyddyd.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


                        
    //C++ code
    //
    void setup ()
    {
      pinMode(13, OUTPUT);
    }

    void loop ()
    {

    }

  2. Y tu mewn i'r void loop() (dolen am byth) ysgrifennwch y cod i oleuo'r LED hwn a'i ddiffodd.

    Awgrym: Bydd angen i chi ychwanegu delay() o 100ms rhwng newidiadau golau er mwyn eu gweld yn yr efelychydd.


    • Rydym yn defnyddio'r LED fel allbwn digidol (golau ymlaen neu'n diffodd) ar gyfer yr ymarfer hwn.

    • Defnyddiwch gyfarwyddiadau digitalWrite() i ddweud wrth gydran ddigidol am droi ymlaen neu ddiffodd.

    • Y tu mewn i gromfachau'r gorchymyn digitalWrite() mae angen i ni gynnwys y pin rydym ni'n ei newid ac yna HIGH neu LOW.

    • Cofiwch, wrth godio, rydym ni'n defnyddio HIGH i roi rhywbeth i fynd LOW i'w ddiffodd.

    • Mae'r cyfarwyddyd delay() yn gwneud i'r rhaglen aros am y cyfnod o amser a nodir y tu mewn i'r cromfachau - wedi'i fesur mewn milieiliadau.

    • Cofiwch, mae'r void loop() yn gweithio'r un fath â dolen am byth.

    • Mae angen i bob cyfarwyddyd/llinell orchymyn ddod i ben gyda hanner colon (;) neu ni fydd y rhaglen yn gweithio.

    • Gallwch ddefnyddio'r efelychydd i wneud yn siŵr bod eich cod yn gweithio - dylai'r LED glas yn y gylched fflachio ymlaen ac i ffwrdd yn gyflym.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


                        
    //C++ code
    //
    void setup ()
    {
      pinMode(13, OUTPUT);
    }

    void loop ()
    {
      digitalWrite(13, HIGH);
      delay(100);
      digitalWrite(13, LOW);
      delay(100);
    }




  1. Ysgrifennwch y cyfarwyddyd sydd ei angen i roi gwybod i'n rhaglen fod gennym ni LDR/Photoresistor wedi'i gysylltu â phin A0.

    Awgrym: Mae'r LDR/Photoresistor yn ddyfais mewnbwn analog.


    • Mae angen iddo fynd i mewn i'r void setup().

    • Mae'n defnyddio'r gorchymyn pinMode() fel yr eglurir yn yr ymarferion Lefel Efydd.

    • Yn yr achos hwn, y wybodaeth allweddol sydd ei hangen yw bod y gydran yn defnyddio pin A0 a'i bod yn INPUT.

    • Does dim angen i'r gosodiad wybod a yw cydran yn ddigidol neu'n analog - bydd y wybodaeth hon yn ddefnyddiol ar ôl i ni ddechrau rhaglennu'r gwrthydd golau-ddibynnol (LDR)/'Photoresistor'.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


                        
    //C++ code
    //
    void setup ()
    {
      pinMode(13, OUTPUT);
      pinMode(A0, INPUT);
    }

    void loop ()
    {
      digitalWrite(13, HIGH);
      delay(100);
      digitalWrite(13, LOW);
      delay(100);
    }

  2. Yn yr un modd â'n pinnau, i ddefnyddio'r monitor cyfresol yn ein rhaglen, mae angen i ni ei gynnwys yn y gosodiad.

    Awgrym: Dangoswyd sut mae sefydlu'r monitor cyfresol yn y wers fideo.


    • Bydd angen i chi ddefnyddio cyfarwyddyd Serial.begin() () y tu mewn i'r void setup().

    • Y cyflymder cyfathrebu yw'r gwerth y tu mewn i'r cromfachau ar gyfer y gorchymyn cyfresol - rydym yn argymell eich bod yn defnyddio 9600 fel gwerth diofyn.

    • Sylwer bod y cyfarwyddyd hwn ychydig yn wahanol gan ei fod yn dechrau gyda phriflythyren.

    • Nid yw hyn yn agor y monitor cyfresol yn awtomatig i chi, ond mae'n rhoi gwybod i'r rhaglen y byddwn yn ei ddefnyddio.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


                        
    //C++ code
    //
    void setup ()
    {
      pinMode(13, OUTPUT);
      pinMode(A0, INPUT);
      Serial.begin(9600);
    }

    void loop ()
    {
      digitalWrite(13, HIGH);
      delay(100);
      digitalWrite(13, LOW);
      delay(100);
    }

  3. Creu newidyn o'r enw 'ldrValue' i storio gwerth y darlleniad LDR a'i osod i 0 wrth ddechrau.

    Awgrym: Mae'r gwerthoedd hyn yn gyfanrifau (rhifau cyfan). Mae hyn yn golygu bod angen i ni ddweud wrth y rhaglen fod hwn yn newidyn gyda math int.


    Pwysig: Mae'r lle y caiff newidyn ei greu yn y rhaglen yn penderfynu ble gellir ei ddefnyddio.

    Ar gyfer y pwnc hwn, byddwn yn defnyddio Newidynnau Drwy'r Cyfan. Mae'r rhain yn newidynnau rydyn ni'n eu diffinio ar ddechrau rhaglen, cyn y void setup() hyd yn oed. Mae hyn yn golygu y gallwn wedyn eu defnyddio mewn unrhyw ran a phob rhan o'r rhaglen.

    Pe byddech chi'n creu newidyn y tu mewn i ddolen/swyddogaeth, dim ond y tu mewn i'r un ddolen/swyddogaeth honno y byddai'n hygyrch ac nid yn unrhyw ran arall o'r rhaglen. Byddai hyn yn cael ei alw'n Newidyn Lleol. Cofiwch, mae hyn yn golygu y bydd y newidyn yn cael ei ail-greu bob tro y bydd y ddolen/swyddogaeth y mae wedi ei osod ynddi yn rhedeg.


    • Mae rhai ieithoedd rhaglennu, fel Arduino C, angen i ni ddweud wrtho pa fath o newidyn ydyw. Dim ond wrth greu'r newidyn y mae angen i chi gynnwys math y newidyn, nid wrth ei ddefnyddio.

    • Mae hwn yn newidyn drwy'r cyfan ac felly mae angen ei greu ar ddechrau'r rhaglen.

    • Cyflwynwyd yr arfer da o osod newidynnau i 0 trwy gydol ein pynciau Micro:Bit ac Electroneg i'ch helpu i gofio gwneud hynny mewn ieithoedd seiliedig ar destun.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


                        
    //C++ code
    //
    int ldrValue = 0;

    void setup ()
    {
      pinMode(13, OUTPUT);
      pinMode(A0, INPUT);
      Serial.begin(9600);
    }

    void loop ()
    {
      digitalWrite(13, HIGH);
      delay(100);
      digitalWrite(13, LOW);
      delay(100);
    }

  4. Y tu mewn i'r void loop(), gwnewch yn siŵr bod eich newidyn gwrthydd golau-ddibynnol newydd (LDR) yn cyfateb i ddarlleniad y synhwyrydd LDR. Yna bydd y rhaglen yn argraffu gwerth y newidyn hwn i'r monitor cyfresol.

    Awgrym: Mae'r LDR yn fewnbwn analog ac mae wedi'i gysylltu â phin A0.


    • Mae rhaglenni Arduino yn 'darllen' mewnbynnau ac yn 'ysgrifennu' allbynnau.

    • Defnyddiwch gyfarwyddyd analogRead() gyda'r pin a nodir tu mewn i'w gromfachau.

    • Mae gorchymyn Serial.print() yn dweud wrth y rhaglen am argraffu beth bynnag sydd o fewn ei gromfachau ar linell newydd y monitor cyfresol.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


                        
    //C++ code
    //
    int ldrValue = 0;

    void setup ()
    {
      pinMode(13, OUTPUT);
      pinMode(A0, INPUT);
      Serial.begin(9600);
    }

    void loop ()
    {
      digitalWrite(13, HIGH);
      delay(100);
      digitalWrite(13, LOW);
      delay(100);
      ldrValue = analogRead(A0);
      Serial.println(ldrValue);
    }



Mae dadfygiwr wedi ei adeiladu i mewn i olygydd cod Tinkercad. Mae hyn yn rhoi gwybod i ni pan fydd gwall yn y cod a'r math o wall. Mae'n rhedeg bob tro y byddwn yn dechrau'r efelychiad. Yn yr ymarfer hwn byddwn yn cyflwyno gwallau i'n rhaglen er mwyn ein helpu i'w cyfateb i'r negeseuon gwall.

Newidiwch eich void setup() i gyd-fynd â phob un o'r enghreifftiau isod er mwyn gweld y neges gwall a gynhyrchir.

Awgrym: gall y rhifau ar ddechrau'r negeseuon gwall fod yn wahanol gan eu bod yn cyfeirio at rifau llinell yn y cod sy'n dibynnu ar eich bylchiad.

1. Colli '}':

                
    void setup ()
    {
      pinMode(13, OUTPUT);
      pinMode(A0, INPUT);
      Serial.begin(9600);
    
    
    void loop ()

2. Colli '{':

                
    void setup ()
    
      pinMode(13, OUTPUT);
      pinMode(A0, INPUT);
      Serial.begin(9600);
    }

3. Colli ';':

                
    void setup ()
    {
      pinMode(13, OUTPUT);
      pinMode(A0, INPUT)
      Serial.begin(9600);
    }

4. Colli '()':

                
    void setup 
    {
      pinMode(13, OUTPUT);
      pinMode(A0, INPUT);
      Serial.begin(9600);
    }

5. Camgymeriad Sillafu:

                
    void setup ()
    {
      pinMoed(13, OUTPUT);
      pinMode(A0, INPUT);
      Serial.begin(9600);
    }

6. Colli ',':

                
    void setup ()
    {
      pinMode(13 OUTPUT);
      pinMode(A0, INPUT);
      Serial.begin(9600);
    }
               
              


  1. 
    In function 'void setup()':
    13:1: error: a function-definition is not allowed here before '{' token   
    20:1: error: expected '}' at end of input
                    

  2. 
    7:3: error: expected initializer before 'pinMode'
    8:10: error: expected constructor, destructor, or type conversion before '(' token    
    9:3: error: 'Serial' does not name a type
    10:1: error: expected declaration before '}' token
                    

  3. 
      In function 'void setup()':
    9:3: error: expected ';' before 'Serial'    
                    

  4. 
    5:6: error: variable or field 'setup' declared void
    7:22: error: expected '}' before ';' token
    8:10: error: expected constructor, destructor, or type conversion before '(' token    
    9:3: error: 'Serial' does not name a type
    10:1: error: expected declaration before '}' token
                    

  5. 
      In function 'void setup()':
    7:3: error: 'pinMoed' was not declared in this scope    
    7:3: note: suggested alternative: 'pinMode'
                    

  6. 
    1:0:
      In function 'void setup()':
    44:16: error: expected ')' before numeric constant


    7:14: note: in expansion of macro 'OUTPUT'
    7:20: error: too few arguments to function 'void pinMode(uint8_t, uint8_t)'    
    1:0:
    134:6: note: declared here




Gwers Fideo (yn Saesneg)

Ymarferion:

Mae'r ymarferion hyn yn parhau i ddefnyddio'r rhaglen a ddatblygwyd yn Sesiwn Un.

Dylai pob dysgwr ddechrau ar lefel efydd a gweithio eu ffordd i fyny cyn belled ag y bo modd.

Cliciwch ar bennawd pob her i'w ehangu.



  1. Ar gyfer yr ymarfer hwn, byddwn yn newid yr hyn y mae'r bwlb LED yn ei wneud felly mae angen i ni gael gwared â'r cyfarwyddiadau sy'n gwneud iddo fflachio.

    Awgrym: Gan ein bod yn dal i ddefnyddio'r LED, peidiwch â thynnu gosodiad pinMode.


    • Dim ond y llinellau a grëwyd yng ngham 2 Lefel Efydd yn Sesiwn Un y mae angen eu dileu.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


                        
  //C++ code
  //
  int ldrValue = 0;

  void setup ()
  {
    pinMode(13, OUTPUT);
    pinMode(A0, INPUT);
    Serial.begin(9600);
  }

  void loop ()
  {
    ldrValue = analogRead(A0);
    Serial.println(ldrValue);
  }

  2. Crëwch newidyn math cyfanrif newydd o'r enw blueLED a'i osod i 13 (rhif y pin y mae wedi'i gysylltu iddo).

    Awgrym: Os gwnaethoch chi gwblhau'r ymarfer estyniad cyntaf yn llwyddiannus yn Sesiwn Un, cewch hepgor y cam hwn.


    • Mae hwn yn newidyn drwy'r cyfan felly mae angen ei sefydlu ar ddechrau'r rhaglen cyn y void setup().

    • Sicrhewch fod y newidyn newydd hwn yn hafal i 13.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


                        
  //C++ code
  //
  int blueLED = 13;
  int ldrValue = 0;

  void setup ()
  {
    pinMode(13, OUTPUT);
    pinMode(A0, INPUT);
    Serial.begin(9600);
  }

  void loop ()
  {
    ldrValue = analogRead(A0);
    Serial.println(ldrValue);
  }

  3. Crëwch newidyn math cyfanrif newydd o'r enw LDR a gosodwch hwn i A0.

    Awgrym: Er ei bod yn ymddangos bod A0 yn gymysgedd o nodau a llythrennau, mae'n rhif pin ac felly caiff ei gydnabod fel cyfanrif.


    • Mae hwn yn newidyn drwy'r cyfan felly mae angen ei sefydlu ar ddechrau'r rhaglen cyn y void setup().

    • Sicrhewch fod y newidyn newydd hwn yn hafal i A0.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


                        
  //C++ code
  //
  int ldr = A0;
  int blueLED = 13;
  int ldrValue = 0;

  void setup ()
  {
    pinMode(13, OUTPUT);
    pinMode(A0, INPUT);
    Serial.begin(9600);
  }

  void loop ()
  {
    ldrValue = analogRead(A0);
    Serial.println(ldrValue);
  }

  4. Nawr, rhowch y newidyn cywir ym mhob lleoliad lle caiff y pinnau eu cofnodi fel rhifau (13 ac A0) yn y rhaglen. Mae hyn yn golygu, os newidir y pin y mae cydran wedi'i chysylltu iddo, dim ond mewn un lle y mae angen addasu'r cod - sef y lle caiff y newidyn ei greu.


    • Bydd angen galw newidyn 'blueLED' unwaith yn y void setup().

    • Mae angen galw newidyn LDR unwaith yn y void setup() ac unwaith yn y void loop().

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


                        
  //C++ code
  //
  int ldr = A0;
  int blueLED = 13;
  int ldrValue = 0;

  void setup ()
  {
    pinMode(blueLED, OUTPUT);
    pinMode(ldr, INPUT);
    Serial.begin(9600);
  }

  void loop ()
  {
    ldrValue = analogRead(ldr);
    Serial.println(ldrValue);
  }

  5. Ychwanegwch ddatganiad-os i'ch void loop() sy'n rhoi'r bwlb LED ymlaen pan fydd y darlleniad LDR yn llai na 160.

    Awgrym: Os aethoch chi i'r afael â'r ymarferion estyniad yn Sesiwn Un, dim ond yr amod ar gyfer y datganiad-os mae angen i chi ei newid.


    • Cofiwch ddefnyddio ein newidynnau newydd wrth alw'r pinnau.

    • Bydd angen arall-datganiad i ddiffodd yr LED pan fydd y cyflwr yn ffug.

    • Sicrhewch fod eich cyfarwyddiadau o fewn cromfachau cyrliog {} y datganiad.

    • Rydym yn defnyddio'r LED fel allbwn digidol. Mae hyn yn golygu y bydd angen i ni ddefnyddio gorchmynion digitalWrite gyda gwerthoedd HIGH a LOW.

    • Peidiwch ag anghofio rhedeg yr efelychiad er mwyn profi eich rhaglen.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


                        
  //C++ code
  //
  int ldr = A0;
  int blueLED = 13;
  int ldrValue = 0;

  void setup ()
  {
    pinMode(blueLED, OUTPUT);
    pinMode(ldr, INPUT);
    Serial.begin(9600);
  }

  void loop ()
  {
    ldrValue = analogRead(ldr);
    Serial.println(ldrValue);
    if (ldrValue < 160)
    {
      digitalWrite(blueLED, HIGH);
    }
    else
    {
      digitalWrite(blueLED, LOW);
    }
  }




  1. Rydyn ni nawr am ddechrau rhaglennu ein servo. I wneud hyn, mae angen i ni ddweud wrth y rhaglen am ddefnyddio llyfrgell servo - yn debyg i'r cam o ychwanegu'r estyniad servo i ddewislen bloc y Micro:Bit.

    Awgrym: Enw'r llyfrgell/estyniad yw Servo.h


    • Rydym yn defnyddio'r gorchymyn #include i ychwanegu llyfrgell/estyniad.

    • Mae enw'r llyfrgell/estyniad yn cael ei roi o fewn cromfachau onglog < >.

    • I gael mynediad i'r llyfrgell/estyniad trwy gydol ein rhaglen (drwy'r cyfan), mae angen i ni wneud hyn cyn ein void setup().

    • Nid oes gan gyfarwyddyd #include hanner colon (;) ar y diwedd.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


                        
  //C++ code
  //

  #include <Servo.h>

  int ldr = A0;
  int blueLED = 13;
  int ldrValue = 0;

  void setup ()
  {
    pinMode(blueLED, OUTPUT);
    pinMode(ldr, INPUT);
    Serial.begin(9600);
  }

  void loop ()
  {
    ldrValue = analogRead(ldr);
    Serial.println(ldrValue);
    if (ldrValue < 160)
    {
      digitalWrite(blueLED, HIGH);
    }
    else
    {
      digitalWrite(blueLED, LOW);
    }
  }

  2. Ychwanegwch servo i'ch rhaglen o'r enw myServo gan ddefnyddio'r gorchmynion llyfrgell newydd.

    Awgrym: Gall llyfrgelloedd ychwanegol fod â gwahanol ffyrdd o gynhyrchu newidynnau. Yn yr achos hwn, defnyddiwn y gorchymyn Servo variableName; i ychwanegu servo.


    • Mae hwn yn newidyn drwy'r cyfan y mae angen ei osod ar ddechrau'r rhaglen.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


                        
  //C++ code
  //

  #include <Servo.h>
  Servo myServo;

  int ldr = A0;
  int blueLED = 13;
  int ldrValue = 0;

  void setup ()
  {
    pinMode(blueLED, OUTPUT);
    pinMode(ldr, INPUT);
    Serial.begin(9600);
  }

  void loop ()
  {
    ldrValue = analogRead(ldr);
    Serial.println(ldrValue);
    if (ldrValue < 160)
    {
      digitalWrite(blueLED, HIGH);
    }
    else
    {
      digitalWrite(blueLED, LOW);
    }
  }

  3. Crëwch newidyn math cyfanrif drwy'r cyfan newydd o'r enw servoPin a'i osod i 12. Defnyddiwch y newidyn newydd hwn yn y void setup() i ddweud wrth y rhaglen pa bin mae myServo wedi'i gysylltu iddo.

    Awgrym: Mae'r gorchymyn llyfrgell Servo ar gyfer adnabod pinnau yn wahanol eto. Bydd angen i chi ddefnyddio strwythur gorchymynservoName.attach(pin);


    • Gosodwch y newidyn servoPin newydd yn yr un ffordd ag y gwnaethom ar gyfer newidynnau LDR a blueLED.

    • Gan ddefnyddio strwythur gorchymyn servoName.attach(pin); rhowch myServo yn lle servoName a servoPin yn lle'r pin.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


                        
  //C++ code
  //

  #include <Servo.h>
  Servo myServo;

  int servoPin = 12;
  int ldr = A0;
  int blueLED = 13;
  int ldrValue = 0;

  void setup ()
  {
    pinMode(blueLED, OUTPUT);
    pinMode(ldr, INPUT);
    Serial.begin(9600);
    myServo.attach(servoPin);
  }

  void loop ()
  {
    ldrValue = analogRead(ldr);
    Serial.println(ldrValue);
    if (ldrValue < 160)
    {
      digitalWrite(blueLED, HIGH);
    }
    else
    {
      digitalWrite(blueLED, LOW);
    }
  }

  4. Y tu mewn i'r void loop(), ysgrifennwch raglen gan ddefnyddio cyfarwyddiadau myServo.write(angle); i wneud i'r servo symud rhwng onglau 0°, 90°, 180°, and back to 90°. Cynhwyswch un eiliad o saib ar ôl pob symudiad.

    Awgrym: Mae cyfarwyddyd delay(); yn defnyddio milieiliadau ar gyfer y gwerth y tu mewn i'r cromfachau. 1000 milieiliadau = 1 eiliad.


    • Mae'r oedi 1000ms yn angenrheidiol i roi amser i'r servo gwblhau symudiad cyn dechrau'r nesaf.

    • Does dim angen symbol ° ar werth yr ongl yn y gorchymyn.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


                        
  //C++ code
  //

  #include <Servo.h>
  Servo myServo;

  int servoPin = 12;
  int ldr = A0;
  int blueLED = 13;
  int ldrValue = 0;

  void setup ()
  {
    pinMode(blueLED, OUTPUT);
    pinMode(ldr, INPUT);
    Serial.begin(9600);
    myServo.attach(servoPin);
  }

  void loop ()
  {
    ldrValue = analogRead(ldr);
    Serial.println(ldrValue);
    if (ldrValue < 160)
    {
      digitalWrite(blueLED, HIGH);
    }
    else
    {
      digitalWrite(blueLED, LOW);
    }
    myServo.write(0);
    delay(1000);
    myServo.write(90);
    delay(1000);
    myServo.write(180);
    delay(1000);
    myServo.write(90);
    delay(1000);
  }




  1. Crëwch newidyn drwy'r cyfan newydd o'r enw piezo neu piezoPin i storio gwerth y pin ar gyfer y swnyn piezo.

    Awgrym: Bydd angen i chi edrych ar y gylched i wybod pa bin yw hwn.


    • Cofiwch, ystyrir bod pob pin rhaglenadwy, gan gynnwys y rhai sydd â'r llythyren A yn eu henwau, yn rhifau/cyfanrifau

    • Y pin rhaglenadwy ar gyfer y swnyn piezo yw'r un sydd wedi ei gysylltu i'w derfynell bositif.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


                        
  //C++ code
  //

  #include <Servo.h>
  Servo myServo;

  int piezo = A3;
  int servoPin = 12;
  int ldr = A0;
  int blueLED = 13;
  int ldrValue = 0;

  void setup ()
  {
    pinMode(blueLED, OUTPUT);
    pinMode(ldr, INPUT);
    Serial.begin(9600);
    myServo.attach(servoPin);
  }

  void loop ()
  {
    ldrValue = analogRead(ldr);
    Serial.println(ldrValue);
    if (ldrValue < 160)
    {
      digitalWrite(blueLED, HIGH);
    }
    else
    {
      digitalWrite(blueLED, LOW);
    }
    myServo.write(0);
    delay(1000);
    myServo.write(90);
    delay(1000);
    myServo.write(180);
    delay(1000);
    myServo.write(90);
    delay(1000);
  }

  2. Gan ddefnyddio ein newidyn piezo newydd, sefydlwch y pinMode() ar gyfer y swnyn y tu mewn i'r void setup().

    Awgrym: Bydd angen i chi ystyried a yw'r swnyn yn fewnbwn neu'n allbwn.


    • Mae'r piezo buzzer yn ddyfais allbwn analog.

    • Rhowch sylw i ba ddisgrifiadau y mae angen eu hysgrifennu mewn priflythrennau.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


                        
  //C++ code
  //

  #include <Servo.h>
  Servo myServo;

  int piezo = A3;
  int servoPin = 12;
  int ldr = A0;
  int blueLED = 13;
  int ldrValue = 0;

  void setup ()
  {
    pinMode(blueLED, OUTPUT);
    pinMode(ldr, INPUT);
    Serial.begin(9600);
    myServo.attach(servoPin);
    pinMode(piezo, OUTPUT);
  }

  void loop ()
  {
    ldrValue = analogRead(ldr);
    Serial.println(ldrValue);
    if (ldrValue < 160)
    {
      digitalWrite(blueLED, HIGH);
    }
    else
    {
      digitalWrite(blueLED, LOW);
    }
    myServo.write(0);
    delay(1000);
    myServo.write(90);
    delay(1000);
    myServo.write(180);
    delay(1000);
    myServo.write(90);
    delay(1000);
  }

  3. Rhaglennwch eich swnyn i seinio am 0.5 eiliad yn ôl y darlleniad LDR. Yr amodau yw:

    • Os yw lefel y golau yn llai na 60, chwarae amledd tôn 65.
    • Arall, os yw lefel y golau yn llai na 100, chwarae amledd tôn 82.
    • Arall, os yw lefel y golau yn llai na 160, chwarae amledd tôn 98.
    • Arall, os yw lefel y golau yn llai na 220, chwarae amledd tôn 131.
    • Arall, os yw lefel y golau yn llai na 280, chwarae amledd tôn 165.
    • Arall, os yw lefel y golau yn llai na 340, chwarae amledd tôn 196.
    • Arall, os yw lefel y golau yn llai na 400, chwarae amledd tôn 262.
    • Arall, os yw lefel y golau yn llai na 460, chwarae amledd tôn 330.
    • Arall, os yw lefel y golau yn llai na 520, chwarae amledd tôn 392.
    • Arall, chwarae amledd tôn 523.

    Awgrym: Rhowch sylw i ddechrau pob amod i gael cliw ynghylch pa ddatganiadau sydd eu hangen ar gyfer pob un.


    • Bydd angen i chi greu os-datganiad, 8 arall-os datganiad ac arall-datganiad. Dylai'r rhain fod yn yr adran void loop() eich rhaglen.

    • Bydd rhaglenni'n mynd i lawr yr holl opsiynau nes bod un yn wir. Yna bydd yn perfformio'r camau cod a rhoi'r gorau i fynd i lawr y rhestr. Golyga hyn mai dim ond y lefel golau uchaf mae angen i ni ei ysgrifennu ym mhob datganiad.

    • Dylid ysgrifennu'r cyfarwyddyd: tone(pin, frequency, duration);

    • Mae gennym newidyn i'w ddefnyddio ar gyfer y pin, darperir yr amleddau, ac mae'r hyd yn cael ei fesur mewn milieiliadau (felly 0.5 eiliad = 500 milieiliad).

    • Pan fyddwch chi'n profi'r rhaglen, bydd saib rhwng pob tôn gaiff ei chwarae wrth i'r cyfarwyddiadau eraill gael eu cwblhau yn y void loop().

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


                        
  //C++ code
  //

  #include <Servo.h>
  Servo myServo;

  int piezo = A3;
  int servoPin = 12;
  int ldr = A0;
  int blueLED = 13;
  int ldrValue = 0;

  void setup ()
  {
    pinMode(blueLED, OUTPUT);
    pinMode(ldr, INPUT);
    Serial.begin(9600);
    myServo.attach(servoPin);
    pinMode(piezo, OUTPUT);
  }

  void loop ()
  {
    ldrValue = analogRead(ldr);
    Serial.println(ldrValue);
    if (ldrValue < 160)
    {
      digitalWrite(blueLED, HIGH);
    }
    else
    {
      digitalWrite(blueLED, LOW);
    }
    myServo.write(0);
    delay(1000);
    myServo.write(90);
    delay(1000);
    myServo.write(180);
    delay(1000);
    myServo.write(90);
    delay(1000);
    if (ldrValue < 60)
    {
      tone(piezo, 65, 500);
    }
    else if (ldrValue < 100)
    {
      tone(piezo, 82, 500);
    }
    else if (ldrValue < 160)
    {
      tone(piezo, 98, 500);
    }
    else if (ldrValue < 220)
    {
      tone(piezo, 131, 500);
    }
    else if (ldrValue < 280)
    {
      tone(piezo, 165, 500);
    }
    else if (ldrValue < 340)
    {
      tone(piezo, 196, 500);
    }
    else if (ldrValue < 400)
    {
      tone(piezo, 262, 500);
    }
    else if (ldrValue < 460)
    {
      tone(piezo, 330, 500);
    }
    else if (ldrValue < 520)
    {
      tone(piezo, 392, 500);
    }
    else 
    {
      tone(piezo, 523, 500);
    }
  }


Ar gyfer yr ymarferion hyn byddem yn argymell eich bod yn defnyddio copi o'ch rhaglen rhag ofn i bethau fynd o chwith.

Mapio: Fel gyda'r codio bloc blaenorol yn Makecode a Tinkercad, mae'n bosib mapio amrediad o werthoedd o fewnbynnau i allbynnau yn lle cael os-datganiadau mor hir.

Ar gyfer hyn mae angen i ni greu gwerth i gynnal y mapio:

int mappedVariable = map(inputValue, inputMin, inputMax, outputMin, outputMax);

Er enghraifft, os hoffem fapio amrediad potensiomedr (mewnbwn analog) i LED (allbwn analog), i wneud yr LED yn fwy disglair wrth i werth y potensiomedr gynyddu, mae angen y wybodaeth ganlynol arnom:

  • inputValue: Dyma werth presennol y potensiomedr.
  • inputMin: Gwerth lleiaf posib y potensiomedr (0).
  • inputMax: Gwerth mwyaf posib y potensiomedr (1023).
  • outputMin: Gwerth lleiaf posib yr LED (0).
  • outputMax: Gwerth mwyaf posib yr LED (255).

Byddai'r rhaglen yn edrych rhywbeth fel hyn:

            
  int potPin = A4;
  int ledPin = 9;
  int potValue = 0;
  int potMapLED = 0;

  void setup()
  {
    pinMode(potPin, INPUT);
    pinMode(ledPin, OUTPUT);
  }

  void loop()
  {
    potValue = analogRead(potPin);
    potMapLED = map(potValue, 0, 1023, 0, 255);
    analogWrite(ledPin, potMapLED);
  }
  1. Yn eich rhaglen, mapiwch amrediad y mewnbwn LDR i ongl y Servo.

    Awgrym: Amrediad LDR yn yr efelychydd Tinkercad yw 6 i 679. Caiff ongl y servo fod yn unrhyw beth rhwng 0 a 180.


  2. Nawr ceisiwch fapio'r LDR i'r swnyn piezo.

    Ystod amlder y swnyn yw 31 i 4978.


Gwers Fideo (yn Saesneg)

Ymarferion:

Byddwn yn parhau â'r rhaglen a gynhyrchwyd yn Sesiwn Dau.

Dylai pob dysgwr ddechrau ar lefel efydd a gweithio eu ffordd i fyny cyn belled ag y bo modd.

Cliciwch ar bennawd pob her i'w ehangu.


Bydd yr ymarferion hyn yn dangos i chi sut i sefydlu swyddogaethau modur ar gyfer y robot hwn.

  1. Ychwanegwch 4 newidyn math cyfanrif newydd ar ddechrau eich rhaglen ar gyfer y canlynol:

    Newidyn o'r enw leftForwardPin sydd wedi'i osod i 10,
    Newidyn o'r enw leftReversePin sydd wedi'i osod i 11,
    Newidyn o'r enw rightForwardPin sydd wedi'i osod i 9,
    Newidyn o'r enw rightReversePin sydd wedi'i osod i 6.


    • Mae angen i'r rhain fynd cyn y void setup() er mwyn i ni gael eu defnyddio drwy'r cyfan.

    • Os nad ydych yn siŵr, edrychwch ar y newidynnau math cyfanrif blaenorol sydd wedi eu hysgrifennu yn eich rhaglen yn barod.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.

    Dangosir y rhan o'r rhaglen a newidiwyd isod. Bydd y rhaglen lawn yn cael ei hychwanegu ar ddiwedd pob lefel.

                        
  //C++ code
  //

  #include <Servo.h>
  Servo myServo;

  int leftForwardPin = 10;
  int leftReversePin = 11;
  int rightForwardPin = 9;
  int rightReversePin = 6;
  int piezo = A3;
  int servoPin = 12;
  int ldr = A0;
  int blueLED = 13;
  int ldrValue = 0;

  void setup ()

  2. Nawr mae angen i ni osod y modd pin ar gyfer pob un o'r rhain, gan ddefnyddio ein newidynnau newydd.


    • Mae moduron yn ddyfeisiau allbwn.

    • Er enghraifft: pinMode(leftForwardPin, OUTPUT);

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.

    Dangosir y rhan o'r rhaglen a newidiwyd isod. Bydd y rhaglen lawn yn cael ei hychwanegu ar ddiwedd pob lefel.

                        
  void setup ()
  {
    pinMode(leftForwardPin, OUTPUT);
    pinMode(leftReversePin, OUTPUT);
    pinMode(rightForwardPin, OUTPUT);
    pinMode(rightReversePin, OUTPUT);
    pinMode(blueLED, OUTPUT);
    pinMode(ldr, INPUT);
    Serial.begin(9600);
    myServo.attach(servoPin);
    pinMode(piezo, OUTPUT);
  }

  3. Nawr mae angen i ni greu ein swyddogaethau ein hunain ar gyfer gwahanol gyfeiriadau'r robot (ymlaen, yn ôl, i'r chwith, i'r dde, a stopio).

    Awgrym: Mae'r moduron a ddefnyddir yn y gylched hon yn ddyfeisiau digidol.


    • Byddem yn awgrymu gosod y swyddogaethau newydd hyn ar ôl eich newidynnau drwy'r cyfan ond cyn y void setup(). Bydd hyn yn lleihau'r risg o gymysgu'r swyddogaethau newydd hyn yn ddamweiniol o fewn y rhaglen bresennol.

    • Mae swyddogaeth newydd yn dechrau gyda void functionName() { } gyda'r cyfarwyddiadau y tu mewn i'r cromfachau cyrliog.

    • Ysgrifennir enwau swyddogaethau mewn testun camel (dechrau gyda llythyren fach, dim bylchau, a phob gair newydd yn dechrau gyda phriflythyren).

    • Y tu mewn i bob swyddogaeth bydd angen i chi gynnwys y gorchmynion digitalWrite(); ar gyfer pob newidyn modur.

    • Gan fod y rhain yn ddyfeisiau digidol, bydd angen i ni eu gosod i HIGH neu LOW.

    • Y tu mewn i'r cromfachau digitalWrite(); bydd angen i chi gynnwys y newidyn a nodi a yw'n HIGH neu'n LOW.

    • Er mwyn i'r robot droi i'r chwith, mae angen i'r olwyn dde fynd ymlaen a'r olwyn chwith yn ôl. Ac i'r gwrthwyneb er mwyn i'r robot droi i'r dde.

    • Er enghraifft, bydd swyddogaeth ymlaen yn edrych fel hyn: 
                            
  void forward()
  {
    digitalWrite(leftForwardPin, HIGH);
    digitalWrite(leftReversePin, LOW);
    digitalWrite(rightForwardPin, HIGH);
    digitalWrite(rightReversePin, LOW);
  }

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.

    Dangosir y rhan o'r rhaglen a newidiwyd isod. Bydd y rhaglen lawn yn cael ei hychwanegu ar ddiwedd pob lefel.

                        
  int ldrValue = 0;

  void robotForward()
  {
    digitalWrite(leftForwardPin, HIGH);
    digitalWrite(leftReversePin, LOW);
    digitalWrite(rightForwardPin, HIGH);
    digitalWrite(rightReversePin, LOW);
  }

  void robotReverse()
  {
    digitalWrite(leftForwardPin, LOW);
    digitalWrite(leftReversePin, HIGH);
    digitalWrite(rightForwardPin, LOW);
    digitalWrite(rightReversePin, HIGH);
  }

  void robotLeft()
  {
    digitalWrite(leftForwardPin, LOW);
    digitalWrite(leftReversePin, HIGH);
    digitalWrite(rightForwardPin, HIGH);
    digitalWrite(rightReversePin, LOW);
  }

  void robotRight()
  {
    digitalWrite(leftForwardPin, HIGH);
    digitalWrite(leftReversePin, LOW);
    digitalWrite(rightForwardPin, LOW);
    digitalWrite(rightReversePin, HIGH);
  }

  void robotStop()
  {
    digitalWrite(leftForwardPin, LOW);
    digitalWrite(leftReversePin, LOW);
    digitalWrite(rightForwardPin, LOW);
    digitalWrite(rightReversePin, LOW);
  }

  void setup ()

  4. Dechreuwch yr efelychiad i sicrhau nad oes gwallau yn eich cod. Ni fydd y moduron yn gwneud unrhyw beth eto, gan nad ydym wedi galw unrhyw un o'n swyddogaethau newydd. 


                        
  //C++ code
  //

  #include <Servo.h>
  Servo myServo;

  int leftForwardPin = 10;
  int leftReversePin = 11;
  int rightForwardPin = 9;
  int rightReversePin = 6;
  int piezo = A3;
  int servoPin = 12;
  int ldr = A0;
  int blueLED = 13;
  int ldrValue = 0;

  void robotForward()
  {
    digitalWrite(leftForwardPin, HIGH);
    digitalWrite(leftReversePin, LOW);
    digitalWrite(rightForwardPin, HIGH);
    digitalWrite(rightReversePin, LOW);
  }

  void robotReverse()
  {
    digitalWrite(leftForwardPin, LOW);
    digitalWrite(leftReversePin, HIGH);
    digitalWrite(rightForwardPin, LOW);
    digitalWrite(rightReversePin, HIGH);
  }

  void robotLeft()
  {
    digitalWrite(leftForwardPin, LOW);
    digitalWrite(leftReversePin, HIGH);
    digitalWrite(rightForwardPin, HIGH);
    digitalWrite(rightReversePin, LOW);
  }

  void robotRight()
  {
    digitalWrite(leftForwardPin, HIGH);
    digitalWrite(leftReversePin, LOW);
    digitalWrite(rightForwardPin, LOW);
    digitalWrite(rightReversePin, HIGH);
  }

  void robotStop()
  {
    digitalWrite(leftForwardPin, LOW);
    digitalWrite(leftReversePin, LOW);
    digitalWrite(rightForwardPin, LOW);
    digitalWrite(rightReversePin, LOW);
  }

  void setup ()
  {
    pinMode(leftForwardPin, OUTPUT);
    pinMode(leftReversePin, OUTPUT);
    pinMode(rightForwardPin, OUTPUT);
    pinMode(rightReversePin, OUTPUT);
    pinMode(blueLED, OUTPUT);
    pinMode(ldr, INPUT);
    Serial.begin(9600);
    myServo.attach(servoPin);
    pinMode(piezo, OUTPUT);
  }

  void loop ()
  {
    ldrValue = analogRead(ldr);
    Serial.println(ldrValue);
    if (ldrValue < 160)
    {
      digitalWrite(blueLED, HIGH);
    }
    else
    {
      digitalWrite(blueLED, LOW);
    }
    myServo.write(0);
    delay(1000);
    myServo.write(90);
    delay(1000);
    myServo.write(180);
    delay(1000);
    myServo.write(90);
    delay(1000);
    if (ldrValue < 60)
    {
      tone(piezo, 65, 500);
    }
    else if (ldrValue < 100)
    {
      tone(piezo, 82, 500);
    }
    else if (ldrValue < 160)
    {
      tone(piezo, 98, 500);
    }
    else if (ldrValue < 220)
    {
      tone(piezo, 131, 500);
    }
    else if (ldrValue < 280)
    {
      tone(piezo, 165, 500);
    }
    else if (ldrValue < 340)
    {
      tone(piezo, 196, 500);
    }
    else if (ldrValue < 400)
    {
      tone(piezo, 262, 500);
    }
    else if (ldrValue < 460)
    {
      tone(piezo, 330, 500);
    }
    else if (ldrValue < 520)
    {
      tone(piezo, 392, 500);
    }
    else 
    {
      tone(piezo, 523, 500);
    }
  }




  1. Nawr rydym ni'n mynd i ychwanegu rhaglen at y void loop() sy'n galw ein swyddogaethau newydd pan fydd eu hangen. Rydym am i'n robot wneud y canlynol cyn symud ei servo:
    1. Symud ymlaen am un eiliad.
    2. Stopio am hanner eiliad.
    3. Troi i'r chwith am hanner eiliad.
    4. Troi i'r dde am eiliad.
    5. Troi i'r chwith am hanner eiliad.
    6. Stopio am hanner eiliad.
    7. Symud yn ôl am 1 eiliad.
    8. Stopio am un eiliad.

    Awgrym: Defnyddiwch y cyfarwyddyd delay(); ar gyfer yr amseroedd.


    • I alw swyddogaeth defnyddiwch gyfarwyddyd functionName(); gan ddisodli enw'r swyddogaeth i gyd-fynd â'r un rydych chi'n ei galw.

    • Mesurir saib mewn milieiladau - mae 1000 o'r rhain mewn eiliad.

    • Yn ein rhaglen ateb, defnyddiwyd yr enwau swyddogaethau robotForward(), robotReverse(), robotLeft(), robotRight(), a robotStop(). Felly, gan ddefnyddio enwau'r swyddogaethau hyn, pe baem am i'r robot symud ymlaen am 5 eiliad ac yna stopio am 2 eiliad cyn symud yn ôl am 5 eiliad, byddem yn ysgrifennu: 
                          
  robotForward();
  delay(5000);
  robotStop();
  delay(2000);
  robotReverse();
  delay(5000);
  robotStop();

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.

    Dangosir y rhan o'r rhaglen a newidiwyd isod. Bydd y rhaglen lawn yn cael ei hychwanegu ar ddiwedd pob lefel.

                        
  void loop ()
  {
    ldrValue = analogRead(ldr);
    Serial.println(ldrValue);
    if (ldrValue < 160)
    {
      digitalWrite(blueLED, HIGH);
    }
    else
    {
      digitalWrite(blueLED, LOW);
    }

    robotForward();
    delay(1000);
    robotStop();
    delay(500);
    robotLeft();
    delay(500);
    robotRight();
    delay(1000);
    robotLeft();
    delay(500);
    robotStop();
    delay(500);
    robotReverse();
    delay(1000);
    robotStop();
    delay(1000);

    myServo.write(0);
    delay(1000);
    myServo.write(90);
    delay(1000);
    myServo.write(180);
    delay(1000);
    myServo.write(90);
    delay(1000);
  }

  2. Dechreuwch yr efelychiad i sicrhau nad oes bygiau ac i sicrhau bod y moduron yn gweithio. 


                      
  //C++ code
  //

  #include <Servo.h>
  Servo myServo;

  int leftForwardPin = 10;
  int leftReversePin = 11;
  int rightForwardPin = 9;
  int rightReversePin = 6;
  int piezo = A3;
  int servoPin = 12;
  int ldr = A0;
  int blueLED = 13;
  int ldrValue = 0;

  void robotForward()
  {
    digitalWrite(leftForwardPin, HIGH);
    digitalWrite(leftReversePin, LOW);
    digitalWrite(rightForwardPin, HIGH);
    digitalWrite(rightReversePin, LOW);
  }

  void robotReverse()
  {
    digitalWrite(leftForwardPin, LOW);
    digitalWrite(leftReversePin, HIGH);
    digitalWrite(rightForwardPin, LOW);
    digitalWrite(rightReversePin, HIGH);
  }

  void robotLeft()
  {
    digitalWrite(leftForwardPin, LOW);
    digitalWrite(leftReversePin, HIGH);
    digitalWrite(rightForwardPin, HIGH);
    digitalWrite(rightReversePin, LOW);
  }

  void robotRight()
  {
    digitalWrite(leftForwardPin, HIGH);
    digitalWrite(leftReversePin, LOW);
    digitalWrite(rightForwardPin, LOW);
    digitalWrite(rightReversePin, HIGH);
  }

  void robotStop()
  {
    digitalWrite(leftForwardPin, LOW);
    digitalWrite(leftReversePin, LOW);
    digitalWrite(rightForwardPin, LOW);
    digitalWrite(rightReversePin, LOW);
  }

  void setup ()
  {
    pinMode(leftForwardPin, OUTPUT);
    pinMode(leftReversePin, OUTPUT);
    pinMode(rightForwardPin, OUTPUT);
    pinMode(rightReversePin, OUTPUT);
    pinMode(blueLED, OUTPUT);
    pinMode(ldr, INPUT);
    Serial.begin(9600);
    myServo.attach(servoPin);
    pinMode(piezo, OUTPUT);
  }

  void loop ()
  {
    ldrValue = analogRead(ldr);
    Serial.println(ldrValue);
    if (ldrValue < 160)
    {
      digitalWrite(blueLED, HIGH);
    }
    else
    {
      digitalWrite(blueLED, LOW);
    }

    robotForward();
    delay(1000);
    robotStop();
    delay(500);
    robotLeft();
    delay(500);
    robotRight();
    delay(1000);
    robotLeft();
    delay(500);
    robotStop();
    delay(500);
    robotReverse();
    delay(1000);
    robotStop();
    delay(1000);

    myServo.write(0);
    delay(1000);
    myServo.write(90);
    delay(1000);
    myServo.write(180);
    delay(1000);
    myServo.write(90);
    delay(1000);
    if (ldrValue < 60)
    {
      tone(piezo, 65, 500);
    }
    else if (ldrValue < 100)
    {
      tone(piezo, 82, 500);
    }
    else if (ldrValue < 160)
    {
      tone(piezo, 98, 500);
    }
    else if (ldrValue < 220)
    {
      tone(piezo, 131, 500);
    }
    else if (ldrValue < 280)
    {
      tone(piezo, 165, 500);
    }
    else if (ldrValue < 340)
    {
      tone(piezo, 196, 500);
    }
    else if (ldrValue < 400)
    {
      tone(piezo, 262, 500);
    }
    else if (ldrValue < 460)
    {
      tone(piezo, 330, 500);
    }
    else if (ldrValue < 520)
    {
      tone(piezo, 392, 500);
    }
    else 
    {
      tone(piezo, 523, 500);
    }
  }



Rydym ni nawr yn mynd i sefydlu a rhaglennu'r synhwyrydd uwchsain.

  1. Crëwch newidynnau math cyfanrif a gosodwch y dulliau pin ar gyfer y canlynol:

    • Newidyn o'r enw ultrasonicTrigger - wedi'i gysylltu â phin 7 - allbwn.

    • Newidyn o'r enw ultrasonicEcho - wedi'i gysylltu â phin 8 - mewnbwn.


    • Gosodwch y newidynnau cyfanrif newydd i werth y pin.

    • Defnyddiwch y newidyn yn y moddau pin, yn hytrach na rhif y pin.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.

    Dangosir y rhannau o'r rhaglen a newidiwyd isod. Bydd y rhaglen lawn yn cael ei hychwanegu ar ddiwedd pob lefel.

                        
  int ultrasonicTrigger = 7;
  int ultrasonicEcho = 8;
  int leftForwardPin = 10;
  int leftReversePin = 11;
  int rightForwardPin = 9;
  int rightReversePin = 6;
  int piezo = A3;
  int servoPin = 12;
  int ldr = A0;
  int blueLED = 13;
  int ldrValue = 0;
                    
                  
                        
  void setup ()
  {
    pinMode(ultrasonicTrigger, OUTPUT);
    pinMode(ultrasonicEcho, INPUT);
    pinMode(leftForwardPin, OUTPUT);
    pinMode(leftReversePin, OUTPUT);
    pinMode(rightForwardPin, OUTPUT);
    pinMode(rightReversePin, OUTPUT);
    pinMode(blueLED, OUTPUT);
    pinMode(ldr, INPUT);
    Serial.begin(9600);
    myServo.attach(servoPin);
    pinMode(piezo, OUTPUT);
  }

    2. Pwysig: Mae gan y synhwyrydd uwchsain broses osod gymhleth nad oes angen i chi boeni am ei dysgu ar hyn o bryd. Yn lle hynny, gofynnwn i chi gopïo'r swyddogaeth gyfrifo isod yn ofalus i'ch rhaglen yn union ar ôl eich swyddogaethau modur ond cyn y void setup();.

                    
  int readUltrasonic() 
  {
    digitalWrite(ultrasonicTrigger,LOW); // Clear the signal
    delayMicroseconds(2);
    digitalWrite(ultrasonicTrigger, HIGH); // Send out new signal
    delayMicroseconds(10);
    digitalWrite(ultrasonicTrigger,LOW); // Stop sending signal

    unsigned long duration = pulseIn(ultrasonicEcho, HIGH);
    int distance = duration /2 /29;
    Serial.print(distance);
    Serial.print("cm");
    return distance;
  }

    Mae'r swyddogaeth hon yn rhoi'r pellter i wrthrych mae'n ei synhwyro mewn centimetrau. Gallwn nawr ei alw yn ein rhaglen i helpu gyda gweddill yr ymarfer hwn.

    Sylwer os gwelwch yn dda: Os ydych chi'n defnyddio enwau newidyn gwahanol i'r rhai a ddarperir yng ngham 1, ni fydd hyn yn gweithio.


  2. Crëwch newidynnau cyfanrif drwy'r cyfan newydd o'r enw 'left','front', a 'right'. Gosodwch pob un i 0. Ateb

    Dangosir y rhan o'r rhaglen a newidiwyd isod. Bydd y rhaglen lawn yn cael ei hychwanegu ar ddiwedd pob lefel.

                      
  int left = 0;
  int front = 0;
  int right = 0;
  int ultrasonicTrigger = 7;
  int ultrasonicEcho = 8;
  int leftForwardPin = 10;
  int leftReversePin = 11;
  int rightForwardPin = 9;
  int rightReversePin = 6;
  int piezo = A3;
  int servoPin = 12;
  int ldr = A0;
  int blueLED = 13;
  int ldrValue = 0;

  3. Mae ein rhaglen eisoes yn cynnwys symudiadau servo fel y dangosir isod. 
                    
  myServo.write(0);
  delay(1000);
  myServo.write(90);
  delay(1000);
  myServo.write(180);
  delay(1000);
  myServo.write(90);
  delay(1000);
    Rydym ni nawr eisiau cymryd darlleniadau uwchsonig o bob cyfeiriad. Felly, ar ôl symud i 0°, mewnosodwch linell sy'n gosod ein newidyn 'left' newydd i alw ein swyddogaeth readUltrasonic(). Yna, ar ôl iddo symud i 90°, gosodwch y newidyn 'front' i alw'r un swyddogaeth. Ailadroddwch eto am 180° gyda newidyn 'right'. Nid oes angen darllen y pedwerydd symudiad gan ein bod eisoes wedi cymryd hwnnw.

    Awgrym: Cofiwch, pwrpas y seibiau yw rhoi amser i'r servos orffen eu symudiadau felly dylid cymryd y darlleniadau ar ôl y saib ond cyn y symudiad nesaf.


    • Dyma sut i ychwanegu'r darlleniad chwith fel enghraifft: 
                            
  myServo.write(0);
  delay(1000);
  left = readUltrasonic();
  myServo.write(90);
  delay(1000);
  myServo.write(180);
  delay(1000);
  myServo.write(90);
  delay(1000);

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.

    Dangosir y rhan o'r rhaglen a newidiwyd isod. Bydd y rhaglen lawn yn cael ei hychwanegu ar ddiwedd pob lefel.

                        
  myServo.write(0);
  delay(1000);
  left = readUltrasonic();
  myServo.write(90);
  delay(1000);
  front = readUltrasonic();
  myServo.write(180);
  delay(1000);
  right = readUltrasonic();
  myServo.write(90);
  delay(1000);

  4. Rydym eisoes wedi rhaglennu llwybr symud i'r robot. Nawr, mae angen i ni sicrhau bod hyn yn ddiogel i'r robot ac na fydd yn taro i mewn i unrhyw beth. Gan mai dim ond mynd yn ôl ac ymlaen gyda rhywfaint o droi yw'r llwybr presennol, dim ond gwneud yn siŵr nad oes unrhyw beth o'i flaen sydd angen. Newidiwch eich rhaglen i stopio os yw darlleniad y synhwyrydd blaen yn llai na metr.

    Awgrym: Mae swyddogaeth readUltrasonic() yn rhoi pellter mewn centimedrau.


    • Mae hyn yn gofyn am ddatganiad-os ar gyfer pan fo'r tu front < 100.

    • Bydd angen i ni roi ein cyfarwyddiadau modur blaenorol mewn arall-datganiad.

    • Cofiwch, i roi'r gorau i symud, mae gennym swyddogaeth stopio a wnaed yn gynharach.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.

    Dangosir y rhan o'r rhaglen a newidiwyd isod. Bydd y rhaglen lawn yn cael ei hychwanegu ar ddiwedd pob lefel.

                        
  if (front < 100)
  {
    robotStop();
  }
  else
  {
    robotForward();
    delay(1000);
    robotStop();
    delay(500);
    robotLeft();
    delay(500);
    robotRight();
    delay(1000);
    robotLeft();
    delay(500);
    robotStop();
    delay(500);
    robotReverse();
    delay(1000);
    robotStop();
    delay(1000);
  }

  5. Yn eich void loop(), crëwch set o gyfarwyddiadau a fydd yn argraffu i'r monitor cyfresol p'un ai'r ochr dde ynteu'r chwith sydd fwyaf diogel i deithio iddi.

    Awgrym: Bydd hyn yn gofyn am os-ddatganiad, arall-os datganiad, ac arall-datganiad. Defnyddir y datganiad arall i dangos pan fo'r ddau fesuriad yr un peth.


    • Os dde > chwith, rydym am i'r monitor cyfresol ddangos y gair right, gan mai dyma'r cyfeiriad mwyaf diogel.

    • Arall os chwith>dde, rydym am i'r monitor cyfresol ddangos y gair left.

    • Arall, rydym am i'r monitor cyfresol ddangos yr ymadrodd 'no problem'.

    • Cofiwch, wrth argraffu geiriau i'r monitor cyfresol, rydym yn defnyddio dyfynodau dwbl: Serial.println("gair");

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.

    Dangosir y rhan o'r rhaglen a newidiwyd isod. Bydd y rhaglen lawn yn cael ei hychwanegu ar ddiwedd pob lefel.

                        
  myServo.write(0);
  delay(1000);
  left = readUltrasonic();
  myServo.write(90);
  delay(1000);
  front = readUltrasonic();
  myServo.write(180);
  delay(1000);
  right = readUltrasonic();
  myServo.write(90);
  delay(1000);

  if (right > left)
  {
    Serial.println("right");
  }
  else if (left > right)
  {
    Serial.println("left");
  }
  else
  {
    Serial.println("no problem");
  }

  6. Gobeithio eich bod wedi bod yn gwirio eich cod ar ôl pob cam. Os ddim, dechreuwch yr efelychiad er mwyn sicrhau nad oes bygiau ac i brofi'ch rhaglen. 


                      
  //C++ code
  //

  #include <Servo.h>
  Servo myServo;

  int left = 0;
  int front = 0;
  int right = 0;
  int ultrasonicTrigger = 7;
  int ultrasonicEcho = 8;
  int leftForwardPin = 10;
  int leftReversePin = 11;
  int rightForwardPin = 9;
  int rightReversePin = 6;
  int piezo = A3;
  int servoPin = 12;
  int ldr = A0;
  int blueLED = 13;
  int ldrValue = 0;

  void robotForward()
  {
    digitalWrite(leftForwardPin, HIGH);
    digitalWrite(leftReversePin, LOW);
    digitalWrite(rightForwardPin, HIGH);
    digitalWrite(rightReversePin, LOW);
  }

  void robotReverse()
  {
    digitalWrite(leftForwardPin, LOW);
    digitalWrite(leftReversePin, HIGH);
    digitalWrite(rightForwardPin, LOW);
    digitalWrite(rightReversePin, HIGH);
  }

  void robotLeft()
  {
    digitalWrite(leftForwardPin, LOW);
    digitalWrite(leftReversePin, HIGH);
    digitalWrite(rightForwardPin, HIGH);
    digitalWrite(rightReversePin, LOW);
  }

  void robotRight()
  {
    digitalWrite(leftForwardPin, HIGH);
    digitalWrite(leftReversePin, LOW);
    digitalWrite(rightForwardPin, LOW);
    digitalWrite(rightReversePin, HIGH);
  }

  void robotStop()
  {
    digitalWrite(leftForwardPin, LOW);
    digitalWrite(leftReversePin, LOW);
    digitalWrite(rightForwardPin, LOW);
    digitalWrite(rightReversePin, LOW);
  }

  int readUltrasonic() 
  {
    digitalWrite(ultrasonicTrigger,LOW); // Clear the signal
    delayMicroseconds(2);
    digitalWrite(ultrasonicTrigger, HIGH); // Send out new signal
    delayMicroseconds(10);
    digitalWrite(ultrasonicTrigger,LOW); // Stop sending signal

    unsigned long duration = pulseIn(ultrasonicEcho, HIGH);
    int distance = duration /2 /29;
    Serial.print(distance);
    Serial.print("cm");
    return distance;
  }

  void setup ()
  {
    pinMode(ultrasonicTrigger, OUTPUT);
    pinMode(ultrasonicEcho, INPUT);
    pinMode(leftForwardPin, OUTPUT);
    pinMode(leftReversePin, OUTPUT);
    pinMode(rightForwardPin, OUTPUT);
    pinMode(rightReversePin, OUTPUT);
    pinMode(blueLED, OUTPUT);
    pinMode(ldr, INPUT);
    Serial.begin(9600);
    myServo.attach(servoPin);
    pinMode(piezo, OUTPUT);
  }

  void loop ()
  {
    ldrValue = analogRead(ldr);
    Serial.println(ldrValue);
    if (ldrValue < 160)
    {
      digitalWrite(blueLED, HIGH);
    }
    else
    {
      digitalWrite(blueLED, LOW);
    }

    if (front < 100)
    {
      robotStop();
    }
    else
    {
      robotForward();
      delay(1000);
      robotStop();
      delay(500);
      robotLeft();
      delay(500);
      robotRight();
      delay(1000);
      robotLeft();
      delay(500);
      robotStop();
      delay(500);
      robotReverse();
      delay(1000);
      robotStop();
      delay(1000);
    }   

    myServo.write(0);
    delay(1000);
    left = readUltrasonic();
    myServo.write(90);
    delay(1000);
    front = readUltrasonic();
    myServo.write(180);
    delay(1000);
    right = readUltrasonic();
    myServo.write(90);
    delay(1000);

    if (right > left)
    {
      Serial.println("right");
    }
    else if (left > right)
    {
      Serial.println("left");
    }
    else
    {
      Serial.println("no problem");
    }

    if (ldrValue < 60)
    {
      tone(piezo, 65, 500);
    }
    else if (ldrValue < 100)
    {
      tone(piezo, 82, 500);
    }
    else if (ldrValue < 160)
    {
      tone(piezo, 98, 500);
    }
    else if (ldrValue < 220)
    {
      tone(piezo, 131, 500);
    }
    else if (ldrValue < 280)
    {
      tone(piezo, 165, 500);
    }
    else if (ldrValue < 340)
    {
      tone(piezo, 196, 500);
    }
    else if (ldrValue < 400)
    {
      tone(piezo, 262, 500);
    }
    else if (ldrValue < 460)
    {
      tone(piezo, 330, 500);
    }
    else if (ldrValue < 520)
    {
      tone(piezo, 392, 500);
    }
    else 
    {
      tone(piezo, 523, 500);
    }
  }


I gael her ychwanegol rhowch gynnig ar y canlynol mewn copi o'ch rhaglen.

Dilëwch y symudiadau presennol o'ch void loop() () ac ysgrifennwch raglen newydd sydd yn golygu bod y robot yn defnyddio ei servos a'i ddarlleniadau uwchsonig cyn penderfynu pa ffordd i symud. Cofiwch, mae ein symudiadau chwith a dde yn cynnwys troi yn y fan a'r lle, mae'n rhaid i chi wedyn yrru ymlaen er mwyn mynd y ffordd honno.


Ymarferion:

Y sesiwn hon, byddwn yn defnyddio cylched Tinkercad wahanol i adolygu popeth a drafodwyd ar y pwnc hwn.

Bydd angen i chi gopïo ein cylched Bwrdd Synhwyrydd i'w defnyddio ar gyfer yr ymarferion hyn.

Mae sawl synwyrydd ac LED wedi'u gosod ar y bwrdd synhwyrydd hwn a bydd modd inni gopïo cyfres o wahanol ddyfeisiau yn y cartref.

Dylai pob dysgwr ddechrau ar lefel efydd a gweithio eu ffordd i fyny cyn belled ag y bo modd.

Cliciwch ar bennawd pob her i'w ehangu.


Yn yr adran hon, byddwn yn creu rhaglen sy'n defnyddio'r LDR / gwrthydd golau ddibynol i reoli disgleirdeb y bwlb LED coch.

  1. Crewch newidynnau cyfanrifol ar gyfer y pinnau LDR ac LED coch.


    • Gallwch ddefnyddio'r gylched i benderfynu i ba binnau rhaglenadwy mae'r cydrannau wedi eu cysylltu.

    • Cofiwch, mae pob enw pin yn cael ei ystyried yn rif cyfan (cyfanrifau), hyd yn oed y rhai sy'n cynnwys y llythyren A.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


                        
  //C++ code
  //

  int ldrPin = A5;
  int redLEDPin = 3;

  void setup ()
  {
    
  }

  void loop ()
  {

  }

  2. Gosodwch y pinMode(); ar gyfer y ddwy gydran yma.


    • Mae cyfarwyddyd y pinMode(); yn gofyn eich bod yn dweud gwerth y pin wrtho (o fewn y cromfachau) ac a yw'n fewnbwn ynteu'n allbwn.

    • Cofiwch, mae mewnbwn ac allbwn yn cael eu hysgrifennu mewn priflythrennau bloc.

    • Yn hytrach nag ysgrifennu rhif y pin, defnyddiwch y newidyn a grëwyd yn y cam blaenorol.

    • Mae synwyryddion sy'n casglu gwybodaeth yn ddyfeisiau mewnbwn.

    • Mae'r cydrannau rydym yn eu rheoli gyda'r rhaglen yn allbynnau.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


                         
  //C++ code
  //

  int ldrPin = A5;
  int redLEDPin = 3;

  void setup ()
  {
    pinMode(ldrPin, INPUT);
    pinMode(redLEDPin, OUTPUT);
  }

  void loop ()
  {

  }

  3. Yn y void loop() ysgrifennwch raglen i storio gwerth yr LDR mewn newidyn.

    Awgrym: Bydd angen i chi greu newidyn cyfanrifol newydd ar gyfer hyn.


    • Dyma lle mae dewis enwau ar gyfer newidynnau yn bwysig. Mae angen i chi allu dweud pa newidyn yw'r gwerth pin a pha un yw'r darlleniad. Yn enwedig gan fod eich rhaglen yn gofyn am y ddau.

    • Sicrhewch fod y newidyn newydd hwn ar gael drwy'r cyfan ac wedi'i osod i sero yn y lle cyntaf.

    • Cofiwch, mewnbwn analog yw'r ddyfais LDR.

    • Rydym yn 'darllen' mewnbynnau ac yn 'ysgrifennu' allbynnau.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


                         
  //C++ code
  //

  int ldrPin = A5;
  int redLEDPin = 3;
  int ldrReading = 0;

  void setup ()
  {
    pinMode(ldrPin, INPUT);
    pinMode(redLEDPin, OUTPUT);
  }

  void loop ()
  {
    ldrReading = analogRead(ldrPin);
  }

  4. Argraffwch y gwerth hwn yn y monitor cyfresol.

    Awgrym: Peidiwch ag anghofio cynnwys y cyfarwyddiadau gosod angenrheidiol i ddefnyddio'r monitor cyfresol.


    • Yn y swyddogaeth void setup() bydd angen i chi ychwanegu'r cyfarwyddyd Serial.begin(9600); fel bod y rhaglen yn gwybod i ddefnyddio'r monitor cyfresol.

    • Y tu mewn i'r void loop() bydd angen i chi ysgrifennu gwerth y newidyn i'r monitor cyfresol.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


                         
  //C++ code
  //

  int ldrPin = A5;
  int redLEDPin = 3;
  int ldrReading = 0;

  void setup ()
  {
    pinMode(ldrPin, INPUT);
    pinMode(redLEDPin, OUTPUT);
    Serial.begin(9600);
  }

  void loop ()
  {
    ldrReading = analogRead(ldrPin);
    Serial.println(ldrReading);
  }

  5. Defnyddiwch yr efelychydd i ddod o hyd i werthoedd lleiaf ac uchaf yr LDR.


    • Os nad yw'r cod yn gweithio, gwiriwch ef yn erbyn yr ateb ar gyfer yr adran uchod. Y gwall mwyaf cyffredin yw cynnwys gormod neu dim digon o hanner colon.

    • Cofiwch, gallwch newid gwerthoedd yr LDR yn yr efelychydd trwy ei ddewis ac yna addasu'r llithrydd sy'n ymddangos.

    • Bydd angen i'r monitor cyfresol fod ar agor ar waelod ffenestr eich cod er mwyn i chi weld y gwerthoedd.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.

    Amrediad yr LDR yn efelychydd Tinkercad yw 6 i 679.


  6. Mapiwch ddarlleniad yr LDR i amrediad yr LED coch (0 - 255) a storiwch y gwerth mewn newidyn cyfanrifol newydd.

    Mapio: Fel gyda'r codio bloc blaenorol yn Makecode a Tinkercad, mae'n bosib mapio amrediad o werthoedd o fewnbynnau i allbynnau yn lle cael os-ddatganiadau mor hir.

    Ar gyfer hyn mae angen i ni greu gwerth i gynnal y mapio:

    int mappedVariable = map(inputValue, inputMin, inputMax, outputMin, outputMax);

    Er enghraifft, os hoffem fapio amrediad potensiomedr (mewnbwn analog) i LED (allbwn analog), i wneud yr LED yn fwy disglair wrth i werth y potentiometer gynyddu, mae angen y wybodaeth ganlynol arnom:

    • inputValue: Dyma werth presennol y potensiomedr.
    • inputMin: Gwerth lleiaf posib y potensiomedr (0).
    • inputMax: Gwerth mwyaf posib y potensiomedr (1023).
    • outputMin: Gwerth lleiaf posib yr LED (0).
    • outputMax: Gwerth mwyaf posib yr LED (255).

    Byddai'r rhaglen yn edrych rhywbeth fel hyn:

                      
  int potPin = A4;
  int ledPin = 9;
  int potValue = 0;
  int potMapLED = 0;

  void setup()
  {
    pinMode(potPin, INPUT);
    pinMode(ledPin, OUTPUT);
  }

  void loop()
  {
    potValue = analogRead(potPin);
    potMapLED = map(potValue, 0, 1023, 0, 255);
    analogWrite(ledPin, potMapLED);
  }


    • Crewch newidyn cyfanrifol trwy'r cyfan a'i osod i sero. Dyma lle byddwn wedyn yn storio gwerth yr LDR wedi'i fapio o fewn ein rhaglen.

    • Gan edrych ar strwythur y map(inputValue, inputMin, inputMax, outputMin, outputMax); Rydym ni'n gwybod mai'r inputValue yw ein darlleniad o gam 4, yr inputMin yw 6 fel y darganfuwyd yng ngham 5, ac o'r un cam rydym hefyd yn gwybod mai 679 yw'r inputMax. Y bwlb LED yw'r allbwn, sydd ag amrediad o 0 - 255 bob amser.

    • Gosodwch eich newidyn newydd ar gyfer y gwerth wedi'i fapio i gyd-fynd â'r swyddogaeth fapio tu mewn i'r void loop().

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


                        
 //C++ code
 //

 int ldrPin = A5;
 int redLEDPin = 3;
 int ldrReading = 0;
 int ldrMapValue = 0;

 void setup ()
 {
   pinMode(ldrPin, INPUT);
   pinMode(redLEDPin, OUTPUT);
   Serial.begin(9600);
 }

 void loop ()
 {
   ldrReading = analogRead(ldrPin);
   Serial.println(ldrReading);
   ldrMapValue = map(ldrReading, 6, 679, 0, 255);
 }

  7. Defnyddiwch y gwerth mapio hwn i osod disgleirdeb yr LED coch.


    • Gan ein bod yn addasu disgleirdeb yr LED, rydym yn ei ddefnyddio fel dyfais allbwn analog.

    • Cofiwch ein bod yn 'darllen' mewnbynnau ac yn 'ysgrifennu' allbynnau.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


                        
  //C++ code
  //

  int ldrPin = A5;
  int redLEDPin = 3;
  int ldrReading = 0;
  int ldrMapValue = 0;

  void setup ()
  {
    pinMode(ldrPin, INPUT);
    pinMode(redLEDPin, OUTPUT);
    Serial.begin(9600);
  }

  void loop ()
  {
    ldrReading = analogRead(ldrPin);
    Serial.println(ldrReading);
    ldrMapValue = map(ldrReading, 6, 679, 0, 255);
    analogWrite(redLEDPin, ldrMapValue);
  }

  8. Pe byddai hyn yn rhan o gylched cartref i roi goleuadau ymlaen a'u diffodd, byddai gennym ni broblem. Ar hyn o bryd mae'r LED ar ei fwyaf disglair pan fydd y lefel y golau ar ei uchaf. Byddai angen iddo fod y ffordd groes. Allwch chi feddwl sut i'w osod fel bod yr LED yn dod yn fwy disglair wrth i lefel y golau ostwng?


    • Does dim angen i ni ychwanegu unrhyw linellau cod newydd, dim ond newid yr hyn sydd gennym ar hyn o bryd.

    • Trwy newid amrediad yr LED coch yn y swyddogaeth mapio o 0 - 255 i 255 - 0, gallwn wrth-droi'r rhaglen.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


                         
  //C++ code
  //

  int ldrPin = A5;
  int redLEDPin = 3;
  int ldrReading = 0;
  int ldrMapValue = 0;

  void setup ()
  {
    pinMode(ldrPin, INPUT);
    pinMode(redLEDPin, OUTPUT);
    Serial.begin(9600);
  }

  void loop ()
  {
    ldrReading = analogRead(ldrPin);
    Serial.println(ldrReading);
    ldrMapValue = map(ldrReading, 6, 679, 255, 0);
    analogWrite(redLEDPin, ldrMapValue);
  }



Parhewch i ddefnyddio'r rhaglen a ddatblygwyd yn y lefel efydd.

Yn y set hon o ymarferion, byddwn yn creu efelychiad o system wresogi cartref. Ar gyfer hyn, bydd angen i ni ddefnyddio'r synhwyrydd tymheredd i gasglu darlleniadau, y potensiomedr i ddewis ein lefel wresogi, a'r bylbiau LED glas a gwyrdd i ddangos pan fo'n rhy oer, ar y tymheredd cywir, ac yn rhy boeth.

  1. Gan ein bod yn ychwanegu cydrannau newydd i'n rhaglen, mae angen i ni greu newidynnau i storio eu gwerthoedd pin.

    Awgrym: Mae pedair elfen newydd yn cael eu hychwanegu; y synhwyrydd tymheredd, y potensiomedr, yr LED glas, a'r LED gwyrdd.


    • Dewiswch enwau newidynnau addas.

    • Mae'r rhain i gyd yn newidynnau cyfanrifol.

    • Edrychwch ar y ffordd mae'r cydrannau wedi eu gwifrio yn y gylched a ddarperir er mwyn penderfynu pa bin rhaglenadwy mae bob un yn ei ddefnyddio.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.

    Dangosir y rhan o'r rhaglen a newidiwyd isod. Bydd y rhaglen lawn yn cael ei hychwanegu ar ddiwedd y lefel.

                         
  //C++ code
  //

  int ldrPin = A5;
  int redLEDPin = 3;
  int ldrReading = 0;
  int ldrMapValue = 0;
  int tempPin = A4;
  int potPin = A3;
  int greenLEDPin = 5;
  int blueLEDPin = 6;

  2. Nawr cwblhewch y cyfarwyddiadau void setup() angenrheidiol ar gyfer y cydrannau hyn.


    • Mae hyn yn golygu creu'r pinMode() ar gyfer pob cydran.

    • Mae dau o'r rhain yn fewnbynnau.

    • Defnyddiwch eich newidynnau gwerth pin yn lle'r rhifau pin.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.

    Dangosir y rhan o'r rhaglen a newidiwyd isod. Bydd y rhaglen lawn yn cael ei hychwanegu ar ddiwedd y lefel.

                         
  void setup ()
  {
    pinMode(ldrPin, INPUT);
    pinMode(redLEDPin, OUTPUT);
    Serial.begin(9600);
    pinMode(tempPin, INPUT);
    pinMode(potPin, INPUT);
    pinMode(greenLEDPin, OUTPUT);
    pinMode(blueLEDPin, OUTPUT);
  }

  3. Argraffwch ddarlleniad y synhwyrydd tymheredd i'r monitor cyfresol a dewch o hyd i'w amrediad o werthoedd.

    Awgrym: Bydd angen newidyn newydd arnoch i gadw'r gwerth hwn.


    • Rydym eisoes wedi sefydlu'r monitor cyfresol i'w ddefnyddio yn yr ymarferion Lefel Efydd.

    • Mae'r newidyn newydd yn newidyn cyfanrifol drwy'r cyfan a fydd yn storio darlleniad y synhwyrydd tymheredd.

    • Mae'r synhwyrydd tymheredd yn ddyfais mewnbwn analog.

    • Defnyddiwch y gorchymyn Serial.println() yn eich void loop() i argraffu gwerth eich newidyn newydd.

    • Cofiwch, rydych chi eisoes yn argraffu gwerth yr LDR, felly byddwch yn cael 2 werth yn y monitor cyfresol bob tro mae'r void loop() yn rhedeg.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.

    Dangosir y rhan o'r rhaglen a newidiwyd isod. Bydd y rhaglen lawn yn cael ei hychwanegu ar ddiwedd y lefel.

                        
 //C++ code
 //

 int ldrPin = A5;
 int redLEDPin = 3;
 int ldrReading = 0;
 int ldrMapValue = 0;
 int tempPin = A4;
 int potPin = A3;
 int greenLEDPin = 5;
 int blueLEDPin = 6;
 int tempReading = 0;

                    
                  

                         
  void loop ()
  {
    ldrReading = analogRead(ldrPin);
    Serial.println(ldrReading);
    ldrMapValue = map(ldrReading, 6, 679, 255, 0);
    analogWrite(redLEDPin, ldrMapValue);
    tempReading = analogRead(tempPin);
    Serial.println(tempReading);
  }

    Amrediad y synhwyrydd tymheredd yn yr efelychydd hwn yw 20 - 358.


  4. Nid oes gan y gwerthoedd rydym yn eu casglu ar hyn o bryd o'r synhwyrydd tymheredd lawer o ystyr ar eu ffurf bresennol. Mapiwch werth y tymheredd ar amrediad o -40 °C i 125 ° C, bydd y rhaglen yn gwneud y trosiad mathemategol i fesuriad y byddwn yn ei adnabod.

    Awgrym: Bydd angen newidyn newydd arnoch er mwyn cadw gwerth y tymheredd wedi'i drosi.


    • Crëwch newidyn cyfanrifol drwy'r cyfan i storio'r gwerth hwn a gosodwch ef i sero i ddechrau.

    • Wrth fapio gwerthoedd, gallwn eu mapio i set newydd o werthoedd yn hytrach nag i amrediad allbwn

    • Newidiwch y gwerth outputMin yn y swyddogaeth mapio i -40, a'r gwerth outputMax i 125.

    • Defnyddiwch y gwerthoedd amrediad o gam 3 fel gwerthoedd inputMin a inputMax.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.

    Dangosir y rhannau o'r rhaglen a newidiwyd isod. Bydd y rhaglen lawn yn cael ei hychwanegu ar ddiwedd y lefel.

                        
 //C++ code
 //

 int ldrPin = A5;
 int redLEDPin = 3;
 int ldrReading = 0;
 int ldrMapValue = 0;
 int tempPin = A4;
 int potPin = A3;
 int greenLEDPin = 5;
 int blueLEDPin = 6;
 int tempReading = 0;
 int tempDegreesC = 0;

                    
                  

                         
  void loop ()
  {
    ldrReading = analogRead(ldrPin);
    Serial.println(ldrReading);
    ldrMapValue = map(ldrReading, 6, 679, 255, 0);
    analogWrite(redLEDPin, ldrMapValue);
    tempReading = analogRead(tempPin);
    Serial.println(tempReading);
    tempDegreesC = map(tempReading, 20, 358, -40, 125);
  }

  5. Os yw'r tymheredd yn uwch na 20 °C, rydym ni eisiau i'r LED gwyrdd oleuo. Fodd bynnag, os yw'r tymheredd yn mynd yn rhy uchel (dros 50 °C), rydym am i'r LED gwyrdd fflachio ymlaen ac i ffwrdd bob 250ms fel rhybudd.

    Awgrym: Peidiwch ag anghofio diffodd yr LED pan fydd y tymheredd yn gostwng yn ôl.


    • Gan mai dim ond rhoi'r LED gwyrdd ymlaen ac i ffwrdd yw'r dasg, gallwn ddefnyddio'r gorchymyn digitalWrite(), gyda'r cyfarwyddiadau HIGH a LOW.

    • Bydd angen i chi feddwl am drefn eich os- ac arall-ddatganiadau. Bydd y rhaglen yn rhedeg yr un cyntaf sy'n wir. Felly, os edrychwch i ddechrau a yw'r tymheredd dros 20°C, bydd hyn yn wir pan fydd dros 50°C hefyd ac ni fydd y rhaglen golau rhybudd yn gweithio.

    • Cofiwch, mae angen i'r cyfarwyddiadau a gynhwysir yn y datganiadau hyn fod o fewn y cromfachau cyrliog, {}. Nid yw'r datganiadau eu hunain angen hanneri colon, dim ond y cyfarwyddiadau oddi mewn iddynt.

    • Rydym yn defnyddio'r gwerthoedd tymheredd sydd newydd eu mapio mewn °C ar gyfer yr amodau datganiad.

    • Ar gyfer y golau sy'n fflachio, bydd angen i chi gynnwys cyfarwyddiadau delay().

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.

    Dangosir y rhan o'r rhaglen a newidiwyd isod. Bydd y rhaglen lawn yn cael ei hychwanegu ar ddiwedd y lefel.

                         
  void loop ()
  {
    ldrReading = analogRead(ldrPin);
    Serial.println(ldrReading);
    ldrMapValue = map(ldrReading, 6, 679, 255, 0);
    analogWrite(redLEDPin, ldrMapValue);
    tempReading = analogRead(tempPin);
    Serial.println(tempReading);
    tempDegreesC = map(tempReading, 20, 358, -40, 125);
    if (tempDegreesC > 50)
    {
      digitalWrite(greenLEDPin, HIGH);
      delay(250);
      digitalWrite(greenLEDPin, LOW);
      delay(250);
    }
    else if (tempDegreesC > 20)
    {
      digitalWrite(greenLEDPin, HIGH);
    }
    else
    {
      digitalWrite(greenLEDPin, LOW);
    }
  }

  6. Mae angen i ni ychwanegu'r potensiomedr i'n rhaglen fel deial rheoli tymheredd. Mae hyn yn golygu bod angen ei fapio ar amrediad mwy addas o werthoedd, yn yr achos hwn 5°C i 35°C.

    Awgrym: Mae hyn yn golygu defnyddio'r un dull ag a ddefnyddiwyd i drosi darlleniadau'r tymheredd.


    • Crëwch newidynnau cyfanrifol drwy'r cyfan ar gyfer darlleniad eich potensiomedr a'r gwerth potensiomedr sydd wedi'i fapio a gosodwch y newidynnau i sero.

    • Os nad ydych yn gwybod amrediad y potensiomedr, bydd angen i chi ddefnyddio'r monitor cyfresol i'ch helpu i ddod o hyd iddo.

    • I brofi eich mapio, defnyddiwch y monitor cyfresol. Efallai y bydd angen i chi ddechrau argraffu gwybodaeth ychwanegol i wahanu'r gwahanol werthoedd sy'n cael eu cynhyrchu ar hyn o bryd. Ar gyfer hyn gallwch ddefnyddio Serial.print("") a fydd yn argraffu beth bynnag sydd wedi'i deipio rhwng y dyfynodau o fewn y cromfachau.

    • Ychwanegwch oediad o un eiliad ar ddiwedd eich void loop() i roi cyfle i chi ddarllen y monitor cyfresol cyn i'r rhaglen ailadrodd.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.

    Dangosir y rhannau o'r rhaglen a newidiwyd isod. Bydd y rhaglen lawn yn cael ei hychwanegu ar ddiwedd y lefel.

                         
  //C++ code
  //
  
  int ldrPin = A5;
  int redLEDPin = 3;
  int ldrReading = 0;
  int ldrMapValue = 0;
  int tempPin = A4;
  int potPin = A3;
  int greenLEDPin = 5;
  int blueLEDPin = 6;
  int tempReading = 0;
  int tempDegreesC = 0;
  int potReading = 0;
  int potDegreesC = 0;
                     
                   

                        
 void loop ()
 {
   ldrReading = analogRead(ldrPin);
   Serial.println(ldrReading);
   ldrMapValue = map(ldrReading, 6, 679, 255, 0);
   analogWrite(redLEDPin, ldrMapValue);
   tempReading = analogRead(tempPin);
   Serial.println(tempReading);
   tempDegreesC = map(tempReading, 20, 358, -40, 125);
   if (tempDegreesC > 50)
   {
     digitalWrite(greenLEDPin, HIGH);
     delay(250);
     digitalWrite(greenLEDPin, LOW);
     delay(250);
   }
   else if (tempDegreesC > 20)
   {
     digitalWrite(greenLEDPin, HIGH);
   }
   else
   {
     digitalWrite(greenLEDPin, LOW);
   }
   potReading = analogRead(potPin);
   Serial.println("Potentiometer reading: ");
   Serial.println(potReading);
   potDegreesC = map(potReading, 0, 1023, 5, 35);
   Serial.println("Potentiometer in degrees: ");
   Serial.println(potDegreesC);
   delay(1000);
 }

  7. Nawr rhowch y bwlb LED glas ymlaen pan fydd y tymheredd yn is na'r hyn a osodwyd ar y potensiomedr.

    Awgrym: Dychmygwch fod hyn yn rhoi'r gwres ymlaen ar yr un pryd.


    • Bydd angen i chi gymharu'r gwerthoedd wedi'u mapio ar gyfer y synhwyrydd tymheredd a'r potensiomedr o fewn os-ddatganiad ar gyfer hyn.

    • Cofiwch gynnwys arall-ddatganiad i ddiffodd yr LED eto pan gyrhaeddir y tymheredd.

    • Gallwch gael gwared ag unrhyw oedi a ychwanegwyd i'ch helpu i ddarllen y monitor cyfresol yn y cam blaenorol.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.

    Dangosir y rhan o'r rhaglen a newidiwyd isod. Bydd y rhaglen lawn yn cael ei hychwanegu ar ddiwedd y lefel.

                         
  void loop ()
  {
    ldrReading = analogRead(ldrPin);
    Serial.println(ldrReading);
    ldrMapValue = map(ldrReading, 6, 679, 255, 0);
    analogWrite(redLEDPin, ldrMapValue);
    tempReading = analogRead(tempPin);
    Serial.println(tempReading);
    tempDegreesC = map(tempReading, 20, 358, -40, 125);
    if (tempDegreesC > 50)
    {
      digitalWrite(greenLEDPin, HIGH);
      delay(250);
      digitalWrite(greenLEDPin, LOW);
      delay(250);
    }
    else if (tempDegreesC > 20)
    {
      digitalWrite(greenLEDPin, HIGH);
    }
    else
    {
      digitalWrite(greenLEDPin, LOW);
    }
    potReading = analogRead(potPin);
    Serial.println("Potentiometer reading: ");
    Serial.println(potReading);
    potDegreesC = map(potReading, 0, 1023, 5, 35);
    Serial.println("Potentiometer in degrees: ");
    Serial.println(potDegreesC);
    if (tempDegreesC < potDegreesC)
    {
      digitalWrite(blueLEDPin, HIGH);
    }
    else
    {
      digitalWrite(blueLEDPin, LOW);
    }
  }

  8. Rhedwch yr efelychiad rhag ofn bod chwilod ac i brofi bod eich system wresogi yn gweithio yn ôl y disgwyl. 


                      
  //C++ code
  //
  
  int ldrPin = A5;
  int redLEDPin = 3;
  int ldrReading = 0;
  int ldrMapValue = 0;
  int tempPin = A4;
  int potPin = A3;
  int greenLEDPin = 5;
  int blueLEDPin = 6;
  int tempReading = 0;
  int tempDegreesC = 0;
  int potReading = 0;
  int potDegreesC = 0;

  void setup ()
  {
    pinMode(ldrPin, INPUT);
    pinMode(redLEDPin, OUTPUT);
    Serial.begin(9600);
    pinMode(tempPin, INPUT);
    pinMode(potPin, INPUT);
    pinMode(greenLEDPin, OUTPUT);
    pinMode(blueLEDPin, OUTPUT);
  }

  void loop ()
  {
    ldrReading = analogRead(ldrPin);
    Serial.println(ldrReading);
    ldrMapValue = map(ldrReading, 6, 679, 255, 0);
    analogWrite(redLEDPin, ldrMapValue);
    tempReading = analogRead(tempPin);
    Serial.println(tempReading);
    tempDegreesC = map(tempReading, 20, 358, -40, 125);
    if (tempDegreesC > 50)
    {
      digitalWrite(greenLEDPin, HIGH);
      delay(250);
      digitalWrite(greenLEDPin, LOW);
      delay(250);
    }
    else if (tempDegreesC > 20)
    {
      digitalWrite(greenLEDPin, HIGH);
    }
    else
    {
      digitalWrite(greenLEDPin, LOW);
    }
    potReading = analogRead(potPin);
    Serial.println("Potentiometer reading: ");
    Serial.println(potReading);
    potDegreesC = map(potReading, 0, 1023, 5, 35);
    Serial.println("Potentiometer in degrees: ");
    Serial.println(potDegreesC);
    if (tempDegreesC < potDegreesC)
    {
      digitalWrite(blueLEDPin, HIGH);
    }
    else
    {
      digitalWrite(blueLEDPin, LOW);
    }
  }



Gan barhau â'n rhaglen, byddwn nawr yn rhaglennu system diogelwch cartref gyda rhai o'r cydrannau eraill.

  1. Crëwch newidynnau cyfanrifol drwy'r cyfan i storio gwerthoedd y PIR (synhwyrydd symudiad) a phin y bwlb golau ffilament. Yna defnyddiwch y rhain i sefydlu modd y pinnau ar gyfer y ddwy gydran.


    • Mae'r PIR yn ddyfais fewnbwn digidol sy'n canfod symudiad.

    • Ar gyfer yr ymarfer hwn, mae'r bwlb golau ffilament yn allbwn digidol.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.

    Dangosir y rhan o'r rhaglen a newidiwyd isod. Bydd y rhaglen lawn yn cael ei hychwanegu ar ddiwedd y lefel.

                         
  //C++ code
  //
  
  int ldrPin = A5;
  int redLEDPin = 3;
  int ldrReading = 0;
  int ldrMapValue = 0;
  int tempPin = A4;
  int potPin = A3;
  int greenLEDPin = 5;
  int blueLEDPin = 6;
  int tempReading = 0;
  int tempDegreesC = 0;
  int potReading = 0;
  int potDegreesC = 0;
  int pirPin = 4;
  int bulbPin = 12;
                     
                   

                        
  void setup ()
  {
    pinMode(ldrPin, INPUT);
    pinMode(redLEDPin, OUTPUT);
    Serial.begin(9600);
    pinMode(tempPin, INPUT);
    pinMode(potPin, INPUT);
    pinMode(greenLEDPin, OUTPUT);
    pinMode(blueLEDPin, OUTPUT);
    pinMode(pirPin, INPUT);
    pinMode(bulbPin, OUTPUT);
  }

    2. Mae'r synhwyrydd PIR yn ddyfais fewnbwn digidol sy'n dangos TRUE pan fydd yn canfod symudiad, a FALSE pan nad yw'n canfod symudiad. Pan fydd newidyn yn wir neu'n anwir, fe'i gelwir yn newidyn math Boole.

    Felly, wrth greu newidyn i storio gwerth mewnbwn digidol, rydym yn defnyddio bool yn hytrach nag int.


  2. Crëwch newidyn math Boole drwy'r cyfan a'i osod i 0. Yna, yn y void loop() gosodwch y newidyn newydd hwn i ddarllen mewnbwn digidol y PIR.


    • Defnyddiwch y math newydd hwn o newidyn yn yr un ffordd ag y byddech chi'n defnyddio unrhyw un arall.

    • Bydd angen i chi ddefnyddio'r cyfarwyddyd digitalRead().

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.

    Dangosir y rhan o'r rhaglen a newidiwyd isod. Bydd y rhaglen lawn yn cael ei hychwanegu ar ddiwedd y lefel.

                        
 //C++ code
 //
 
 int ldrPin = A5;
 int redLEDPin = 3;
 int ldrReading = 0;
 int ldrMapValue = 0;
 int tempPin = A4;
 int potPin = A3;
 int greenLEDPin = 5;
 int blueLEDPin = 6;
 int tempReading = 0;
 int tempDegreesC = 0;
 int potReading = 0;
 int potDegreesC = 0;
 int pirPin = 4;
 int bulbPin = 12;
 bool pirReading = 0;
                    
                  

                         
  void loop ()
  {
    ldrReading = analogRead(ldrPin);
    Serial.println(ldrReading);
    ldrMapValue = map(ldrReading, 6, 679, 255, 0);
    analogWrite(redLEDPin, ldrMapValue);
    tempReading = analogRead(tempPin);
    Serial.println(tempReading);
    tempDegreesC = map(tempReading, 20, 358, -40, 125);
    if (tempDegreesC > 50)
    {
      digitalWrite(greenLEDPin, HIGH);
      delay(250);
      digitalWrite(greenLEDPin, LOW);
      delay(250);
    }
    else if (tempDegreesC > 20)
    {
      digitalWrite(greenLEDPin, HIGH);
    }
    else
    {
      digitalWrite(greenLEDPin, LOW);
    }
    potReading = analogRead(potPin);
    Serial.println("Potentiometer reading: ");
    Serial.println(potReading);
    potDegreesC = map(potReading, 0, 1023, 5, 35);
    Serial.println("Potentiometer in degrees: ");
    Serial.println(potDegreesC);
    if (tempDegreesC < potDegreesC)
    {
      digitalWrite(blueLEDPin, HIGH);
    }
    else
    {
      digitalWrite(blueLEDPin, LOW);
    }
    pirReading = digitalRead(pirPin);
  }

  3. Nawr rydym ni eisiau i'r bwlb golau ffilament ddod ymlaen am 5 eiliad pan fydd y PIR yn canfod symudiad.

    Amodau Boole: Mae amodau os-ddatganiad (neu arall os ddatganiad), yn rhai Boole - maent naill ai'n wir neu'n anwir. Os yn wir, mae'r rhaglen yn rhedeg ei chynnwys. Os nad yw'n wir (gau) mae'n neidio i'r adran nesaf.

    Mae hyn yn golygu, pan fyddwn ni'n creu os-ddatganiad i wirio a yw newidyn Boole yn wir, gallwn ddefnyddio if (booleanVariable) am fod yr amod eisoes yn gwirio i weld a yw'n wir.

    Er enghraifft: Beth am ddweud fod gennym ni newidyn Boole o'r enw 'active' sy'n dweud wrth y rhaglen am raglennu i oleuo bwlb LED wedi'i gysylltu i bin 3 pan fydd 'active' yn wir. Dyma'r rhaglen ganlyniadol:

                      
  bool active = 0;

  void setup() 
  {
    pinMode(3, OUTPUT);
  }

  void loop()
  {
    active = FALSE;
    if (active)
    {
      digitalWrite(3, HIGH);
    }
    else
    {
      digitalWrite(3, LOW);
    }
  }

    Mae'r rhaglen hon yn gwirio i weld a yw gwerth Boole 'active' yn wir, ac nid yw'n wir, felly ni fydd y bwlb yn goleuo.

    Os oeddech chi am newid y rhaglen i wneud y gwrthwyneb, gan oleuo'r LED pan fydd 'active' yn anwir, mae gennych ddau opsiwn. Gallech addasu'r cyfarwyddiadau yn y rhaglen flaenorol, fel hyn:

                      
  if (active)
  {
    digitalWrite(3, LOW);
  }
  else
  {
    digitalWrite(3, HIGH);
  }

    Fel arall, gallech fod wedi newid y cyflwr i 'false' gan ddefnyddio ebychnod (!) cyn enw'r newidyn, fel hyn:

                      
  if (!active)
  {
    digitalWrite(3, HIGH);
  }
  else
  {
    digitalWrite(3, LOW);
  }

    Os ydych chi'n ysgrifennu if(boolVariable = TRUE) or if(boolVariable = FALSE), bydd yn dal i weithio. Fodd bynnag, mae'n dangos nad yw'r rhaglennydd yn deall yn llwyr sut mae os-ddatganiadau'n gweithio.



    • Bydd angen i chi ddiffodd y golau eto ar ôl y 5 eiliad.

    • Mae defnyddio gorchymyn oedi a diffodd yn yr os-ddatganiad yn golygu nad oes angen arall-ddatganiad arnom.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.

    Dangosir y rhan o'r rhaglen a newidiwyd isod. Bydd y rhaglen lawn yn cael ei hychwanegu ar ddiwedd y lefel.

                         
  void loop ()
  {
    ldrReading = analogRead(ldrPin);
    Serial.println(ldrReading);
    ldrMapValue = map(ldrReading, 6, 679, 255, 0);
    analogWrite(redLEDPin, ldrMapValue);
    tempReading = analogRead(tempPin);
    Serial.println(tempReading);
    tempDegreesC = map(tempReading, 20, 358, -40, 125);
    if (tempDegreesC > 50)
    {
      digitalWrite(greenLEDPin, HIGH);
      delay(250);
      digitalWrite(greenLEDPin, LOW);
      delay(250);
    }
    else if (tempDegreesC > 20)
    {
      digitalWrite(greenLEDPin, HIGH);
    }
    else
    {
      digitalWrite(greenLEDPin, LOW);
    }
    potReading = analogRead(potPin);
    Serial.println("Potentiometer reading: ");
    Serial.println(potReading);
    potDegreesC = map(potReading, 0, 1023, 5, 35);
    Serial.println("Potentiometer in degrees: ");
    Serial.println(potDegreesC);
    if (tempDegreesC < potDegreesC)
    {
      digitalWrite(blueLEDPin, HIGH);
    }
    else
    {
      digitalWrite(blueLEDPin, LOW);
    }
    pirReading = digitalRead(pirPin);
    if (pirReading)
    {
      digitalWrite(bulbPin, HIGH);
      delay(5000);
      digitalWrite(bulbPin, LOW);
    }
  }

    4. Erbyn hyn mae gennych olau diogelwch sy'n gweithio pan fydd rhywbeth yn symud gerllaw.

  4. Crëwch fwy o newidynnau i storio'r gwerthoedd pin ar gyfer y synhwyrydd grym, yr LED CGG, y synhwyrydd uwchsain a'r synhwyrydd gogwydd.

    Awgrym: Mae angen mwy nag un newidyn ar rai o'r cydrannau hyn.


    • Bydd yr LED CGG angen tri newidyn gwahanol ar gyfer y pinnau coch, gwyrdd a glas.

    • Mae'r synhwyrydd uwchsain angen dau newidyn. Un ar gyfer y pin sbardun, a'r llall ar gyfer y pin eco.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.

    Dyma enghraifft o'r cod newydd y mae angen ei ychwanegu. Cofiwch, gallai eich enw defnyddiwr amrywio. Mae'r rhaglen gyfan ar gael ar ddiwedd y lefel hon.

                        
  int forcePin = A1;
  int rgbRedLEDPin = 9;
  int rgbGreenLEDPin = 10;
  int rgbBlueLEDPin = 11;
  int tiltPin = 2;
  int ultraTrigPin = 7;
  int ultraEchoPin = 8;

  5. Nawr crëwch y moddau pin yn y void setup() ar gyfer y cydrannau newydd hyn.


    • Mae'r synhwyrydd grym yn ddyfais mewnbwn analog.

    • Mae'r LED CGG yn allbwn.

    • Mae'r synhwyrydd gogwydd yn fewnbwn digidol.

    • Mae'r pin sbardun ar y synhwyrydd uwchsain yn allbwn, ac mae'r pin eco yn fewnbwn.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.

    Dyma enghraifft o'r cod newydd y mae angen ei ychwanegu. Cofiwch, gallai eich enw defnyddiwr amrywio. Mae'r rhaglen gyfan ar gael ar ddiwedd y lefel hon.

                        
  pinMode(forcePin, INPUT);
  pinMode(rgbRedLEDPin, OUTPUT);
  pinMode(rgbGreenLEDPin, OUTPUT);
  pinMode(rgbBlueLEDPin, OUTPUT);
  pinMode(tiltPin, INPUT);
  pinMode(ultraTrigPin, OUTPUT);
  pinMode(ultraEchoPin, INPUT);

  6. Gan ein bod yn defnyddio'r synhwyrydd uwchsain, mae angen i ni ychwanegu'r swyddogaeth isod at y rhaglen, fel y gwnaethom ar gyfer ymarferion Lefel Aur Sesiwn Tri. Mae'r swyddogaeth hon yn cynhyrchu gwerth cyfanrif ar gyfer pellter (mewn cm) y gwrthrych o'r synhwyrydd uwchsain. 

                    
  int readUltrasonic() 
  {
    digitalWrite(ultrasonicTrigger,LOW); // Clear the signal
    delayMicroseconds(2);
    digitalWrite(ultrasonicTrigger, HIGH); // Send out new signal
    delayMicroseconds(10);
    digitalWrite(ultrasonicTrigger,LOW); // Stop sending signal

    unsigned long duration = pulseIn(ultrasonicEcho, HIGH);
    int distance = duration /2 /29;
    Serial.print(distance);
    Serial.print("cm");
    return distance;
  }

    Bydd angen i chi newid y newidynnau o ultrasonicTrigger ac ultrasonicEcho yn y cod hwn i gyd-fynd ag enwau'r newidynnau a grëwyd gennych ar gyfer pinnau sbardun ac eco'r synhwyrydd uwchsain.

    Awgrym: Gan fod hon yn swyddogaeth, rhaid ei chynnwys yn eich cod ar ôl y newidynnau, ond cyn yr adran void setup().

    Rydym wedi ailysgrifennu'r cod a ddarparwyd i gyd-fynd ag enwau'r newidynnau yn ein rhaglen ateb.

                      
  int readUltrasonic() 
  {
    digitalWrite(ultraTrigPin,LOW); // Clear the signal
    delayMicroseconds(2);
    digitalWrite(ultraTrigPin, HIGH); // Send out new signal
    delayMicroseconds(10);
    digitalWrite(ultraTrigPin,LOW); // Stop sending signal

    unsigned long duration = pulseIn(ultraEchoPin, HIGH);
    int distance = duration /2 /29;
    Serial.print(distance);
    Serial.print("cm");
    return distance;
  }

  7. Crëwch swyddogaeth newydd y byddwn yn ei defnyddio i gynnwys rhaglen system larwm.

    Rydym wedi ailysgrifennu'r cod a ddarparwyd i gyd-fynd ag enwau'r newidynnau yn ein rhaglen ateb.

                      
  void alarmSystem()
  {

  }

  8. Y tu mewn i'n swyddogaeth system larwm rydym am ysgrifennu rhaglen sy'n cynyddu disgleirdeb y pin coch ar yr LED CGG wrth i ddarlleniad y synhwyrydd grym gynyddu.


    • Bydd angen i chi greu newidyn i storio darlleniad eich synhwyrydd grym ac un arall ar gyfer y gwerth wedi'i fapio.

    • Yn eich void loop(), defnyddiwch y monitor cyfresol i gyfrifo'r amrediad ar gyfer y synhwyrydd grym. Cofiwch, mae llawer o werthoedd eisoes yn cael eu hargraffu, felly dylech gynnwys testun. Efallai y bydd angen i chi hefyd ychwanegu oediad er mwyn arafu allbrintiau'r monitor cyfresol.

    • Pan fyddwch wedi cael amrediad y synhwyrydd grym, gallwch ei fapio ar bin coch yr LED CGG.

    • I brofi eich rhaglen, bydd angen i chi enwi swyddogaeth y system larwm tu mewn i'r void loop().

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.

    Dyma enghraifft o osod y newidynnau angenrheidiol i'r diben hwn:

                        
  int forceReading = 0;
  int forceMapRed = 0;

    Dyma'r cod sydd ei angen er mwyn dod o hyd i amrediad y synhwyrydd grym. Mae angen dileu hwn ar ôl iddo gael ei ddefnyddio.

                        
  forceReading = analogRead(forcePin);
  Serial.println("Force Reading: ");
  Serial.println(forceReading);
  delay(1000);
  alarmSystem(); //to test our new function's program.

    Dyma'r cod ar gyfer ein swyddogaeth system larwm:

                        
  forceReading = analogRead(forcePin);
  forceMapRed = map (forceReading, 0, 466, 0, 255);
  analogWrite(rgbRedLEDPin, forceMapRed);

  9. Gan barhau â'r rhaglen o fewn swyddogaeth y system larwm, ychwanegwch gyfarwyddiadau i olau glas yr LED CGG gynyddu wrth i wrthrych symud yn agosach at y synhwyrydd uwchsain.


    • Nid oes angen i chi greu newidyn ar gyfer y darlleniad uwchsain gan fod gennym swyddogaeth ar gyfer hynny eisoes.

    • Dilynwch yr un camau ag a ddilynwyd er mwyn mapio'r synhwyrydd grym.

    • Cofiwch, trwy osod amrediad LED y ffordd groes (255 - 0) mewn mapiad, rydym yn cael golau mwy disglair ar gyfer gwerthoedd is.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.


    Dyma enghraifft o osod y newidynnau angenrheidiol i'r diben hwn:

                          
  int ultraMapBlue = 0;

    Dyma'r cod sydd ei angen er mwyn dod o hyd i amrediad y synhwyrydd grym. Mae angen dileu hwn ar ôl iddo gael ei ddefnyddio.

                          
  Serial.println("Ultrasonic Distance:");
  Serial.println(readUltrasonic());
  delay(1000);
  alarmSystem(); //to test our new function's program.

    Dyma'r cod ar gyfer ein swyddogaeth system larwm:

                          
  ultraMapBlue = map (readUltrasonic(), 2, 331, 255, 0);
  analogWrite(rgbBlueLEDPin, ultraMapBlue);

  10. Yn ein swyddogaeth system larwm mae angen i ni nawr ychwanegu cyfarwyddiadau sy'n gwneud i'r golau gwyrdd yn yr LED CGG oleuo os yw'r synhwyrydd gogwydd yn cael darlleniad cadarnhaol (ar ogwydd).


    • Rydym yn defnyddio'r synhwyrydd gogwydd fel mewnbwn digidol fel y PIR. Mae hyn yn golygu y bydd arnoch chi angen newidyn Boole i storio'r darlleniad.

    • Nid oes angen mapio hyn gan ein bod yn defnyddio darllen ac ysgrifennu digidol yma.

    • Gwnewch yn siŵr bod y golau yn diffodd pan nad yw'r amod yn cael ei fodloni.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.

    Bydd angen i chi ychwanegu newidyn newydd ar gyfer darlleniad y synhwyrydd gogwydd.

                          
  bool tiltReading = 0;

    Y rhaglen y bydd angen i chi ei hychwanegu at eich swyddogaeth system larwm. Gall enwau'r newidynnau fod yn wahanol i'ch rhai chi.

                          
  tiltReading = digitalRead(tiltPin);
  if (tiltReading)
  {
    digitalWrite(rgbGreenLEDPin, HIGH);
  }
  else
  {
    digitalWrite(rgbGreenLEDPin, LOW);
  }

  11. Ar hyn o bryd, os bydd mwy nag un synhwyrydd ein system larwm yn cael ei sbarduno, cawn liw cymysg o'r LED CGG. Yn lle hynny, rydym am i'r rhaglen fflachio pob lliw un ar ôl y llall. Bydd modd i'r defnyddiwr felly weld yn glir pa synwyryddion sy'n cael eu sbarduno.


    • Mae angen i ni ychwanegu cyfnodau o oedi rhwng pob synhwyrydd gwahanol - dylai 250ms fod yn ddigon.

    • Hefyd, mae angen i ni osod y pinnau yn ôl i sero cyn y synhwyrydd nesaf.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.

    Dylai'r swyddogaeth system larwm edrych fel hyn bellach:

                          
  void alarmSystem()
  {
    forceReading = analogRead(forcePin);
    forceMapRed = map (forceReading, 0, 466, 0, 255);
    analogWrite(rgbRedLEDPin, forceMapRed);
    delay(250);
    analogWrite(rgbRedLEDPin, 0);
    ultraMapBlue = map (readUltrasonic(), 2, 331, 255, 0);
    analogWrite(rgbBlueLEDPin, ultraMapBlue);
    delay(250);
    analogWrite(rgbBlueLEDPin, 0);
    tiltReading = digitalRead(tiltPin);
    if (tiltReading)
    {
      digitalWrite(rgbGreenLEDPin, HIGH);
    }
    else
    {
      digitalWrite(rgbGreenLEDPin, LOW);
    }
    delay(250);
    digitalWrite(rgbGreenLEDPin, LOW);
  }

  12. Er ein bod wedi bod yn enwi swyddogaeth y system larwm o fewn ein void loop() yn ystod y profion, nid ydym wedi penderfynu eto beth ddylid ei galw. Crëwch newidyn math Boole newydd o'r enw 'activate '. Byddwn yn defnyddio hwn i ddweud wrth y rhaglen bod angen i'r system larwm redeg os yw 'activate' wedi'i osod i TRUE.


    • Nid oes gennym ddyfais fewnbwn ffisegol i'w darllen ar gyfer y newidyn hwn. Yn lle hynny, bydd angen i ni osod y newidyn i 1 (TRUE) neu 0 (FALSE) y tu mewn i'r void loop() er mwyn profi.

    • Cofiwch, mae hwn yn amod Boole ar gyfer yr os-ddatganiad.

    Os ydych chi'n dal yn sownd, defnyddiwch y botwm ateb isod.

    Dyma'r rhannau cod y mae angen ichi eu hychwanegu at eich rhaglen. Cofiwch, gall enwau'r newidyn a'r swyddogaeth fod yn wahanol i'ch rhai chi.

                          
  bool activate = 0;
                      
                    

                          
  activate = 1;                      
  if (activate)
  {
    alarmSystem();
  }

  13. Gobeithio eich bod wedi bod yn profi'ch rhaglen yn gyson trwy gydol yr ymarferion hyn. Os ddim, gallai fod yn anodd dadfygio mor hwyr yn y broses. 


                        
  //C++ code
  //
  
  int ldrPin = A5;
  int redLEDPin = 3;
  int ldrReading = 0;
  int ldrMapValue = 0;
  int tempPin = A4;
  int potPin = A3;
  int greenLEDPin = 5;
  int blueLEDPin = 6;
  int tempReading = 0;
  int tempDegreesC = 0;
  int potReading = 0;
  int potDegreesC = 0;
  int pirPin = 4;
  int bulbPin = 12;  
  bool pirReading = 0;
  int forcePin = A1;
  int rgbRedLEDPin = 9;
  int rgbGreenLEDPin = 10;
  int rgbBlueLEDPin = 11;
  int tiltPin = 2;
  int ultraTrigPin = 7;
  int ultraEchoPin = 8;
  int forceReading = 0;
  int forceMapRed = 0;
  int ultraMapBlue = 0;
  bool tiltReading = 0;
  bool activate = 0;

  int readUltrasonic() 
  {
    digitalWrite(ultraTrigPin,LOW); // Clear the signal
    delayMicroseconds(2);
    digitalWrite(ultraTrigPin, HIGH); // Send out new signal
    delayMicroseconds(10);
    digitalWrite(ultraTrigPin,LOW); // Stop sending signal

    unsigned long duration = pulseIn(ultraEchoPin, HIGH);
    int distance = duration /2 /29;
    Serial.print(distance);
    Serial.print("cm");
    return distance;
  }

  void alarmSystem()
  {
    forceReading = analogRead(forcePin);
    forceMapRed = map (forceReading, 0, 466, 0, 255);
    analogWrite(rgbRedLEDPin, forceMapRed);
    delay(250);
    analogWrite(rgbRedLEDPin, 0);
    ultraMapBlue = map (readUltrasonic(), 2, 331, 255, 0);
    analogWrite(rgbBlueLEDPin, ultraMapBlue);
    delay(250);
    analogWrite(rgbBlueLEDPin, 0);
    tiltReading = digitalRead(tiltPin);
    if (tiltReading)
    {
      digitalWrite(rgbGreenLEDPin, HIGH);
    }
    else
    {
      digitalWrite(rgbGreenLEDPin, LOW);
    }
    delay(250);
    digitalWrite(rgbGreenLEDPin, LOW);
  }

  void setup ()
  {
    pinMode(ldrPin, INPUT);
    pinMode(redLEDPin, OUTPUT);
    Serial.begin(9600);
    pinMode(tempPin, INPUT);
    pinMode(potPin, INPUT);
    pinMode(greenLEDPin, OUTPUT);
    pinMode(blueLEDPin, OUTPUT);
    pinMode(pirPin, INPUT);
    pinMode(bulbPin, OUTPUT);
    pinMode(forcePin, INPUT);
    pinMode(rgbRedLEDPin, OUTPUT);
    pinMode(rgbGreenLEDPin, OUTPUT);
    pinMode(rgbBlueLEDPin, OUTPUT);
    pinMode(tiltPin, INPUT);
    pinMode(ultraTrigPin, OUTPUT);
    pinMode(ultraEchoPin, INPUT);
  }

  void loop ()
  {
    ldrReading = analogRead(ldrPin);
    Serial.println(ldrReading);
    ldrMapValue = map(ldrReading, 6, 679, 255, 0);
    analogWrite(redLEDPin, ldrMapValue);
    tempReading = analogRead(tempPin);
    Serial.println(tempReading);
    tempDegreesC = map(tempReading, 20, 358, -40, 125);
    if (tempDegreesC > 50)
    {
      digitalWrite(greenLEDPin, HIGH);
      delay(250);
      digitalWrite(greenLEDPin, LOW);
      delay(250);
    }
    else if (tempDegreesC > 20)
    {
      digitalWrite(greenLEDPin, HIGH);
    }
    else
    {
      digitalWrite(greenLEDPin, LOW);
    }
    potReading = analogRead(potPin);
    Serial.println("Potentiometer reading: ");
    Serial.println(potReading);
    potDegreesC = map(potReading, 0, 1023, 5, 35);
    Serial.println("Potentiometer in degrees: ");
    Serial.println(potDegreesC);
    if (tempDegreesC < potDegreesC)
    {
      digitalWrite(blueLEDPin, HIGH);
    }
    else
    {
      digitalWrite(blueLEDPin, LOW);
    }
    pirReading = digitalRead(pirPin);
    if (pirReading)
    {
      digitalWrite(bulbPin, HIGH);
      delay(5000);
      digitalWrite(bulbPin, LOW);
    }
    activate = 1;                      
    if (activate)
    {
      alarmSystem();
    }
  }


Os hoffech chi barhau i weithio gyda'r gylched a'r rhaglen hon, dyma rai syniadau ychwanegol i chi.