ESP8266 + blynk. IoT, ağıllı ev sistemləri üçün sadə bir həll yolu

ESP8266 wifi kontrolleri və blynk application(android) –i ilə IoT(Internet of Things‎) testleri edeceyik. Testler üçün ESP8266 wifi modulu əldə etmək lazımdır. Daha sonra proqramlayib uzaqdan lazimi sisitemləri idarə etmək olar. Burda məqsədimiz uzaqdan ağıllı evi ve ya hər hansı bir qurğunu idarə etməkdir.

ESP8266-nı proqramlamamışdan öncə “application” tərəfin necə qurulduğuna baxaq.(Kodlamada blynk proqramının verdiyi “Auth Token” lazım gələcək)

“Play store” – a daxil olun ve blynk proqramını telefonunuza yükləyin.

Daha sonra qeydiyyatdan keçin və proqramı açın. Proqramda “add device” edin və aşağıdakı kimi ESP8266 modulunu əlavə edin.

Modul proqrama əlavə edildikdən sonra sizə emaillə “Auth Token” gondəriləcək. Bunu ESP8266-nin daxili proqramında istifadə edəcəyik.

Daha sonra yaratdığımız ESP8266 proyektini seçək və bir “button” əlavə edək. Bu düymədə D0 terminalını seçək.

Daha sonra nəticəni görmək üçün bir də “Guage” əlavə edək və burada A0-I input kimi təyin edek.

Bununla proqram tərəfi bitirmiş oluruq. İndi ESP8266 wifi modulun proqramlayaq. Giriş terminalını çıxış terminalına birləşdirərək nəticəni görməmizi təyin edək. A0 və D0 terminallarını bir-birinə birləşdirək. Usb kabeli vasitəsilə komputere bağlayaq.

Proqramlamaq üçün lazımlı arduino paketini yükləyək. Bu blynk application-u üçün lazım olan “library” ve “tool” –lardır(Blynk_Release_v0.6.1.zip).

https://github.com/blynkkk/blynk-library/releases

Yüklədikdən sonra arxiv faylı açıb “tools”-u arduino proqraminin tools ve “libraries” –i isə arduino proqramının “libraries” qovluğuna əlavə edirik. Daha sonra arduino proqramını açdıqda bunların yükləndiyini görəcəyik.

            Port və “board”-i doğru seçdikdən sonra kolamaya bashlaya bilərik.

Aşağıdakı kodu yazaq və ESP8266 moduluna yükləyək.

#include <Blynk.h>

#define BLYNK_PRINT Serial    // Comment this out to disable prints and save space
#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>

// You should get Auth Token in the Blynk App.
// Go to the Project Settings (nut icon).
char auth[] = "c3c9f916b2604534a877a6a70a3b8980";

// Your WiFi credentials.
// Set password to "" for open networks.
char ssid[] = "VIBE";
char pass[] = "password";

void setup()
{
  Serial.begin(9600);
  Blynk.begin(auth, ssid, pass);
}

void loop()
{
  Blynk.run();
}

Proqramda əsas diqqət etməyimiz gərəkən bizim wifi parametrlərimizdir. SSİD, password və “Auth Token”. Bizim nümunədə telefonda wifi hotspot qaldırıb(VIBE) ilə test etmişik.

Artiq test edə bilərik. ESP8266 usb ilə qoşulu olduğundan həmən bizim wifi şəbəkəsinə bağlanacaq.(DHCP listdən bağlandığına əmin olun).

Proqramda D0 düyməsini sixsaq A0-da nəticəni görəcəyik.

İndi ESP8266-nin terminallarini internet üzərindən idarə edə bilirik. İstədiyimiz kimi rele, sensor bağlayıb istifadə etmək olar.

Uğurlar!

Arduino ilə yanib-sönən led testi.(Blinking led with arduino)

Sadə dövrə elementlərini nəzərdən keçirdikdən sonra arduino testlərinə bashlaya bilərik.

İlk növbədə yanib sonən led sxemini quraq ve kiçik kod yazaraq sxemi işlək hala gətirək.

https://www.tinkercad.com/things/1rEvIPiBTic

Arduino-a qoshulaq və aşağıdakı kodu onu yukləyək.

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

