განათების კონტროლის სისტემა: 9 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:18

ცოტა ხნის წინ ვმუშაობდი მიკროკონტროლერების და IOT დაფუძნებული მოწყობილობების გაგებაზე უსაფრთხოების კვლევის მიზნებისთვის. ასე რომ, მე ვიფიქრე პრაქტიკაში პატარა სახლის ავტომატიზაციის სისტემის შექმნაზე. მე ჯერ არ დავასრულებ ამას, მაგრამ გაშვებისთვის მე გაგიზიარებთ როგორ გამოვიყენე Raspberry Pi 2 და სხვა რამდენიმე ელექტრული კომპონენტი ამ პოსტში ჩემი ოთახის განათების გასაკონტროლებლად. ასევე, მე არ ვისაუბრებ ჟოლოს საწყის დაყენებაზე, თქვენ შეგიძლიათ იპოვოთ სხვადასხვა გაკვეთილები ამისათვის.

მაგრამ ამ პროექტში მე წარმოგიდგენთ ამ docker pi სერიის პროდუქტს.

მარაგები

კომპონენტების სია:

• 1 x Raspberry Pi 3B+/3B/Zero/Zero W/4B/
• 1 x 16 GB კლასი 10 TF ბარათი
• 1 x DockerPi სერია 4 არხის სარელეო დაფა (HAT)
• 1 x [email protected] კვების ბლოკი, რომელიც 52Pi– დან არის
• 4 x მსუბუქი ზოლები
• 1 x DC კონექტორი
• 1 x 12V კვების ბლოკი მსუბუქი ზოლებისთვის.
• რამდენიმე მავთული.

ნაბიჯი 1: იცოდეთ DockerPi სერიის 4 არხის სარელეო დაფის შესახებ

DockerPi 4 არხის სარელეო არის DockerPi სერიის წევრი, უფრო ხშირად გამოიყენება IOT პროგრამებში.

DockerPi 4 არხის სარელეო შეუძლია გადააწოდოს AC/DC, ტრადიციული კონცენტრატორების ნაცვლად, მეტი იდეის მისაღწევად. DockerPi 4 არხის სარელეო შეიძლება დააგროვოს 4 - მდე და შეიძლება იყოს დაწყობილი სხვა DockerPi გაფართოების დაფაზე. თუ თქვენ გჭირდებათ დიდი ხნის განმავლობაში გაშვება, ჩვენ ასევე გირჩევთ გამოიყენოთ ჩვენი DockerPi Power გაფართოების დაფა მეტი ენერგიის უზრუნველსაყოფად.

სიფრთხილის შენიშვნა სანამ გავაგრძელებდით, მინდა გაგაფრთხილოთ "ქსელის ელექტროენერგიის" ექსპერიმენტის საფრთხის შესახებ. თუ რამე არასწორედ წავა, ყველაზე ცუდი შედეგი შეიძლება იყოს სიკვდილი ან მინიმუმ საკუთარი სახლის დაწვა. ასე რომ, გთხოვთ ნუ ეცდებით ამ სტატიაში აღწერილი არაფრის გაკეთებას, თუ არ გესმით რას აკეთებთ ან უკეთესია დახმარებისთვის მიმართოთ გამოცდილ ელექტრიკოსს. Დავიწყოთ.

ნაბიჯი 2: მახასიათებლები

• DockerPi სერია
• პროგრამირებადი
• კონტროლი პირდაპირ (პროგრამირების გარეშე)
• გააფართოვეთ GPIO ქინძისთავები
• 4 არხის სარელეო
• 4 Alt I2C Addr მხარდაჭერა
• სარელეო სტატუსი Leds მხარდაჭერა
• 3A 250V AC მხარდაჭერა
• 3A 30V DC
• შეიძლება დასტა სხვა დასტის დაფასთან დამოუკიდებლად დედაპლატის აპარატურისგან (მოითხოვს I2C მხარდაჭერას)

ნაბიჯი 3: მოწყობილობის მისამართის რუკა

ამ დაფას აქვს ცალკე რეგისტრაციის მისამართი და თქვენ შეგიძლიათ აკონტროლოთ თითოეული სარელეო ერთი ბრძანებით.

სხვა მოთხოვნები:

პითონის ან C– ს, shell– ის ან Java– ს ან სხვა ენის ძირითადი გაგება (მე ვიყენებ C– ს, python– ს, shell– ს და java– ს)

• Linux სისტემების ძირითადი გაგება
• გონების ყოფნა

ახლა, სანამ წინ მიიწევთ, თქვენ უნდა გესმოდეთ ელექტრული კომპონენტები, რომლებსაც ჩვენ ვიყენებთ:

1. სარელეო:

