bilgiz.org

Pwm (Pulse Width Modulation- sinyal Genişlik Modülasyonu) Tekniği Nedir?

  • Günümüzdeki Durum nedir



  • Sayfa2/2
    Tarih03.07.2017
    Büyüklüğü366.79 Kb.

    Indir 366.79 Kb.
    1   2

    Hatırlatma: Bilgisayar ile eşleştirildikten sonra Bluetooth modülünün aldığı port numaraları için 'Aygıt Yöneticisi' kontrol edilmelidir. Aygıt yöneticisinin yeri daha önceki konularımızda anlatılmıştı. Burada iki adet Bluetooth portu görülebilir. Bunlardan büyük olanı projelerde kullanılacak olan haberleşme portudur.

    Eşleştirilme işlemleri bittikten sonra, Bluetooth ile akıllı cihazların haberleşmesini sağlayacak ara programlara ihtiyaç duymaktayız. Bu programlar, normal bir seri haberleşme yapan bilgisayar programları olarak düşünülebilir.

    Windows kullanıcıları Bluetooth ile haberleşmek için, ücretsiz olarak 'Tera Term' yazılımını indirebilirler. Android kullanıcıları ise haberleşme için 'Bluetooth Terminal' isimli ücretsiz uygulamayı kullanabilirler.

    Not: Daha önce bilgisayar programı geliştirmiş yazılımcılar, Bluetooth haberleşmesini sağlayacak programı kendileri de yazabilirler. Bu programın temel amacı seri porttan gelen verileri ekranda gösterme ve program kullanıcının mesajlarını seri porta yazmadır.

    Eğer eşleştirme işlemini başarıyla tamamlamış ve gerekli yazılımlar indirilmiş ise ilk bağlantımızı kurabiliriz. Bunun için Bluetooth modülünün sadece VCC ve GND pinlerinin takılması yeterlidir. Bu pinler takıldığında Bluetooth modülü üzerinde bulunan ışık yanıp sönmeye başlamaktadır. Bu ışığın hızlı bir şekilde yanıp sönmesi bağlantı isteklerine açık olduğunu göstermektedir.

    Akıllı cihazımızdaki program aracılıyla Bluetooth modülüne bağlanmayı deneyiniz. Birkaç saniye bekledikten sonra, eğer cihazımız ile Bluetooth modülü başarılı bir şekilde bağlanmış ise, modül üzerindeki ışık yanıp sönmeyi bırakıp sadece yanacaktır.

    Şu anda Rx ve Tx pinlerini takmadığımız için haberleşme yapamayız, fakat Bluetooth modülümüzün düzgün çalıştığını ve akıllı cihazımızın da başarılı bir şekilde eşleştirildiğini görmüş olduk.


    Telefon Kontrollü Işık Projesi

    Bu uygulamada Bluetooth modülü yardımıyla Arduino'ya bağlı LED'leri akıllı telefon üzerinden kontrol edeceğiz. Projede yazılan Arduino kodu biraz değiştirilerek akıllı ev projeleri yapılabilir. Kurulan devre sadece akıllı telefonlar ile değil, Bluetooth bağlantısına sahip tüm cihazlar üzerinden kontrol edilebilir. Projede telefon kontrolünün seçilmesinin nedeni projenin taşınabilirliğini sağlamaktır.

    Projede Bluetooth modülü slave (köle) modunda çalışacağından, HC-05 veya HC-06 modülleri kullanılabilir. Bluetooth modülünün haberleşme pinleri (Rx ve Tx) voltaj bölücü yardımıyla Arduino'ya bağlanmıştır. Bunun nedeni daha önce de öğrendiğimiz gibi, 3,3 volt üzerindeki gerilimlerin Bluetooth modülüne zarar verebilmesindendir.

    Bu uygulamayı yapmak için ihtiyacımız olan malzemeler;



    • 1 x Breadboard

    • 1 x Arduino

    • 1 x Bluetooth modülü (HC-05 veya HC-06)

    • 7 x Direnç (3 adet 220 ohm, 2 adet 1K ohm, 2 adet 2,2K ohm)

    • 3 x LED

    • Bluetooth bağlantısına sahip akıllı cihaz

    Proje için aşağıdaki devreyi kurunuz:

    Yukarıdaki resimde direnç değerleri belli olmadığı için aşağıda Bluetooth modülü ve Arduino arasına kurulacak voltaj bölücü devresi gösterilmiştir.





    Not: Eğer belirtilen direçler elinizde yok ise, elektroniğe giriş konusunda öğrenmiş olduğumuz voltaj bölücü hesaplama yöntemi ile farklı direnç değerleri kullanabilirsiniz.

    Arduino UNO'nun sadece bir tane haberleşme portu bulunduğu için Bluetooth modülü Arduino'nun 10 ve 11. pinlerine bağlanmıştır. Bu pinlerin seri port olarak kullanılabilmesi için 'Software Serial' kütüphanesi kullanılmıştır. Bu kütüphanenin kullanımını daha önceki konularda öğrenmiştik.



    Not: Bluetooth modülleri Arduino'nun donanımsal seri portuna da bağlanabilirdi. Fakat o zaman 'Serial Mönitör' üzerinden bilgisayara veri gönderilemezdi ve her programlama yapılacağı zaman bu pinlerin çıkarılması gerekirdi.

    Kontrol edeceğimiz pinleri ve diğer devre bağlantılarını da yaptıktan sonra Arduino programını yazmaya başlayabiliriz. Arduino programı Bluetooth modülü için açılmış sanal seri portları dinlemektedir. Eğer burada yeni bir veri var ise bu veriyi okuyarak işleme almaktadır. Gelen verinin değerine göre LED ışıkları kontrol edilmektedir. Unutulmamalıdır ki, Bluetooth modülü üzerinden gelecek veriler karakter formatındadır. Ayrıca her 'read' fonksiyonu kullanıldığında Arduino tarafından bir karakter okunmaktadır.



    #include
    SoftwareSerial bluetoothModulu(10, 11);

    /* Arduino -> Bluetooth modulu

    10 (Rx) -> Tx

    11 (Tx) -> Rx

    */
    const int LED1 = 2;

    const int LED2 = 3;

    const int LED3 = 4;
    void setup()

    {

    bluetoothModulu.begin(9600); /* Bluetooth haberleşmesi */

    pinMode(LED1, OUTPUT);

    pinMode(LED2, OUTPUT);

    pinMode(LED3, OUTPUT);

    }
    char okunanKarakter; /* okunan verilerin kaydedileceği değişken */

    void loop()

    {

    while(bluetoothModulu.available()>0){ /* Yeni veri var mı */

    okunanKarakter = bluetoothModulu.read(); /* Yeni veriyi okunanKarakter degiskenine kaydet */

    switch(okunanKarakter){ /* Okunan karaktere göre işlem yap */

    case 'a': /* gelen karakterin işlem karşılığı */

    digitalWrite(LED1, HIGH);

    bluetoothModulu.println("LED 1 yakildi");

    break;

    case 'b':

    digitalWrite(LED1, LOW);

    bluetoothModulu.println("LED 1 sonduruldu");

    break;

    case 'c':

    digitalWrite(LED2, HIGH);

    bluetoothModulu.println("LED 2 yakildi");

    break;

    case 'd':

    digitalWrite(LED2, LOW);

    bluetoothModulu.println("LED 2 sonduruldu");

    break;

    case 'e':

    digitalWrite(LED3, HIGH);

    bluetoothModulu.println("LED 3 yakildi");

    break;

    case 'f':

    digitalWrite(LED3, LOW);

    bluetoothModulu.println("LED 3 sonduruldu");

    break;

    } /* Switch sonu */

    }/* While sonu*/

    }/* Loop sonu */

    Harici Motor Sürücü Kullanımı

    Shield motor sürücülere göre daha ucuz olduğu için harici motor sürücüler proje bütçesine göre tercih edilebilmektedir. Harici motor sürücüler, bu bölümde gösterilen kendinizin kurabileceği motor sürücülerin hazır kart şekline getirilmiş halidir. Bu sürücülerde INPUT, OUTPUT, ENABLE ve besleme pinleri bulunur. INPUT pinleri daha önce öğrendiğimiz gibi yön kontrolünde, ENABLE pinleri motorların dönme hızını kontrol etmede kullanılır.

    Motor sürücüsünün nasıl çalıştığını bildiğimize göre kablo bağlantılarını yapmaya başlayabiliriz. Motorlara enerji sağlayacak besleme 7-12 volt arasındaki besleme kaynaklarına bağlanmalıdır. Mantıksal besleme 5 volt hattına ve GND ise toprak hattına bağlanmalıdır. INPUT pinleri Arduino'nun çıkış pinlerine; ENABLE pinleri ise Arduino'nun PWM çıkış verebilen pinlerine bağlanmalıdır. Motor pinleri sürücü yanlarında bulunan OUTPUT pinlerine bağlanmalıdır.

    // Simple Motor Shield sketch

    // -----------------------------------

    //

    // By arduino.cc user "Krodal".



    // June 2012

    // Open Source / Public Domain

    //

    // Using Arduino 1.0.1



    //

    // A simple sketch for the motor shield,

    // without using the Adafruit library.

    //

    // The outputs can be used for DC-motors



    // (either full H-bridge or just On and Off), lights,

    // relays, solenoids, etc.

    // But stepper motors can not be used !

    // Servo motors can be used with the default Servo library.

    //

    // A maximum of 4 DC motors can be used with full-bridge,



    // or a maximum of 8 normal outputs, or a combination.

    // Two servo motors can always be used, they use the +5V

    // of the Arduino board, so the voltage regulator could

    // get hot.

    //

    // Tested with an Ebay clone with the Arduino Uno.



    //

    // Parts of the code are from an old Adafruit Motor Shield

    // library, which was public domain at that time.

    // This code is also public domain

    //

    // This simplified program is using the normal



    // Arduino library functions as much as possible.

    //

    // The motors will make a whistling sound,



    // due to the analogWrite() PWM frequency.

    // The Adafruit library is specifically designed to avoid

    // this, so use the Adafruit library for a better result.

    //

    //



    //

    // Connector usage

    // ---------------

    // The order is different than what you would expect.

    // If the Arduino (Uno) board is held with the USB

    // connector to the left, the positive (A) side is

    // at the top (north), and the negative (B) side is

    // the bottom (south) for both headers.

    //

    // Connector X1:



    // M1 on outside = MOTOR1_A (+) north

    // M1 on inside = MOTOR1_B (-)

    // middle = GND

    // M2 on inside = MOTOR2_A (+)

    // M2 on outside = MOTOR2_B (-) south

    //

    // Connector X2:



    // M3 on outside = MOTOR3_B (-) south

    // M3 on inside = MOTOR3_A (+)

    // middle = GND

    // M4 on inside = MOTOR4_B (-)

    // M4 on outside = MOTOR4_A (+) north

    //

    //



    // -------------------------------

    // | -+s |

    // | -+s |

    // M1 A | | M4 A

    // M1 B | | M4 B

    // GND | | GND

    // M2 A | | M3 A

    // M2 B | | M3 B

    // | ..... |

    // -------------------------------

    // + -

    //

    //



    //

    // Pin usage with the Motorshield

    // ---------------------------------------

    // Analog pins: not used at all

    // A0 ... A5 are still available

    // They all can also be used as digital pins.

    // Also I2C (A4=SDA and A5=SCL) can be used.

    // These pins have a breadboard area on the shield.

    // Digital pins: used: 3,4,5,6,7,8,9,10,11,12

    // Pin 9 and 10 are only used for the servo motors.

    // Already in use: 0 (RX) and 1 (TX).

    // Unused: 2,13

    // Pin 2 has an soldering hole on the board,

    // easy to connect a wire.

    // Pin 13 is also connected to the system led.

    // I2C is possible, but SPI is not possible since

    // those pins are used.

    //

    #include



    // Arduino pins for the shift register

    #define MOTORLATCH 12

    #define MOTORCLK 4

    #define MOTORENABLE 7

    #define MOTORDATA 8
    // 8-bit bus after the 74HC595 shift register

    // (not Arduino pins)

    // These are used to set the direction of the bridge driver.

    #define MOTOR1_A 2

    #define MOTOR1_B 3

    #define MOTOR2_A 1

    #define MOTOR2_B 4

    #define MOTOR3_A 5

    #define MOTOR3_B 7

    #define MOTOR4_A 0

    #define MOTOR4_B 6
    // Arduino pins for the PWM signals.

    #define MOTOR1_PWM 11

    #define MOTOR2_PWM 3

    #define MOTOR3_PWM 6

    #define MOTOR4_PWM 5
    #define SERVO1_PWM 10

    #define SERVO2_PWM 9


    // Codes for the motor function.

    #define FORWARD 1

    #define BACKWARD 2

    #define BRAKE 3

    #define RELEASE 4

    // Declare classes for Servo connectors of the MotorShield.

    //Servo servo_1;

    //Servo servo_2;

    void setup()

    {

    Serial.begin(9600);



    Serial.println("Simple Motor Shield sketch");
    // Use the default "Servo" library of Arduino.

    // Attach the pin number to the servo library.

    // This might also set the servo in the middle position.

    //servo_1.attach(SERVO1_PWM);

    // servo_2.attach(SERVO2_PWM);

    }

    void loop()



    {

    // Suppose there are two servo motors connected.

    // Let them move 180 degrees.

    //servo_1.write(0);

    //delay(1000);

    //servo_1.write(180);

    //delay(2000);
    //servo_2.write(0);

    //delay(1000);

    //servo_2.write(180);

    //delay(2000);

    // Suppose there is a relay, or light or solenoid

    // connected to M3_A and GND.

    // Note that the 'speed' (the PWM, the intensity)

    // is for both M3_A and M3_B.

    // The output is a push-pull output (half bridge),

    // so it can also be used to drive something low.

    // The 'speed' (the PWM, the intensity) can be set

    // to zero, that would make the output disabled

    // and floating.

    //motor_output(MOTOR3_A, HIGH, 255);

    //delay(2000);

    //motor_output(MOTOR3_A, LOW, 255);

    // Suppose a DC motor is connected to M1_A(+) and M1_B(-)

    // Let it run full speed forward and half speed backward.

    // If 'BRAKE' or 'RELEASE' is used, the 'speed' parameter

    // is ignored.

    //motor(3, FORWARD, 255);

    //delay(2000);

    // Be friendly to the motor: stop it before reverse.

    //motor(3, RELEASE, 0);

    //delay(500);

    //motor(3, BACKWARD, 255);

    //delay(2000);

    //motor(3, RELEASE, 0);

    // motor(2, FORWARD, 255);

    //delay(2000);

    // Be friendly to the motor: stop it before reverse.

    //motor(2, RELEASE, 0);

    //delay(500);

    //motor(2, BACKWARD, 255);

    //delay(2000);

    //motor(2, RELEASE, 0);

    char input;

    if (Serial.available()) {

    // read the most recent character

    input = Serial.read();

    // switch based on the character

    switch(input){

    case 'F': // forward

    motor(3, FORWARD, 255);

    motor(2, FORWARD, 255);

    Serial.println("Forward");

    delay(1500);

    break;


    case 'B': // backwards

    motor(3, BACKWARD, 255);

    motor(2, BACKWARD, 255);

    Serial.println("Backward");

    delay(1500);

    break;


    case 'S': // stop

    motor(3, RELEASE, 255);

    motor(2, RELEASE, 255);

    Serial.println("Stop");

    delay(1500);

    break;


    case 'L': // left

    motor(3, FORWARD, 255);

    motor(2, BACKWARD, 255);

    Serial.println("Left");

    delay(1500);

    break;


    case 'R': // right

    motor(3, BACKWARD, 255);

    motor(2, FORWARD, 255);

    Serial.println("Right");

    delay(1500);

    break;


    default: // if character not recognized then stop

    motor(3, RELEASE, 255);

    motor(2, RELEASE, 255);

    Serial.println("Dont understand");

    delay(1500);

    break;


    }

    }

    }



    // Initializing

    // ------------

    // There is no initialization function.

    //

    // The shiftWrite() has an automatic initializing.



    // The PWM outputs are floating during startup,

    // that's okay for the Motor Shield, it stays off.

    // Using analogWrite() without pinMode() is valid.

    //

    // ---------------------------------



    // motor

    //

    // Select the motor (1-4), the command,



    // and the speed (0-255).

    // The commands are: FORWARD, BACKWARD, BRAKE, RELEASE.

    //

    void motor(int nMotor, int command, int speed)



    {

    int motorA, motorB;


    if (nMotor >= 1 && nMotor <= 4)

    {

    switch (nMotor)



    {

    case 1:


    motorA = MOTOR1_A;

    motorB = MOTOR1_B;

    break;

    case 2:


    motorA = MOTOR2_A;

    motorB = MOTOR2_B;

    break;

    case 3:


    motorA = MOTOR3_A;

    motorB = MOTOR3_B;

    break;

    case 4:


    motorA = MOTOR4_A;

    motorB = MOTOR4_B;

    break;

    default:


    break;

    }
    switch (command)

    {

    case FORWARD:



    motor_output (motorA, HIGH, speed);

    motor_output (motorB, LOW, -1); // -1: no PWM set

    break;

    case BACKWARD:



    motor_output (motorA, LOW, speed);

    motor_output (motorB, HIGH, -1); // -1: no PWM set

    break;

    case BRAKE:



    // The AdaFruit library didn't implement a brake.

    // The L293D motor driver ic doesn't have a good

    // brake anyway.

    // It uses transistors inside, and not mosfets.

    // Some use a software break, by using a short

    // reverse voltage.

    // This brake will try to brake, by enabling

    // the output and by pulling both outputs to ground.

    // But it isn't a good break.

    motor_output (motorA, LOW, 255); // 255: fully on.

    motor_output (motorB, LOW, -1); // -1: no PWM set

    break;


    case RELEASE:

    motor_output (motorA, LOW, 0); // 0: output floating.

    motor_output (motorB, LOW, -1); // -1: no PWM set

    break;


    default:

    break;


    }

    }

    }



    // ---------------------------------

    // motor_output

    //

    // The function motor_ouput uses the motor driver to



    // drive normal outputs like lights, relays, solenoids,

    // DC motors (but not in reverse).

    //

    // It is also used as an internal helper function



    // for the motor() function.

    //

    // The high_low variable should be set 'HIGH'



    // to drive lights, etc.

    // It can be set 'LOW', to switch it off,

    // but also a 'speed' of 0 will switch it off.

    //

    // The 'speed' sets the PWM for 0...255, and is for



    // both pins of the motor output.

    // For example, if motor 3 side 'A' is used to for a

    // dimmed light at 50% (speed is 128), also the

    // motor 3 side 'B' output will be dimmed for 50%.

    // Set to 0 for completelty off (high impedance).

    // Set to 255 for fully on.

    // Special settings for the PWM speed:

    // Set to -1 for not setting the PWM at all.

    //

    void motor_output (int output, int high_low, int speed)



    {

    int motorPWM;


    switch (output)

    {

    case MOTOR1_A:



    case MOTOR1_B:

    motorPWM = MOTOR1_PWM;

    break;

    case MOTOR2_A:



    case MOTOR2_B:

    motorPWM = MOTOR2_PWM;

    break;

    case MOTOR3_A:



    case MOTOR3_B:

    motorPWM = MOTOR3_PWM;

    break;

    case MOTOR4_A:



    case MOTOR4_B:

    motorPWM = MOTOR4_PWM;

    break;

    default:


    // Use speed as error flag, -3333 = invalid output.

    speed = -3333;

    break;

    }
    if (speed != -3333)



    {

    // Set the direction with the shift register

    // on the MotorShield, even if the speed = -1.

    // In that case the direction will be set, but

    // not the PWM.

    shiftWrite(output, high_low);


    // set PWM only if it is valid

    if (speed >= 0 && speed <= 255)

    {

    analogWrite(motorPWM, speed);



    }

    }

    }



    // ---------------------------------

    // shiftWrite

    //

    // The parameters are just like digitalWrite().



    //

    // The output is the pin 0...7 (the pin behind

    // the shift register).

    // The second parameter is HIGH or LOW.

    //

    // There is no initialization function.



    // Initialization is automatically done at the first

    // time it is used.

    //

    void shiftWrite(int output, int high_low)



    {

    static int latch_copy;

    static int shift_register_initialized = false;
    // Do the initialization on the fly,

    // at the first time it is used.

    if (!shift_register_initialized)

    {

    // Set pins for shift register to output



    pinMode(MOTORLATCH, OUTPUT);

    pinMode(MOTORENABLE, OUTPUT);

    pinMode(MOTORDATA, OUTPUT);

    pinMode(MOTORCLK, OUTPUT);


    // Set pins for shift register to default value (low);

    digitalWrite(MOTORDATA, LOW);

    digitalWrite(MOTORLATCH, LOW);

    digitalWrite(MOTORCLK, LOW);

    // Enable the shift register, set Enable pin Low.

    digitalWrite(MOTORENABLE, LOW);


    // start with all outputs (of the shift register) low

    latch_copy = 0;


    shift_register_initialized = true;

    }
    // The defines HIGH and LOW are 1 and 0.

    // So this is valid.

    bitWrite(latch_copy, output, high_low);


    // Use the default Arduino 'shiftOut()' function to

    // shift the bits with the MOTORCLK as clock pulse.

    // The 74HC595 shiftregister wants the MSB first.

    // After that, generate a latch pulse with MOTORLATCH.

    shiftOut(MOTORDATA, MOTORCLK, MSBFIRST, latch_copy);

    delayMicroseconds(5); // For safety, not really needed.

    digitalWrite(MOTORLATCH, HIGH);

    delayMicroseconds(5); // For safety, not really needed.

    digitalWrite(MOTORLATCH, LOW);

    }

    ARDUİNO ETHERNET UYGULAMASI – LED TOGGLE



    30 OCAK 2013 ADMİN 1 YORUM

    Bu uygulamada Arduino Ethernet Shield kullanarak, web üzerinden led yakıp söndüreceğiz.



    Ethernet Shield R3

    Ethernet katmanımızı Arduino kartımızın üstüne takıyoruz. LED bağlantılarını şekilde ki gibi yapıyoruz.



    • Led bağlantılarımızı sırasıyla

    • 1.LED +’sı -> D2

    • 2.LED +’sı -> D3

    • 3.LED +’sı -> D4

    • 4.LED +’sı -> D5

    • ….

    • şeklinde yapıyoruz. Bu şekilde istediğimiz kadar led bağlayabiliriz. Bağladığımız led sayısı kadar programı düzenlememiz gerekir. Bizim kodumuz 8 led için

    LED yakıp söndürme işlemimizi toggle kütüphanesiyle yapıcaz. Toggle geçerli durumun tersine dönmesini sağlar. Yani LED yanıyor (HIGH-1 durumunda)  ise toggle işleminden sonra LED söner (LOW-0). Tekrar toggle işlemine girince de LED yanar.

    Toggle kütüphanesini buradan edinebilirsiniz. Zip dosyasının içindeki klasörü Arduino>Libraries klasörüne kopyalayın.

    Ethernet katmanımızın (shield) ayarlarını yapmak için öncelikle bilgisayarımızın ağ bilgisini öğrenmemiz lazım.


    • Yerel Ağ Bağlantısı > Ayrıntılar > IPv4 adresine ve ağ maskesine bakın.

    • Buradan router’ımızın adresini öğreniyoruz. Genellikle 192.168.1.xx şeklinde olur.

    • Daha sonra Arduino’muza uygun boş bir ip veriyoruz 192.168.1.yy

    Arduino’nun ip adresi ve router adresi için IPv4 Adresinin ilk 3 kısmı aynı olmalı 4.kısım değişmeli yani;

    byte ip[] = { 192, 168, 1, 199 };               //arduino için ip adresi


    byte gateway[] = { 192, 168, 1, 50 };     //router için ip adresi

    Ağ maskesinin ise birebir aynı olması gerekiyor.Yani;

    byte subnet[] = { 255, 255, 255, 0 };     //ağ maskesi

    Ağ bilgilerini de elde ettikten sonra şimdi sıra program kısmında

    Kod:

    Source code

       

    #include

     

    #include



    #include

    boolean reading = false;

    byte ip[] = { 192, 168, 1, 199 }; //arduino için ip adresi

    byte gateway[] = { 192, 168, 1, 50 }; //router için ip adresi

    byte subnet[] = { 255, 255, 255, 0 }; //ağ maskesi

    byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };// Ethernet entegresinin fiziksel adresi

    Server server = Server(80); // Server portu 80

     

    void setup(){



    //10,11,12 & 13 ethernet katmanı tarafından kullanılıyor

     

    //LED bağlantılarımız

     

    pinMode(2, OUTPUT);



    pinMode(3, OUTPUT);

    pinMode(4, OUTPUT);

    pinMode(5, OUTPUT);

    pinMode(6, OUTPUT);

    pinMode(7, OUTPUT);

    pinMode(8, OUTPUT);

    pinMode(9, OUTPUT);

     

    //Ethernet başlatılıyor

     

    Ethernet.begin(mac, ip, gateway, subnet);



    server.begin();

    }

     



    void loop()

     

    {



    Client client = server.available();

     

    if (client) {



     

    boolean currentLineIsBlank = true;

    boolean sentHeader = false;

     

    while (client.connected()) {



     

    if (client.available()) {

     

    if(!sentHeader){



     

    //HTML başlığı ekleniyor

     

    client.println("HTTP/1.1 200 OK");



     

    client.println("Content-Type: text/html");

    client.println();

    sentHeader = true;

    }

     

    char c = client.read(); //okunan değeri stringe ata



     

    if(reading && c == ' ') reading = false;

    if(c == '?') reading = true; //? bulundu pin numarasını belirle

     

    if(reading){   //bir değer girildiyse



    Serial.print(c);  //değeri ekranı yazdır

     

    switch (c) {  //değere göre karşılık gelen ledi yak



    case '2':

    //2 numara toggle

    triggerPin(2, client);

    break;

    case '3':



    //3 numara toggle

    triggerPin(3, client);

    break;

    case '4':



    //4 numara toggle

    triggerPin(4, client);

    break;

    case '5':



    //5 numara toggle

    triggerPin(5, client);

    break;

    case '6':



    //6 numara toggle

    triggerPin(6, client);

    break;

    case '7':



    //7 numara toggle

    triggerPin(7, client);

    break;

    case '8':



    //8 numara toggle

    triggerPin(8, client);

    break;

    case '9':



    //9 numara toggle

    triggerPin(9, client);

    break;

    }

     



    }

     

    if (c == 'n' && currentLineIsBlank) break;



     

    if (c == 'n') {

    currentLineIsBlank = true;

    }else if (c != 'r') {

    currentLineIsBlank = false;

    }

    }



    }

    delay(1); // bekle

    client.stop(); // iletişimi kapat:

    }

    }



    void triggerPin(int pin, Client client){

     

    //Sayfa üstünde yazdırılacaklar

     

    client.println(pin);



    client.print("Numarali Led Toggle");

    client.print("

     

    ");


    digitalToggle(pin);

    }

     


    Bilgisayar ile Internet Explorer ya da benzeri bir program ile aşağıdaki resimde gösterildiği gibi Arduino için atadığınız ip adresine ulaşırsanız boş bir ekran çıkacaktır. Yani http://192.168.1.199/ adresine ulaşabiliyorsanız tüm bağlantılarınız ve işlemleriniz doğru demektir.

    Kodumuz http://192.168.1.199/?Lednumarası mantığı ile çalışmaktadır.

    Yani http://192.168.1.199/?3 yazdığınızda dijital 3. pine bağlı olan Led aktif olacaktır.

    http://192.168.1.199/?234 yazdığınızda ise 2. 3. ve 4. pinlerdeki Ledler aktif olacaktır.

    ethernet shield kartı kullanarak ip üzerinden kameradan görüntü almak

    Malzemeler:



    1. Arduino

    2. Arduino Ethernet Shield

    3. Serial kamera

    Kamera Kod

    1

    2

    3



    4

    5

    6



    7

    8

    9



    10

    11

    12



    13

    14

    15



    16

    17

    18



    19

    20

    21



    22

    23

    24



    25

    26

    27



    28

    29

    30



    31

    32

    33



    34

    35

    36



    37

    38

    39



    40

    41

    42



    43

    44

    45



    46

    47

    48



    49

    50

    51



    52

    53

    54



    55

    56

    57



    58

    59

    60



    61

    62

    63



    64

    65

    66



    67

    68

    69



    70

    71

    72



    73

    74

    75



    76

    77

    78



    79

    80

    81



    82

    83

    84



    85

    86

    87



    88

    89

    90



    91

    92

    93



    94

    95

    96



    97

    98

    99



    100

    101


    102

    103


    104

    105


    106

    107


    108

    109


    110

    111


    112

    113


    114

    115


    116

    117


    118

    119


    120

    121


    122

    123


    124

    125


    126

    127


    128

    129


    130

    131


    132

    133


    134

    135


    136

    137


    138

    139


    140

    141


    142

    143


    144

    145


    146

    147


    148

    149


    150

    151


    152

    153


    154

    155


    156

    157


    158

    159


    160

    161


    162

    163


    164

    165


    166

    167


    168

    169


    170

    171


    172

    173


    174

    175


    176

    177


    178

    179


    180

    181


    182

    183


    184

    185


    186

    187


    188

    189


    190


    #include

    #include

    #include

    #include

    #include

    #include

     

    // Arduino Ethernet shield: pin 4



    #define chipSelect 4

    // Using SoftwareSerial (Arduino 1.0+) or NewSoftSerial (Arduino 0023 & prior):

    #if ARDUINO >= 100

    // On Uno: camera TX connected to pin 2, camera RX to pin 3:

    SoftwareSerial cameraconnection = SoftwareSerial(2, 3);

    // On Mega: camera TX connected to pin 69 (A15), camera RX to pin 3:

    //SoftwareSerial cameraconnection = SoftwareSerial(69, 3);

    #else


    NewSoftSerial cameraconnection = NewSoftSerial(2, 3);

    #endif


     

    Adafruit_VC0706 cam = Adafruit_VC0706(&cameraconnection);

     

    /************ ETHERNET STUFF ************/



    byte mac[] = {0x90,0xa2,0xda,0x0e,0xf7,0xfc};

    byte ip[] = {192, 168, 0, 30};

    char rootFileName[] = "index.htm";

    EthernetServer server(80);

     

    /************ SDCARD STUFF ************/



    SdFat SD;

    Sd2Card card;

    SdVolume volume;

    SdFile root;

    SdFile file;

     

    // store error strings in flash to save RAM



    #define error(s) error_P(PSTR(s))

    void error_P(const char* str) {

    PgmPrint("error: ");

    SerialPrintln_P(str);

    if (card.errorCode()) {

    PgmPrint("SD error: ");

    Serial.print(card.errorCode(), HEX);

    Serial.print(',');

    Serial.println(card.errorData(), HEX);

    }

    while(1);



    }

     

    /**********************SETUP()*********************/



     

    void setup() {

    #if !defined(SOFTWARE_SPI)

    #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)

    if(chipSelect != 53) pinMode(53, OUTPUT); // SS on Mega

    #else


    if(chipSelect != 10) pinMode(10, OUTPUT); // SS on Uno, etc.

    #endif


    #endif

     

    PgmPrint("Free RAM: ");



    Serial.println(FreeRam());

    pinMode(10, OUTPUT);

    digitalWrite(10, HIGH);

     

    if (!card.init(SPI_HALF_SPEED, 4)) error("card.init failed!");



    if (!volume.init(&card)) error("vol.init failed!");

     

    PgmPrint("Volume is FAT");



    Serial.println(volume.fatType(),DEC);

    Serial.println();

     

    if (!root.openRoot(&volume)) error("openRoot failed");



     

    PgmPrintln("Files found in root:");

    root.ls(LS_DATE | LS_SIZE);

    Serial.println();

     

    PgmPrintln("Files found in all dirs:");



    root.ls(LS_R);

     

    Serial.println();



    PgmPrintln("Done");

    Serial.begin(9600);

    Serial.println("VC0706 Camera snapshot test");

    if (!SD.begin(chipSelect)) {

    Serial.println("Card failed, or not present");

    return;


    }

    Ethernet.begin(mac, ip);

    server.begin();

    }

     



    #define BUFSIZ 100

     

    /**********************LOOP()*********************/



     

    void loop() {

    char clientline[BUFSIZ];

    char *filename;

    int index = 0;

    int image = 0;

     

    EthernetClient client = server.available();



    if (client) {

    boolean current_line_is_blank = true;

    index = 0;

    while (client.connected()) {

    if (client.available()) {

    char c = client.read();

    if (c != '\n' && c != '\r') {

    clientline[index]= c;

    index++;

    if (index >= BUFSIZ)

    index = BUFSIZ -1;

    continue;

    }

    clientline[index]= 0;



    filename = 0;

    Serial.println(clientline);

    if (strstr(clientline, "GET / ") != 0) {

    filename = rootFileName;

    }

    if (strstr(clientline, "GET /") != 0) {



    if (!filename) filename = clientline + 5;

    (strstr(clientline, " HTTP"))[0] = 0;

    Serial.println(filename);

    if (strstr(filename, "tttt") != 0)

    takingPicture();

    if (strstr(filename, "rrrr") != 0)

    removePicture();

    if (! file.open(filename, O_READ)) {

    client.println("HTTP/1.1 404 Not Found");

    client.println("Content-Type: text/html");

    client.println();

    client.println("File Not Found!");

    break;

    }

     



    Serial.println("Open!");

    client.println("HTTP/1.1 200 OK");

    if(strstr(filename, ".css") != 0)

    client.println("Content-Type: text/css");

    else if (strstr(filename, ".htm") != 0)

    client.println("Content-Type: text/html");

    else if (strstr(filename, ".jpg") != 0)

    client.println("Content-Type: image/jpeg");

    client.println();

     

    int16_t c;



    while ((c = file.read()) >= 0) {

    Serial.print((char)c);

    client.print((char)c);

    }

    file.close();



    }else {

    // everything else is a 404

    client.println("HTTP/1.1 404 Not Found");

    client.println("Content-Type: text/html");

    client.println();

    client.println("File Not Found!");

    }

    break;


    }

    }

    delay(1000);



    client.stop();

    }

    }



     

    /**********************FUNCTION1()*********************/

     

    void takingPicture(){



    if (cam.begin()) {

    Serial.println("Camera Found:");

    } else {

    Serial.println("No camera found?");

    return;

    }

    char *reply = cam.getVersion();



    if (reply == 0) {

    Serial.print("Failed to get version");

    } else {

    Serial.println("-----------------");

    Serial.print(reply);

     

    Serial.println("-----------------");



    }

    //cam.setImageSize(VC0706_640x480); // biggest

    cam.setImageSize(VC0706_320x240); // medium

    //cam.setImageSize(VC0706_160x120); // small

     

    uint8_t imgsize = cam.getImageSize();



    Serial.print("Image size: ");

    if (imgsize == VC0706_640x480) Serial.println("640x480");

    if (imgsize == VC0706_320x240) Serial.println("320x240");

    if (imgsize == VC0706_160x120) Serial.println("160x120");

     

    Serial.println("Snap in 3 secs...");



    delay(3000);

    cam.takePicture();

    Serial.println("taking picture");

     

    file.open("IMAGE.jpg", O_RDWR | O_CREAT);



     

    uint16_t jpglen = cam.frameLength();

    pinMode(8, OUTPUT);

     

    byte wCount = 0;



    while (jpglen > 0) {

    uint8_t *buffer;

    uint8_t bytesToRead = min(32, jpglen);

    buffer = cam.readPicture(bytesToRead);

    file.write(buffer, bytesToRead);

    if(++wCount >= 64) {

    Serial.print('.');

    wCount = 0;

    }

    jpglen -= bytesToRead;



    }

    file.close();

    Serial.println("end of taking picture");

    }

    /**********************FUNCTION2()*********************/



    void removePicture(){

    file.open("IMAGE.jpg", O_READ | O_WRITE);

    file.remove();

    }

    IOT ‘ ye Giriş

    İlk örneği 1990 yılında kahve makinesinin boş olup olmadığını kontrol edebilmek için kurulan kameralı sistem ile fikir olarak ortaya çıkan nesnelerin interneti daha sonradan asıl adını almaya başladı. Orijinal ismi internet of things (IoT) olan ‘’Nesnelerin İnterneti’’ kavramı teknoloji öncülerinden Kevin Ashton tarafından ilk defa 1999 yılında ortaya atıldı. ‘Nesnelerin interneti nedir?’ derseniz ‘’Cihazların birbirleri arasında iletişim kurması mantığına dayanarak kullanıcıların hayatlarını kolaylaştıran bir teknolojidir. ‘’ tanımını yapabiliriz.

    Günümüzdeki Durum nedir?
    Yapılan araştırmalara göre bugün internete 10-11 milyar cihazın bağlı olduğu tahmin edilmekte ve bu rakamın 2020 yılına gelindiğinde 50 milyar cihaz seviyesine çıkması öngörülmektedir. Aynı araştırmalara göre; 2003 yılında dünyada kişi başına düşen birbirleriyle bağlantılı cihaz oranı 0,08 iken bu oranın 2020 tahmini ise "6,48"dir. Ayrıca 2020 yılında, 20 adet tipik ev cihazının üreteceği bilgi trafiğinin, 2008 yılında üretilen tüm internet trafiğinden daha fazlaolacağı tahmin edilmektedir

    .

    Nesnelerin interneti konusuna girişte benim önerim ESP8266 serisidir. Birçok pine sahip olan esp’nin 12 serisini kullanmanızı tavsiye ederim. Kullanımı en rahat olarak üzerinde herşeyi hazır olan Nodemcu nasıl kullanılır nerelerde kullanılır bunları göreceğiz.



    Esp 12 herhangi bir işlemciye gerek duymadan tek başına çalışabiliyor.Bir arduino gibi kullanabildiğimiz modülde analog/digital giriş ve çıkışların bulunduğu pinler var.Bu pinlerden sensör okuyabilir, motor sürebilir yada dünyanın diğer ucuna bir veri gönderebiliriz. Proglamlamasını arduino IDE kullanarak rahatça yapabilirsiniz.

    Esp8266 ile en rahat kullanılan portal ‘’blynk” adı verilen uygulama. Google Play’ den inirip kaydolup hemen kullanmaya başlayabilirsiniz.

    NODEMCU BLYNK UYGULAMA 1 LED YAKMA

    Arduino’ya blynk kütüphanesini yüklemekle başlayalım işe. Kütüphane’yi gitub’tan indirebilirsiniz.( https://github.com/blynkkk/blynk-library) arduinoya blynk kütüphanesini yükledikten sonra esp’yi arduinoda board kısmında görebilmek için esp’yi tercihler kısmından eklemek gerekli.

    ( http://arduino.esp8266.com/stable/package_esp8266com_index.json)

    Kütüphaneyi ve esp’yi arduinoya yükledikten sonra örneklere başlayabiliriz.



    Token kodunu blynk’e üye olduktan sonra ekranda görebilirsiniz.Token kodunu yazdıktan sonra esp’yi internete bağlamak için sizin internet bağlantınızın adını ve şifresini doğru bir şekilde girin. Araçlardan kartı ve portu seçtikten sonra kodu yükleyin.



    Kodu yükledikten sonra uygulamayı açın ve bir buton seçin. Seçtiğiniz butonun üzerine dokunarak hangi pini aktif hale getirecek seçebilirsiniz. Seçtiğiniz pine bir led bağlarsanız internete bağlı olduğunuz sürece o ledi istediğiniz yerden açıp kapatırsınız.

    LED’s Control through TTY

    HW setup


    I added a blue LED to make the demo more fun.  Here is what I have now….

    Note: I stopped using the 9V battery (as I had posted earlier).  It was getting drained to fast so using the 5V output from the Arduino board that is then regulated down to 3.3V using my home mode variable voltage regulator (described in my previous post: Mini Power supply from LM317T)

    SW setup

    The code is pretty straight forward if you have been following my previous post referenced above in “The Plan” section.  I start up the sever –> wait for incoming string –> if some key words are found, do something to IO’s connected to 3 LED’s.  The actual code is at the bottom of this post.



    Testing

    The testing steps will be:



    1. Start up the Arduino and ESP8266 with the code below loaded.  This should get my ESP8266 on my Wifi network.

    2. Use TeraTerm to open a raw TCP/IP connection

    3. Type in key words to control various LED.

    4. Watch LED light show.

    5. Code used for this post

    6. /*

    7. Try to start the server autonomously

    8. */

    9. #include

    10. #include



    11. #define TIMEOUT 5000 // mS

    12. #define GREENLED 4

    13. #define REDLED 5

    14. #define BLUELED 3



    15. SoftwareSerial mySerial(7, 6); // RX, TX







    16. void setup()

    17. {

    18. pinMode(REDLED,OUTPUT);

    19. pinMode(GREENLED,OUTPUT);

    20. Serial.begin(9600);

    21. mySerial.begin(9600);

    22. mySerial.setTimeout(100);



    23. int CommandStep = 1;



    24. //This initializes the Wifi Module as a server

    25. BlinkLED(REDLED,CommandStep,50);

    26. SendCommand("AT+RST", "Ready", true);

    27. BlinkLED(GREENLED,CommandStep,50);

    28. CommandStep++;







    29. BlinkLED(REDLED,CommandStep,50);

    30. SendCommand("AT+GMR", "OK", true);

    31. BlinkLED(GREENLED,CommandStep,50);

    32. CommandStep++;



    33. delay(5000);



    34. BlinkLED(REDLED,CommandStep,50);

    35. SendCommand("AT+CIFSR", "OK", true);

    36. BlinkLED(GREENLED,CommandStep,50);

    37. CommandStep++;





    38. BlinkLED(REDLED,CommandStep,50);

    39. SendCommand("AT+CIPMUX=1","OK",true);

    40. BlinkLED(GREENLED,CommandStep,50);

    41. CommandStep++;



    42. BlinkLED(REDLED,CommandStep,50);

    43. SendCommand("AT+CIPSERVER=1,22","OK",true);

    44. BlinkLED(GREENLED,CommandStep,50);

    45. //----------------------------------------------------



    46. }



    47. void loop(){

    48. String IncomingString="";

    49. char SingleChar;

    50. boolean StringReady = false;





    51. while (mySerial.available())

    52. {

    53. IncomingString=mySerial.readString();

    54. StringReady= true;

    55. }



    56. //********** Only run when string is available ************//

    57. if (StringReady){

    58. Serial.println("Received String: " + IncomingString);



    59. if ((IncomingString.indexOf("xmas") != -1) || (IncomingString.indexOf("christmas") != -1 )) {

    60. int loopdelay = 50;

    61. for (int x=1; x <= 50 ; x ++){

    62. digitalWrite(REDLED,HIGH);

    63. delay(loopdelay);

    64. digitalWrite(GREENLED,HIGH);

    65. delay(loopdelay);

    66. digitalWrite(BLUELED,HIGH);

    67. delay(loopdelay);

    68. digitalWrite(REDLED,LOW);

    69. delay(loopdelay);

    70. digitalWrite(GREENLED,LOW);

    71. delay(loopdelay);

    72. digitalWrite(BLUELED,LOW);

    73. }

    74. }





    75. if ((IncomingString.indexOf("red") != -1) || (IncomingString.indexOf("all") != -1)) {

    76. Serial.println("Someone trying to control RED LED");

    77. ProcessLEDCommand(REDLED, IncomingString);

    78. }



    79. if ((IncomingString.indexOf("green") != -1) || (IncomingString.indexOf("all") != -1)) {

    80. Serial.println("Someone trying to control GREEN LED");

    81. ProcessLEDCommand(GREENLED, IncomingString);

    82. }

    83. if ((IncomingString.indexOf("blue") != -1) || (IncomingString.indexOf("all") != -1)){

    84. Serial.println("Someone trying to control YELLOW LED");

    85. ProcessLEDCommand(BLUELED, IncomingString);

    86. }

    87. }







    88. //************************************************************

    89. }



    90. void ProcessLEDCommand(int LEDPin, String IncomingString){

    91. if (IncomingString.indexOf("on") != -1) {

    92. Serial.println("Someone trying to turn on LED");

    93. digitalWrite(LEDPin,HIGH);

    94. }

    95. if (IncomingString.indexOf("off") != -1) {

    96. Serial.println("Someone trying to turn off LED");

    97. digitalWrite(LEDPin,LOW);

    98. }

    99. if (IncomingString.indexOf("blink") != -1) {

    100. Serial.println("Someone trying to blink LED");

    101. BlinkLED(LEDPin,5,200);

    102. }

    103. }





    104. void BlinkLED(int LEDPin, int NumberOfBlinks, int OnDuration)

    105. {

    106. for (int x=1; x <= NumberOfBlinks ; x ++){

    107. digitalWrite(LEDPin,HIGH);

    108. delay(OnDuration);

    109. digitalWrite(LEDPin,LOW);

    110. delay(OnDuration);

    111. }

    112. }





    113. boolean SendCommand(String cmd, String ack, boolean halt_on_fail)

    114. {

    115. mySerial.println(cmd); // Send "AT+" command to module



    116. // Otherwise wait for ack.

    117. if (!echoFind(ack)) // timed out waiting for ack string

    118. if (halt_on_fail)

    119. errorHalt(cmd+" failed");// Critical failure halt.

    120. else

    121. return false; // Let the caller handle it.

    122. return true; // ack blank or ack found

    123. }



    124. // Read characters from WiFi module and echo to serial until keyword occurs or timeout.

    125. boolean echoFind(String keyword)

    126. {

    127. byte current_char = 0;

    128. byte keyword_length = keyword.length();



    129. // Fail if the target string has not been sent by deadline.

    130. long deadline = millis() + TIMEOUT;

    131. while(millis() < deadline)

    132. {

    133. if (mySerial.available())

    134. {

    135. char ch = mySerial.read();

    136. Serial.write(ch);

    137. if (ch == keyword[current_char])

    138. if (++current_char == keyword_length)

    139. {

    140. Serial.println();

    141. return true;

    142. }

    143. }

    144. }

    145. return false; // Timed out

    146. }



    147. // Print error message and loop stop.

    148. void errorHalt(String msg)

    149. {

    150. Serial.println(msg);

    151. Serial.println("HALT");

    152. digitalWrite(REDLED,HIGH);

    153. digitalWrite(GREENLED,HIGH);

    154. while(true){};

    155. }

    LED’s Control Through ESP8266 + Arduino Web Page


    The Web Page Implementation


    I will use a HTML form to send a POST request back to the server.  If you are like me and not familiar with how this works, I will explain what I know and how I will try to get it to work.

    First I found out how to create a form with radio buttons and a submit button.  Here is what the page looks like…



    I found www.w3schools.com/tags/tag_form.asp that helped me write the HTML code for the above like this…











    Red LED State

    ON

    OFF






    Green LED State

    ON

    OFF






    Blue LED State

    ON

    OFF






    1   2






        Ana sayfa


    Pwm (Pulse Width Modulation- sinyal Genişlik Modülasyonu) Tekniği Nedir?

    Indir 366.79 Kb.