void loop()
{
  digitalWrite(13, HIGH);
  delay(1000); // Wait for 1000 millisecond(s)
  digitalWrite(13, LOW);
  delay(1000); // Wait for 1000 millisecond(s)
}

Sxemi işə saldıqda led-in yanib sondüyünü görəcəyik.

Kodu daha etraflı izah etmeye çalışaq.

Evvelde qeyd edilmiş “void setup()” ilkin parametrlərin təyinini icra edir. Bu funksiya yalnız başlanğıcda çalishir və sonraki dövlərdə bura birdə müraciət olunmur.

“pinMode(13, OUTPUT); ” – 13-cü terminalın çıxış olacağını təyin edir.

“void loop()” – bu kodda istifadə olunan ikinci funksiyadır. Funksiyanin, dəyişənlərin nə olduğuna sonrakı müvzularda toxunacağıq. Bu funksiya sxem işlədiyi muddətcə daimi olaraq çağrılır. Prosessorun bacardığı en böyük sürətlə. Saniyədə min və ya milyon dəfələrə.

  “digitalWrite(13, HIGH); ” – Əvvəldən təyin olunan 13-cü terminali aktiv hala gətirir. Yəni çixişa +5v verir.

 “delay(1000);” – Bir saniyə kodu ləngidir. Ledin yandığının görünməsi üçün.

  “digitalWrite(13, LOW); ” – 13-cü terminal verilən 5v gərginliyi kəsirç 0-a endirir.

  “delay(1000);” – yenidən 1 saniyə kod ləngidilir. Və loop funksiyasi yeniden çağrılır.

Bu mütəmadi olaraq davam edir. Nəticədə bir saniyədən bir yanib sönən led alınır.

Bir gizli təbəqəsi(hidden layer, synapses) olan sadə neyron şəbəkə

import numpy as np
X = np.array([[0, 0, 1], [1, 1, 1], [1, 0, 1], [0, 1, 1]])
y = np.array([[0,1,1,0]]).T
syn0 = 2*np.random.random((3,4)) - 1
syn1 = 2*np.random.random((4,1)) - 1
for j in range(60000):
    l1 = 1/(1+np.exp(-(np.dot(X,syn0))))
    l2 = 1/(1+np.exp(-(np.dot(l1,syn1))))
    l2_delta = (y - l2)*(l2*(1-l2))
    l1_delta = l2_delta.dot(syn1.T) * (l1 * (1-l1))
    syn1 += l1.T.dot(l2_delta)
    syn0 += X.T.dot(l1_delta)

Biraz detallı yazsaq code aşağıdakı kimi olacaq

import numpy as np

def nonlin(x,deriv=False):
	if(deriv==True):
	    return x*(1-x)

	return 1/(1+np.exp(-x))
    
X = np.array([[0,0,1],
            [0,1,1],
            [1,0,1],
            [1,1,1]])
                
y = np.array([[0],
			[1],
			[1],
			[0]])

np.random.seed(1)

# randomly initialize our weights with mean 0
syn0 = 2*np.random.random((3,4)) - 1
syn1 = 2*np.random.random((4,1)) - 1

for j in xrange(60000):

	# Feed forward through layers 0, 1, and 2
    l0 = X
    l1 = nonlin(np.dot(l0,syn0))
    l2 = nonlin(np.dot(l1,syn1))

    # how much did we miss the target value?
    l2_error = y - l2
    
    if (j% 10000) == 0:
        print "Error:" + str(np.mean(np.abs(l2_error)))
        
    # in what direction is the target value?
    # were we really sure? if so, don't change too much.
    l2_delta = l2_error*nonlin(l2,deriv=True)

    # how much did each l1 value contribute to the l2 error (according to the weights)?
    l1_error = l2_delta.dot(syn1.T)
    
    # in what direction is the target l1?
    # were we really sure? if so, don't change too much.
    l1_delta = l1_error * nonlin(l1,deriv=True)

    syn1 += l1.T.dot(l2_delta)
    syn0 += l0.T.dot(l1_delta)