სარელეო არის ელექტრო მოწყობილობა, რომელიც ჩვეულებრივ გამოიყენება მაღალი ძაბვების გასაკონტროლებლად ძალიან დაბალი ძაბვის შესაყვანად. იგი შედგება ბოძზე შემოხვეული ხვეულიდან და ორი პატარა ლითონის ფლაპიდან (კვანძები), რომლებიც გამოიყენება წრის დახურვის მიზნით. ერთი კვანძი ფიქსირდება, მეორე კი მოძრავია. როდესაც ელექტროენერგია გაივლის კოჭას, ის ქმნის მაგნიტურ ველს და იზიდავს მოძრავ კვანძს სტატიკური კვანძისკენ და წრე სრულდება. ამრიგად, მხოლოდ მცირე ძაბვის გამოყენებით კოჭის გაძლიერება ჩვენ შეგვიძლია რეალურად დავასრულოთ მაღალი ძაბვის წრე. ასევე, ვინაიდან სტატიკური კვანძი ფიზიკურად არ არის დაკავშირებული კოჭასთან, გაცილებით ნაკლებია შანსი, რომ მიკროკონტროლერი, რომელიც ამუშავებს კოჭას, დაზიანდეს, თუ რამე არასწორედ წავა.

ნაბიჯი 4: შეაერთეთ რელე ნათურის დამჭერთან, რომელიც იკვებება მთავარი ელექტრომომარაგებით

ახლა რაც შეეხება რთულ ნაწილს, ჩვენ დავუკავშირდებით რელეს ნათურის დამჭერთან, რომელიც იკვებება მთავარი ელექტრომომარაგებით. მაგრამ, პირველ რიგში მინდა მოგაწოდოთ მოკლე წარმოდგენა იმის შესახებ, თუ როგორ ხდება ნათურების ჩართვა და გამორთვა პირდაპირი დენის წყაროს მეშვეობით.

ახლა, როდესაც ნათურა დაკავშირებულია მთავარ წყაროსთან, ჩვენ ამას ჩვეულებრივ ვაკეთებთ ბოლქვთან ორი მავთულის შეერთებით. ერთი მავთული არის "ნეიტრალური" მავთული და მეორე არის "უარყოფითი" მავთული, რომელიც რეალურად ახორციელებს დენს, ასევე არის გადამრთველი დამატებული მთელ წრეზე, რათა გააკონტროლოს ON OFF მექანიზმი. ასე რომ, როდესაც სვიტი არის დაკავშირებული (ან ჩართულია) დენი მიედინება ნათურაში და ნეიტრალურ მავთულში, ასრულებს წრეს. ეს ჩართავს ნათურას. როდესაც გადამრთველი ჩართულია, ის არღვევს წრეს და ნათურა გამორთულია. აქ არის მცირე წრიული დიაგრამა ამის ახსნისთვის:

ახლა, ჩვენი ექსპერიმენტისთვის, ჩვენ გვჭირდება, რომ "უარყოფითი მავთული" გაიაროს ჩვენს რელეში, რომ შეწყვიტოს წრე და გააკონტროლოს დენის ნაკადი რელეს გადართვის გამოყენებით. ასე რომ, როდესაც რელე ჩართულია, მან უნდა დაასრულოს წრე და ნათურა უნდა ჩართოს და პირიქით. იხილეთ ქვემოთ მოცემული დიაგრამა სრული წრედისთვის.

ნაბიჯი 5: I2C (Raspberry Pi) კონფიგურაცია

გაუშვით sudo raspi-config და მიჰყევით მოთხოვნებს, რომ დააინსტალიროთ i2c მხარდაჭერა ARM core და linux kernel

გადადით ინტერფეისის პარამეტრებზე

ნაბიჯი 6: პირდაპირი კონტროლი პროგრამირების გარეშე (Raspberry Pi)

ჩართეთ არხის No.1 სარელეო

i2cset -y 1 0x10 0x01 0xFF

გამორთეთ არხი No.1 სარელეო

i2cset -y 1 0x10 0x01 0x00

ჩართეთ არხი No2 სარელეო

i2cset -y 1 0x10 0x02 0xFF

გამორთეთ არხი No2 სარელეო

i2cset -y 1 0x10 0x02 0x00

ჩართეთ არხი No3 სარელეო

i2cset -y 1 0x10 0x03 0xFF

გამორთეთ არხი No3 სარელეო

i2cset -y 1 0x10 0x03 0x00

ჩართეთ არხი No4 სარელეო

i2cset -y 1 0x10 0x04 0xFF

გამორთეთ არხი No4 სარელეო

i2cset -y 1 0x10 0x04 0x00

ნაბიჯი 7: პროგრამა ენაზე C (ჟოლო Pi)

შექმენით საწყისი კოდი და დაასახელეთ "relay.c"

#ჩართეთ

#ჩართეთ

#ჩართეთ

#განსაზღვრეთ DEVCIE_ADDR 0x10

#განსაზღვრეთ RELAY1 0x01

#განსაზღვრეთ RELAY2 0x02

#განსაზღვრეთ RELAY3 0x03

#განსაზღვრეთ RELAY4 0x04

#განსაზღვრეთ 0xFF

#განსაზღვრეთ გამორთული 0x00

მთავარი (ბათილია)

{

printf ("ჩართეთ რელეები C / n");

int fd;

int i = 0;

fd = გაყვანილობაPiI2C დაყენება (DEVICE_ADDR);

for (;;) {

for (i = 1; i <= 4; i ++)

{

printf ("ჩართეთ სარელეო ნომერი $ d", i);

გაყვანილობაPiI2CWriteReg8 (fd, i, ON);

ძილი (200);

printf ("გამორთეთ რელე No $ d", i);

გაყვანილობაPiI2CWriteReg8 (fd, i, OFF);

ძილი (200);

}

}

დაბრუნება 0;

}

შეადგინეთ იგი

gcc სარელეო. c -lwiringPi -o სარელეო

შეასრულეთ

./ სარელეო

ნაბიჯი 8: პროგრამა პითონში (Raspberry Pi)

შემდეგი კოდი რეკომენდირებულია Python 3 -ის გამოყენებით და smbus ბიბლიოთეკის დაყენება:

შექმენით ფაილი სახელწოდებით: "relay.py" და ჩასვით შემდეგი კოდი:

იმპორტის დრო როგორც t

smbus- ის იმპორტი

იმპორტის სისტემა

DEVICE_BUS = 1

DEVICE_ADDR = 0x10

ავტობუსი = smbus. SMBus (DEVICE_BUS)

მართალია:

სცადე:

მე დიაპაზონში (1, 5):

bus.write_byte_data (DEVICE_ADDR, i, 0xFF)

ტ. ძილი (1)

bus.write_byte_data (DEVICE_ADDR, i, 0x00)

ტ. ძილი (1)

გარდა კლავიატურის უწყვეტი, როგორც e:

ბეჭდვა ("დატოვე მარყუჟი")

sys.exit ()

* შეინახეთ და შემდეგ გაუშვით როგორც python3:

python3 სარელეო. py

ნაბიჯი 9: პროგრამა Java (Raspberry Pi)

შექმენით ახალი ფაილი სახელწოდებით: I2CRelay.java და ჩასვით შემდეგი კოდი:

იმპორტი java.io. IOException;

იმპორტი java.util. Arrays;

იმპორტი com.pi4j.io.i2c. I2CBus;

იმპორტი com.pi4j.io.i2c. I2CD მოწყობილობა;

იმპორტი com.pi4j.io.i2c. I2C ქარხანა;

იმპორტი com.pi4j.io.i2c. I2CFactory. UnsupportedBusNumberException;

იმპორტის com.pi4j.platform. PlatformAlreadyAssignedException;

იმპორტი com.pi4j.util. Console;

საჯარო კლასი I2CRelay {

// სარელეო რეგისტრის მისამართი.

საჯარო სტატიკური ფინალი DOCKER_PI_RELAY_ADDR = 0x10;

// სარელეო არხი.

საჯარო სტატიკური საბოლოო ბაიტი DOCKER_PI_RELAY_1 = (ბაიტი) 0x01;

საჯარო სტატიკური საბოლოო ბაიტი DOCKER_PI_RELAY_2 = (ბაიტი) 0x02;

საჯარო სტატიკური საბოლოო ბაიტი DOCKER_PI_RELAY_3 = (ბაიტი) 0x03;

საჯარო სტატიკური საბოლოო ბაიტი DOCKER_PI_RELAY_4 = (ბაიტი) 0x04;

// სარელეო სტატუსი

საჯარო სტატიკური საბოლოო ბაიტი DOCKER_PI_RELAY_ON = (ბაიტი) 0xFF;

საჯარო სტატიკური საბოლოო ბაიტი DOCKER_PI_RELAY_OFF = (ბაიტი) 0x00;

public static void main (String args) ისვრის InterruptException, PlatformAlreadyAssignedException, IOException, UnsupportedBusNumberException {

საბოლოო კონსოლის კონსოლი = ახალი კონსოლი ();

I2CBus i2c = I2CFactory.getInstance (I2CBus. BUS_1);

I2CD მოწყობილობა = i2c.getDevice (DOCKER_PI_RELAY_ADDR);

console.println ("ჩართე სარელეო!");

device.write (DOCKER_PI_RELAY_1, DOCKER_PI_RELAY_ON);

თემა. ძილი (500);

console.println ("გამორთეთ სარელეო!");

device.write (DOCKER_PI_RELAY_1, DOCKER_PI_RELAY_OFF);

}

}