Java script de sadə neyron şəbəkə (simple neuron network with js)


        
var print_log = "";
function nonlin(x) {
return 1 / (1 + nj.exp(-x));
}
function nonli_dev(x) {
return x * (1 - x);
}

        X = nj.array([[0, 0, 1], [1, 1, 1], [1, 0, 1], [0, 1, 1]]);
        y = nj.array([[0,1,1,0]]).T;

        var syn0 = nj.array([[2*Math.random()-1],[2*Math.random()-1],[2*Math.random()-1]]);
        //print_log = syn0;
        //console.log(syn0);

        for (ab = 0; ab < 4000; ab ++ ) {
            l0 = X;
            l1 = nj.sigmoid(nj.dot(l0, syn0));

            l1_error = nj.array([[0,0,0,0]]).T;
            l1_delta = nj.array([[0,0,0,0]]).T;
            for (i = 0; i < l1_error.selection.data.length; i++) {
                l1_i = l1.selection.data[i];
                y_i = y.selection.data[i];

                l1_error.selection.data[i] =  y_i - l1_i;

                l1_error_i = l1_error.selection.data[i];

                l1_delta.selection.data[i] = l1_error_i * nonli_dev(l1_i);
            }

            syn0_delta = nj.dot(l0.T, l1_delta);

            for (i = 0; i < syn0.selection.data.length; i++) {
                a = syn0.selection.data[i];
                syn0.selection.data[i] += syn0_delta.selection.data[i];
            }
            //print_log = print_log + "<br>" + l1_error;
        }

        //console.log(y);
        print_log = print_log + "<br>" + l1;

Neyron şəbəkələrə sadə nümünə(simple neuron network example)

Piton(python) proqramlaşdırma dilində sadə neyron şəbəkə aşağı kimidir:

from numpy import exp, array, random, dot
X = array([[0, 0, 1], [1, 1, 1], [1, 0, 1], [0, 1, 1]])
y = array([[0,1,1,0]]).T
random.seed(1)
syn0 = 2*random.random((3,1)) - 1
print(syn0)
for iteration in range(10000):
    l1 = 1/(1+exp(-(dot(X,syn0))))
    syn0 += dot(X.T, (y - l1) * l1 * (1 - l1))
print(syn0)

print(1 / (1 + exp(-(dot(array([1, 0, 0]), syn0)))))

Daha detallı:

import numpy as np


# sigmoid function 0 ve 1 arasinda bir deyer alir hemishe, deriv=true tepe noqtesi 0 olan menfi ededlerdir /\
def nonlin(x, deriv=False):
    if (deriv == True):
        return x * (1 - x)
    return 1 / (1 + np.exp(-x))


# input dataset
X = np.array([[0, 0, 1],
              [0, 1, 1],
              [1, 0, 1],
              [1, 1, 1]])

# output dataset .T sertlerle sutunlarin yerini deyishir, burada bir setr yaradir sonra onu sutuna cevirir. Birbasha sutunda yaratmaq olar(array([[0], [0], [1], [1]]))
y = np.array([[0, 0, 1, 1]]).T

# seed random numbers to make calculation
# deterministic (just a good practice), neticesi sadece null-dur
np.random.seed(1)

# initialize weights randomly with mean 0, -1 ve 1 arasinda 3 eded 1 setrli matrix generate edir( np.random.random((3, 1))- 0-1 arasinda olan matrix) 2-ye vurub 1 cixdiqda deyer -1 ve 1 arasinda alinir
syn0 = 2 * np.random.random((3, 1)) - 1

for iter in range(10000):
    # forward propagation - l0 girish matrixdir, l1 cixish. l0 ve generate olunmush -1 ve 1 arasinda olan martixsi bir-birine vurur ve alinan deyerleri 0-1 arasina cevirir
    l0 = X
    l1 = nonlin(np.dot(l0, syn0))

    # how much did we miss? dogru cavabdan biz tesadufi aldigimiz deyerleri cixir ve bizim sehvmizini tapiriq
    l1_error = y - l1

    # multiply how much we missed by the
    # slope of the sigmoid at the values in l1, sehvin deltasini tapiriq
    l1_delta = l1_error * nonlin(l1, True)

    # update weights, etdiyimiz sehv qeder dogruya yaxinlashiriq ve procedurur defelerle icra ederek dogruya yaxin netice almaga calishiriq
    syn0 += np.dot(l0.T, l1_delta)

print("Output After Training:")
print(l1)