ეფექტური Java განვითარება Raspberry Pi– სთვის: 11 ნაბიჯი (სურათებით)

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

ეს ინსტრუქცია აღწერს ძალიან ეფექტურ მიდგომას Raspberry Pi– სთვის Java პროგრამების შემუშავებისთვის. მე გამოვიყენე მიდგომა Java- ს შესაძლებლობების განვითარებისათვის, დაწყებული დაბალი დონის მოწყობილობის მხარდაჭერიდან დაწყებული, მრავალძირიანი და ქსელური პროგრამებით დამთავრებული. მიდგომა არა მხოლოდ ეფექტურია, ის უფასოა!

ფუნდამენტურად, მიდგომა არის დისტანციური განვითარება NetBeans– ის გამოყენებით. NetBeans მუშაობს სამუშაო სადგურზე (დესკტოპის ან ლეპტოპის კომპიუტერი და არა Raspberry Pi), რომელიც დაკავშირებულია Wifi– ით Raspberry Pi– თან. მას შემდეგ რაც ყველაფერი დალაგდება, შეგიძლიათ ჩაწეროთ Java პროგრამა NetBeans– ში და შემდეგ ერთი დაწკაპუნებით შეადგინოთ და ააწყოთ პროგრამა სამუშაო სადგურზე, გადმოწეროთ პროგრამა Pi– ზე, გაუშვათ პროგრამა Pi– ზე და გამოაქვეყნოთ NetBeans კონსოლზე. რა მაგია! თქვენ ასევე შეგიძლიათ გამართოთ გაშვებული პროგრამა, დააყენოთ შესვენების წერტილები და შეისწავლოთ ცვლადი მნიშვნელობები. მეტი მაგია!

ამ შესავლის დანარჩენი ნაწილი აღწერს ჯავის გამოყენების მოტივაციას და NetBeans– ის დისტანციური განვითარებისათვის. თუ გაინტერესებთ მოტივაცია, წაიკითხეთ. თუ არ გაინტერესებთ, გადადით ნაბიჯი 1 -ზე.

რატომ გამოვიყენოთ Java Raspberry Pi– ზე?

არსებობს მრავალი პროგრამირების ენა Raspberry Pi– სთვის, მაგრამ მე განვიხილავ დისკუსიას „პროფესიონალური კლასის“პროგრამირების ენებზე, რომლებიც მიზნად ისახავს დამოუკიდებელ პროგრამებს, მხარს უჭერს მრავალ ამოცანას, იძლევა ტექნიკურ და ქსელურ წვდომას და ა.შ. ეს ნიშნავს Java, Python, ან C/C ++. Raspbian– ის უახლესი გამოცემები მოიცავს ყველა ამ ენის შემუშავებასა და გაშვებას.

პითონი ფაქტიურად "დაწინაურებულია" Pi- ზე გამოსაყენებლად, ნაწილობრივ მაინც ახალი პროგრამისტებისთვის სწავლის სიმარტივის გამო. მე ვარ გამოცდილი პროგრამისტი და არ მიყვარს პითონი მისი არაერთი მახასიათებლის აშკარად სუბიექტური ზიზღის გამო, მაგალითად, დინამიური აკრეფით. პითონისთვის არის ერთი მახასიათებელი, რომლის მიმართაც არ მომწონს ობიექტური - შესრულება. ეს წყარო გვიჩვენებს, რომ Java ყოველთვის უფრო სწრაფია ვიდრე Python 3 და ფაქტობრივად ასობითჯერ უფრო სწრაფად მუშაობს ამოცანის მიხედვით.

ჩემი აზრით, C არის "მაღალი დონის მანქანების ენა", ანუ ის, რაც ძალიან ახლოს არის სისტემის ტექნიკასთან, ან თუნდაც ოპერაციულ სისტემასთან. თქვენ შეგიძლიათ გააკეთოთ თითქმის ყველაფერი და ამის გაკეთება შეგიძლიათ რაც შეიძლება სწრაფად; ფაქტობრივად, ეს წყარო ვარაუდობს, რომ C- ს შეუძლია გაუშვას 7X -მდე უფრო სწრაფად, ვიდრე ჯავა. მე ასევე არ მიყვარს C, რადგან მე (სუბიექტურად) არ მომწონს მისი ზოგიერთი მახასიათებელი, რომელიც მე არკანულად, არქაულად ან ორივედ მიმაჩნია; მაგალითად, მკაფიო მითითებები. ობიექტურად, ის, რომ შენ შეგიძლია რამის გაკეთება, ნიშნავს რომ შენ ხარ მხოლოდ ბუნდოვანი ხარვეზი (მაგ., ცუდი მაჩვენებლის არითმეტიკა ან მცდარი მეხსიერება) მეხსიერების გადაწერას და პროგრამის ან მთელი სისტემის პოტენციურად ჩამონგრევას. ჯავა ხელს უშლის ასეთ საფრთხეებს, ამიტომ ჯავა უფრო უსაფრთხოა. ვგრძნობ, რომ უსაფრთხოება ასევე აუმჯობესებს პროგრამისტების პროდუქტიულობას. მე C ++ მიმაჩნია ობიექტზე ორიენტირებულ „შეფუთვაში“C– ს გარშემო, რომელიც არაფერს აკეთებს C– ს საფრთხეების აღმოსაფხვრელად.

დასკვნა: ჯავა უფრო სწრაფია ვიდრე პითონი. ჯავა უფრო უსაფრთხოა ვიდრე C.

არსებობს შეზღუდვები ჯავის გამოყენებისას?

ჯერჯერობით, მე შემიძლია გავაკეთო ყველაფერი Java, რაც შემიძლია გავაკეთო პითონში. არის რაღაცეები, რისი გაკეთებაც შეიძლება C– ში, რისი გაკეთებაც შეუძლებელია ჯავაში, მაგრამ ისევ და ისევ, ჯერჯერობით ყველაფერი, რისი გაკეთებაც მსურდა, მიმართული იყო ჯავის თაყვანისმცემლების მიერ Pi საზოგადოებაში. მაგალითს შემოგთავაზებთ შემდგომ საფეხურზე. როგორც ვთქვი, მე შევიძინე სენსორები გამყიდველებისგან, რომლებიც ამარაგებდნენ "დრაივერებს" სენსორებისთვის მხოლოდ პითონში (ან C/C ++ არდუინოსთვის), ამიტომ ჯავის ექვივალენტი უნდა დამეწერა; დამატებითი ძალისხმევა სულაც არ არის პროდუქტიული, მაგრამ შეიძლება გამოიწვიოს სენსორის მუშაობის უფრო დიდი წარმოდგენა.

რატომ არის დისტანციური განვითარება NetBeans– ზე დაფუძნებული?

მე აღმოვაჩინე, რომ NetBeans– ზე დაფუძნებული დისტანციური განვითარება მნიშვნელოვნად ზრდის პროდუქტიულობას Raspberry Pi– სთვის Java– ს გამოყენებისას. მე დარწმუნებული ვარ, რომ თქვენ შეგიძლიათ გამოიყენოთ მიდგომა სწრაფი და უსაფრთხო პროგრამების შესაქმნელად, Java– ს თანდაყოლილი მახასიათებლების გამო, მათი წერის, შექმნისა და გამართვისას ბევრად უფრო სწრაფად, ვიდრე სხვა მიდგომები, რაც მე აღმოვაჩინე, „პროფესიონალის“დისტანციური განვითარების გამო. კლასი NetBeans ინტეგრირებული განვითარების გარემო (IDE).

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

Raspbian– ში შემავალი VNC სერვერი უზრუნველყოფს დისტანციურ გრაფიკულ ინტერფეისს (GUI), რომელიც იძლევა დისტანციური განვითარების ფორმას, სადაც მხოლოდ დისტანციური GUI მუშაობს სამუშაო სადგურზე და ყველაფერი დანარჩენი, წერა, შედგენა და აგება ხდება Pi– ზე. VNC– ით ადვილია გამოიყენოთ Java– ს განვითარების ინსტრუმენტები, რომლებიც იგზავნება Raspbian– ში, როგორიცაა BlueJ, Geany და Greenfoot. ზოგიერთი მათგანი შეიძლება ჩაითვალოს IDE; თუმცა, მე ვხედავ მათ შორს პროფესიული კლასისგან.

ტექნიკურად შესაძლებელია დააინსტალიროთ პროფესიონალური კლასის Java IDE, როგორიცაა Eclipse ან NetBeans Raspberry Pi– ზე და გამოიყენოთ იგი დისტანციურად VNC– ის საშუალებით. მოხსენებები და საღი აზრი ვარაუდობენ, რომ შედეგები იქნება იმედგაცრუებული, მეხსიერების დიდი ნაკვალევისა და პროცესორის სიმძლავრის გამო, რაც მოითხოვს ასეთ IDE– ებს, ასევე დისტანციური GUI– ს მიერ შემოღებულ ქსელის ლატენტურობას.

Eclipse და NetBeans ძალიან კარგად მუშაობს სამუშაო სადგურზე. Eclipse– ით კოდის წერა სასიამოვნო გამოცდილებაა, თუმცა პროგრამის შექმნა არ არის; პროგრამის გადმოტვირთვა უნდა მოხდეს Eclipse– ის გარეთ; Pi– ზე პროგრამის შესრულება სრულიად დამოუკიდებელია Eclipse– ისგან. საერთო შედეგი არის მრავალსაფეხურიანი, თითქმის მტკივნეული პროცესი, რომელსაც არ შეუძლია დისტანციური გამართვის მხარდაჭერა. NetBeans– ს აქვს ჩაშენებული შედგენა, აშენება, გადმოტვირთვა, დისტანციური შესრულება და დისტანციური გამართვა, რაც მას საუკეთესო მიდგომად აქცევს.

ნაბიჯი 1: შექმენით Raspberry Pi

დისტანციური განვითარების მიდგომის გამოსაყენებლად თქვენ უნდა დაიწყოთ სამიზნე Raspberry Pi– ს დაყენებით. არსებობს მრავალი რესურსი, მათ შორის Instructables, რომელიც დაგეხმარებათ Raspberry Pi– ის დაყენებაში. იხილეთ ეს Pi- ს (და სხვა) შექმნის საფუძვლები.

ეს ინსტრუქცია გულისხმობს თქვენ

• დააინსტალირეთ უახლესი Raspbian; დარწმუნდით, რომ ჩაწერეთ Pi მომხმარებლის ID და პაროლი
• დააყენეთ Wifi და დაუკავშირდით თქვენს როუტერს (იხილეთ ეს); დარწმუნდით, რომ ჩაწერეთ Pi- ს IP მისამართი
• ჩართეთ SSH (იხილეთ ეს), რათა დაუშვას დისტანციური წვდომა Pi– ზე სამუშაო სადგურიდან

დაყენების დასრულების შემდეგ შეგიძლიათ გამორთოთ და გათიშოთ ეკრანი, კლავიატურა და მაუსი Pi– დან. ეს არის დისტანციური განვითარების ერთ -ერთი მთავარი უპირატესობა. თქვენ უნდა დატოვოთ ნებისმიერი Wifi dongle დაკავშირებული (არ არის საჭირო, რა თქმა უნდა, Pi მოდელისთვის 3 ან Pi Zero W), შემდეგ კი შეგიძლიათ Pi- ს ჩართვა.

შესამოწმებლად, გახსენით ssh კლიენტი თქვენს სამუშაო სადგურზე, მაგ., ტერმინალი MacOS– ზე ან ჩამკეტი Windows– ზე. შემდეგ შეიყვანეთ ssh (უსაფრთხო გარსი) ბრძანება შემდეგი ფორმით:

ssh the_pi_ip_address -l the_pi_user_id

თქვენ უნდა მიიღოთ მოთხოვნა შეიყვანოთ თქვენი Pi მომხმარებლის ID პაროლი. თუ მოთხოვნა არ გამოჩნდება, შეამოწმეთ, რომ ssh ბრძანებაში შეიყვანეთ სწორი IP მისამართი. შეიყვანეთ თქვენი პაროლი (ის დაიმალება) და თქვენ უნდა ნახოთ Pi- ს გარსი, რომელიც ასე გამოიყურება:

pi@raspberrypi: ~ $

თუ თქვენ ვერ ხედავთ მოთხოვნას, გადაამოწმეთ თქვენ მიერ გამოყენებული მომხმარებლის ID და პაროლი.

ახლა თქვენ უნდა იპოვოთ გზა Java გაშვებისაკენ და დაადასტუროთ ნაგულისხმევი ვერსია Java 8 (უნდა იყოს ჭეშმარიტი უახლესი Raspbian– ისთვის). ჯავას გაშვების გზის საპოვნელად, ssh კლიენტში შეიყვანეთ ბრძანება

sudo განახლება-ალტერნატივები-java- ს ჩვენება

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

java - ავტომატური რეჟიმი

ბმულის საუკეთესო ვერსია არის/usr/lib/jvm/jdk-8-oracle-arm32-vfp-hflt/jre/bin/java

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

თუ ნაგულისხმევი გაშვების დრო არ არის Java 8, ssh კლიენტში შეიყვანეთ შემდეგი ბრძანება Java 8 -ზე გადასასვლელად (ვარაუდობენ, რომ ის დაინსტალირებულია)

sudo განახლება-ალტერნატივები-კონფიგურაცია ჯავა

ნაბიჯი 2: დააინსტალირეთ NetBeans სამუშაო სადგურზე

ახლა თქვენ უნდა დააინსტალიროთ NetBeans თქვენს სამუშაო სადგურზე. მიუთითეთ თქვენი სამუშაო სადგურის ბრაუზერი NetBeans ჩამოტვირთვის გვერდზე. თქვენ ნახავთ რამდენიმე შესაძლო პაკეტს, რომელიც მხარს უჭერს Java– ს ორ გამოცემას, ისევე როგორც სხვა ენებს. ყველაფერი რაც თქვენ გჭირდებათ Raspberry Pi– სთვის Java განვითარებისათვის არის Java SE, მაგრამ შეგიძლიათ მიიღოთ Java EE პაკეტი ან All bundle. მას შემდეგ რაც გადაწყვეტთ რომელი პაკეტი გსურთ დააწკაპუნეთ შესაბამის ჩამოტვირთვა ღილაკზე. თქვენ შეგიძლიათ იპოვოთ დამატებითი ინსტრუქციები თქვენი სამუშაო სადგურის OS– სთვის აქ.

მას შემდეგ რაც დააინსტალირებთ NetBeans, დაიწყეთ (ეს შეიძლება ავტომატურად გაკეთდეს ინსტალაციის შემდეგ). თქვენ უნდა ნახოთ NetBeans– ის მთავარი ფანჯარა, როგორც ეს მოცემულია სურათზე. სურათი გადაღებულია Mac– ზე და Windows– ის მთავარი ფანჯარა შეიძლება ოდნავ განსხვავებული იყოს.

მას შემდეგ რაც წარმატებით დააინსტალირეთ და დაიწყეთ NetBeans, გადადით შემდეგ საფეხურზე.

ნაბიჯი 3: Raspberry Pi როგორც დისტანციური პლატფორმის კონფიგურაცია NetBeans– ში

შემდეგი ქმედებები აყალიბებს Raspberry Pi როგორც დისტანციური Java SE პლატფორმა NetBeans– ისთვის. ეს საშუალებას აძლევს NetBeans– ს ჩამოტვირთოს და შეასრულოს Java პროგრამები Pi– ზე. თქვენ შეგიძლიათ იპოვოთ გარკვეულწილად ზოგადი აღწერა აქ.

შენიშვნა: ამ და მომდევნო ნაბიჯებში მე ვაჩვენებ ჩემს გარემოს სპეციფიკურ ღირებულებებს კონფიგურაციისა და კოდირების სხვადასხვა ასპექტისთვის; შენი აშკარად განსხვავებული იქნება

Pi როგორც დისტანციური პლატფორმა კონფიგურაციისთვის:

1. NetBeans– ის მთავარ მენიუს ზოლში აირჩიეთ Tools -> Java Platforms. თქვენ ნახავთ Java პლატფორმის მენეჯერის ამომხტარ ფანჯარას (სურათი ერთი).
2. დააწკაპუნეთ პლატფორმის დამატებაზე ქვედა მარცხენა კუთხეში. თქვენ ნახავთ დამატებით Java პლატფორმას [პლატფორმის ტიპი] ამომხტარი ფანჯარა (სურათი მეორე).
3. აირჩიეთ დისტანციური ჯავის სტანდარტული გამოცემა. დააწკაპუნეთ შემდეგი. თქვენ იხილავთ დამატებით Java პლატფორმას [შეიქმნა დისტანციური პლატფორმა] ამომხტარი ფანჯარა (სურათი სამი გვიჩვენებს ამომხტარი მას შემდეგ, რაც ველში შევიტანე შესაბამისი მნიშვნელობები ჩემი გარემოსთვის).
4. პლატფორმის სახელის ველში შეიყვანეთ სახელი Pi. თქვენ შეგიძლიათ გამოიყენოთ თითქმის ყველაფერი, მაგრამ ის უნდა იყოს უნიკალური.
5. მასპინძლის ველში შეიყვანეთ IP მისამართი Pi– ში, რომელიც ნაპოვნია 1 ნაბიჯში.
6. მომხმარებლის სახელის ველში შეიყვანეთ მომხმარებლის სახელი, რომელიც გამოიყენეთ 1 -ლი ნაბიჯი.
7. დატოვეთ გამოყენების პაროლის ავთენტიფიკაცია არჩეული და პაროლის ველში შეიყვანეთ პაროლი, რომელიც შექმენით ნაბიჯი 1.
8. დისტანციური JRE Path ველში თქვენ უნდა შეიყვანოთ Pi– ზე Java– ს გაშვების გზის უმეტესი ნაწილი. ნაბიჯი 1, ეს იყო/usr/lib/jvm/jdk-8-oracle-arm32-vfp-hflt/jre/bin/java. ამასთან, თქვენ უნდა ჩამოაგდოთ off /bin /java ველის მნიშვნელობაში.
9. NetBeans გადმოტვირთავს გაშვებულ პროგრამას სამუშაო დირექტორიაში Pi- ზე, რომელიც გამოვლენილია სამუშაო დიარის ველში. ნაგულისხმევი არის/the_Pi_user_ID/NetBeansProjects/და ის სავსებით მისაღებია. სურვილისამებრ შეგიძლიათ გამოიყენოთ რაღაც განსხვავებული, თუმცა ის ხელმისაწვდომი უნდა იყოს the_Pi_user_ID (სურათი სამი).
10. დააწკაპუნეთ დასრულება ამომხტარი ფანჯრის ქვედა მარჯვენა კუთხეში. დამუშავების შემდეგ, თქვენ კვლავ უნდა ნახოთ Java პლატფორმის მენეჯერის ამომხტარი ფანჯარა. ახლა თქვენ უნდა ნახოთ თქვენი დისტანციური Pi (იმ სახელით, რომელიც თქვენ გამოიყენეთ მე –4 მოქმედებაში ზემოთ) კატეგორიის დისტანციური Java SE (სურათი ოთხი).
11. დააწკაპუნეთ სატესტო პლატფორმაზე ქვედა მარცხნივ, რათა შეამოწმოთ კავშირი NetBeans– სა და თქვენს Pi– ს შორის. თქვენ პირველად ნახავთ ამომხტარ ფანჯარას, რომელიც ამბობს „დისტანციური პლატფორმის გადამოწმება“. წარმატების შემთხვევაში, თქვენ მიიღებთ მეორე ამომხტარ ფანჯარას, რომელშიც მითითებულია კავშირი… წარმატებით დამყარდა. თუ არა, თქვენ უნდა შეამოწმოთ და შეასწოროთ ინფორმაცია, რომელიც შეიყვანეთ დამატებული ჯავის პლატფორმის [დისტანციური პლატფორმის დაყენება] ამომხტარ ფანჯარაში ზემოთ 5-9 მოქმედებებში. ამის გაკეთება შეგიძლიათ Java პლატფორმის მენეჯერის ამომხტარი ფანჯრიდან; უბრალოდ შეარჩიეთ თქვენი Pi პლატფორმა და შემდეგ შეცვალეთ ველები ამომხტარი ფანჯრის მარჯვენა მხარეს.
12. წარმატებული კავშირის შემდეგ, დააწკაპუნეთ დახურვაზე Java Platform Manager Manager- ში. ახლა თქვენ ნახავთ NetBeans– ის მთავარ ფანჯარას.

ახლა ნამდვილი გართობა შეიძლება დაიწყოს!

ნაბიჯი 4: შექმენით Java პროექტი სამუშაო სადგურზე

ეს არ არის გამიზნული იმის ახსნა, თუ როგორ გამოვიყენოთ NetBeans, ან Java, მაგრამ მე აღვწერ მინიმალურ ქმედებებს, რომ დავწერო პროგრამა NetBeans– ში სამუშაო სადგურზე და, საბოლოოდ, გავუშვა პროგრამა დისტანციურად Raspberry Pi– ზე.

NetBeans– ში თქვენ ჯერ უნდა შექმნათ პროექტი პროგრამის Java კლასისთვის. გარდა ამისა, ჯავაში კლასები ინახება პაკეტებში ორგანიზაციისა და უსაფრთხოების მხარდასაჭერად. პროექტის შესაქმნელად და სურვილისამებრ შექმენით პაკეტი და კლასის ფაილი:

1. NetBeans– ის მთავარ ფანჯარაში დააწკაპუნეთ ახალი პროექტის ხატულაზე (მეორე მარცხნიდან). თქვენ ნახავთ ახალ პროექტს [აირჩიე პროექტი] ამომხტარი ფანჯარა (სურათი ერთი).
2. ნაგულისხმევი (კატეგორია: ჯავა, პროექტი: ჯავა პროგრამა) სწორია ამ მაგალითისთვის, ასე რომ უბრალოდ დააწკაპუნეთ შემდეგზე. თქვენ ნახავთ ახალ Java პროგრამას [სახელი და ადგილმდებარეობა] ამომხტარი ფანჯარა (სურათი ორი გვიჩვენებს მნიშვნელობებს ჩემი მაგალითისთვის). შენიშვნა: მე შევცვალე ჩემი მომხმარებლის ინფორმაცია ფერადი ოთხკუთხედების გამოყენებით.
3. პროექტის სახელის ველში შეიყვანეთ თქვენთვის სასურველი Java პროექტის სახელი. სახელი უნდა დაიწყოს დიდი ასოთი და კონვენცია გვთავაზობს აქლემის შემთხვევას სიტყვების შეთავსებისას.
4. პროექტის ადგილმდებარეობის ველი აკონტროლებს სად მდებარეობს პროექტი თქვენს ფაილურ სისტემაში. ნაგულისხმევი განსხვავდება ოპერაციული სისტემის მიხედვით, მაგრამ მისი მიღება უსაფრთხოა.
5. Project Folder ველი გაძლევთ საშუალებას გააკონტროლოთ პროექტის საქაღალდის სახელი. მე მიმაჩნია საუკეთესოდ გამოვიყენო ნაგულისხმევი, რაც არის მდებარეობის ველის და სახელის ველის შეთავსება.
6. როდესაც შემოწმებულია ჩარჩოს შექმნა ძირითადი კლასი, NetBeans ავტომატურად ქმნის პაკეტს და ძირითადი კლასის ფაილს (პროგრამა, რომლის გაშვებაც შესაძლებელია ბრძანების სტრიქონიდან) იგივე სახელით, რაც პროექტს აქვს. მე ვფიქრობ, რომ ჩვეულებრივ ის უნდა იყოს შეუმოწმებელი, მაგრამ ამ შემთხვევაში, მე მას შემოწმებას დავტოვებ, რაც გამორიცხავს სხვაგვარად საჭირო ქმედებებს (სურათი მეორე).
7. დააწკაპუნეთ დასრულება პროექტის, პაკეტის და ძირითადი კლასის ფაილის შესაქმნელად. ახლა NetBeans– ის მთავარი ფანჯრის ზედა მარცხენა სარკმელი აჩვენებს თქვენს პროექტს, რომელიც შეიცავს ერთ პაკეტს, რომელიც თავის მხრივ შეიცავს ერთი კლასის ფაილს main () მეთოდით. ზედა მარჯვენა სარკმელი შეიცავს ნაგულისხმევ მთავარ კლასს (პროგრამას), რომელიც ავტომატურად გენერირდება NetBeans– ის მიერ (სურათი სამი).

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

ნაბიჯი 5: დააკონფიგურირეთ NetBeans პროექტი დისტანციურად გაშვებული Raspberry Pi– ზე

NetBeans პროექტის და მასში შემავალი პროგრამის კონფიგურაციისთვის, Raspberry Pi– ზე დისტანციურად გასაშვებად, გააკეთეთ შემდეგი:

1. მარჯვენა ან 2 თითით დაწკაპუნება (დამოკიდებულია სამუშაო სადგურის OS- ზე) პროექტზე NetBeans მთავარი ფანჯრის პროექტების პროექტში, რათა გამოვიდეს პროექტის მენიუ და დააწკაპუნოთ თვისებებზე. თქვენ დაინახავთ პროექტის თვისებების ამომხტარი ფანჯარა (სურათზე ნაჩვენებია ამომხტარი შესაბამისი მნიშვნელობებით ჩემი მაგალითისთვის).
2. კატეგორიების მარცხნივ, აირჩიეთ გაშვება.
3. დააწკაპუნეთ ახალი კონფიგურაციის ველის მარჯვნივ. შედეგად შექმენით ახალი კონფიგურაციის popup, შეიყვანეთ სახელი კონფიგურაციისთვის და დააწკაპუნეთ OK. სახელი შეიძლება იყოს ნებისმიერი; მე მხოლოდ ხელახლა გამოვიყენე პლატფორმის სახელი ("ჩემი პი"). კიდევ ერთხელ ნახავთ პროექტის თვისებების ფანჯარას.
4. დააწკაპუნეთ ჩამოსაშლელ ხატულაზე Runtime Platform ველზე მარჯვნივ. ამომხტარი სიიდან აირჩიეთ დისტანციური პლატფორმა, რომელიც ადრე შექმენით (ჩემს გარემოში, "ჩემი Pi").
5. დააწკაპუნეთ OK პროექტის დისტანციური პლატფორმის დასაყენებლად. თქვენ კვლავ ნახავთ მთავარ ფანჯარას.

თქვენ ახლა მზად ხართ დაწეროთ კოდი და გაუშვათ პროგრამა დისტანციურად.

ნაბიჯი 6: დაწერეთ Java პროგრამა სამუშაო სადგურზე და გაუშვით იგი Raspberry Pi– ზე

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

Pi– ზე პროგრამის გასაშვებად, დააწკაპუნეთ გაშვების ხატზე (მწვანე მარცხნივ მიმართული ისარი) მთავარ ფანჯარაში. NetBeans ადგენს კოდს, ქმნის jar ფაილს, გადმოტვირთავს jar ფაილს Raspberry Pi– ში დისტანციური პლატფორმის მიერ გამოვლენილი, ახორციელებს პროგრამას Pi– ზე, იჭერს პროგრამის გამომუშავებას (System.out) და ეხმიანება NetBeans– ზე გამომავალი ფანჯარა მთავარი ფანჯრის ქვედა მარჯვენა კუთხეში (სურათი მეორე).

თქვენ ახლა მნიშვნელოვნად გააფართოვეთ თქვენი შესაძლებლობები Raspberry Pi– ზე პროექტების შემუშავებისთვის! Მაგრამ მოიცადე…. Უფრო მეტიც!

ნაბიჯი 7: გამართეთ Java პროგრამა NetBeans– ით

ერთ – ერთი ყველაზე მძლავრი მახასიათებელი ინდუსტრიული განვითარების ინტეგრირებული განვითარების გარემოს მსგავსად NetBeans არის პროგრამის გამართვის უნარი გაშვებისას. NetBeans საშუალებას გაძლევთ გამოიყენოთ დისტანციურად გამართვისას გამართვის ინსტრუმენტების სრული ნაკრები. ეს მოიცავს პროგრამის „მნიშვნელოვან“ან „პრობლემურ“ადგილებში შესვენების წერტილების დაყენებას და ცვლადების მნიშვნელობის შემოწმებას მიმდინარე შესრულების მდგომარეობაში.

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

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

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

შესრულება ჩერდება შესვენების წერტილში ინსტრუქციის შესრულებამდე შესვენების წერტილთან ხაზზე. მწვანე ფონი მიუთითებს შემდგომ შესასრულებელ განცხადებაზე. ამრიგად, ჩემს მაგალითში, მე -9 ხაზის გარღვევის წერტილით, ცვლადი a ჯერ არ არსებობს, მით უმეტეს, რომ აქვს მნიშვნელობა.

ახლა გადაიტანეთ კურსორი მთავარ ფანჯარაში გამართვის მენიუს ხატზე (პირველი ორმაგი ისარი ქვემოთ ხატულა გამართვის ხატის მარჯვნივ) და დააწკაპუნეთ Step Over ხატულაზე (მას აქვს ლურჯი დოკუმენტი ფონზე და მწვანე ისრის საწინააღმდეგო ისარი წინა პლანზე). [შენიშვნა: თუ თქვენ გახდით თქვენს NetBeans მთავარ ფანჯარას საკმარისად ფართო, გამართვის მენიუ გაფართოვდება და გამართვის მოქმედების ხატები გამოჩნდება გამართვის ხატის მარჯვნივ.] NetBeans ასრულებს განცხადებას შესვენების წერტილში და აჩერებს შესრულებას მომდევნო განცხადებამდე. ახლა თქვენ ნახავთ, რომ ცვლადი a არსებობს და აქვს მოსალოდნელი მნიშვნელობა (სურათი სამი).

ორჯერ დააწკაპუნეთ Step Over ხატულაზე. თქვენ ნახავთ, რომ სამივე ცვლადს აქვს მნიშვნელობა; გაითვალისწინეთ, რომ c კვლავ ნულია (სურათი ოთხი).

ერთხელ დააწკაპუნეთ Step Over ხატულაზე. თქვენ ნახავთ, რომ c ცვლადს აქვს შესაბამისი მნიშვნელობა, ანუ a და b ცვლადების ჯამი (სურათი ხუთი).

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

ნაბიჯი 8: შეასრულეთ NetBeans– ისგან დამოუკიდებელი პროგრამა

შეიძლება დადგეს დრო, როდესაც გსურთ თქვენი პროგრამის შესრულება Raspberry Pi– ზე, NetBeans– ის „დახმარების“ან „ჩარევის“გარეშე. ეს ძალიან მარტივია. პირველი, გახსენით ssh კლიენტი თქვენი Pi- სთვის.

გახსოვდეთ მე –3 საფეხურიდან, რომ NetBeans თქვენს პროექტს ათავსებს Pi– ზე სამუშაო დირექტორიაში. ნაგულისხმევი ბაზა არის/home/pi/NetBeansProjects მომხმარებლისთვის pi. კონკრეტულ დირექტორიას აქვს იგივე სახელი, რაც თქვენს პროექტს. NetBeans ათავსებს ქილას ქვე დირექტორიაში, რომელსაც ეწოდება dist. ჩემი მაგალითისთვის, სრული გზა არის/home/pi/NetBeansProjects/MyRemoteProg/dist. Ssh კლიენტზე Pi, პროგრამის შესასრულებლად შეგიძლიათ გამოიყენოთ java ბრძანება "jar" ვარიანტით:

java -jar /home/pi/NetBeansProjects/MyRemoteProg/dist/MyRemoteProg.jar

თქვენ ნახავთ შესრულების შედეგებს ssh კლიენტში; ჩემს მაგალითში, გამომავალი იქნება

გამარჯობა Raspberry Pi!

ეს მუშაობს იმიტომ, რომ jar ფაილში არსებული ინფორმაცია განსაზღვრავს რომელი ძირითადი კლასი უნდა შეასრულოს jar– ში.

თქვენ ასევე შეგიძლიათ შეცვალოთ სამუშაო დირექტორია (cd– ს საშუალებით) jar ფაილის ადგილას და შემდეგ გასცეს უფრო მოკლე ბრძანება იგივე შედეგების მისაღებად.

java -jar MyRemoteProg.jar

ნაბიჯი 9: შექმენით და გადმოწერეთ, მაგრამ არ შეასრულოთ პროგრამა NetBeans– ის საშუალებით

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

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

ამ ტექნიკის გამოსაყენებლად, ჯერ შექმენით ახალი ძირითადი კლასი:

1. აჩვენეთ პროექტის მენიუ, როგორც მე –5 საფეხურზე და დააწკაპუნეთ ახალი-> Java მთავარი კლასი. თქვენ ნახავთ ახალი Java ძირითადი კლასის ამომხტარი ფანჯარა.
2. კლასის სახელის ველში შეიყვანეთ სახელი. სახელი შეიძლება იყოს ყველაფერი, რაც მოგწონთ; მე გამოვიყენე "Dummy". პაკეტის ველი გაძლევთ საშუალებას განსაზღვროთ კლასის პაკეტი; თქვენ ირჩევთ პაკეტს ველის მარჯვნივ ჩამოსაშლელი სიის გამოყენებით. კლასი შეიძლება იყოს იმავე პაკეტში, როგორც თქვენი "რეალური" პროგრამა ან განსხვავებული პაკეტი; ახალი კლასი იმავე პაკეტში ჩავდე. დააწკაპუნეთ დასრულება. ახლა თქვენ იხილავთ NetBeans– ის მთავარ ფანჯარას ახალი ფაილით ზედა მარჯვენა პანელში (სურათი ერთი). მე დავამატე მარტივი ბეჭდური განცხადება Pi– ზე მუშაობის შესახებ, მაგრამ არაფერი ნამდვილად არ არის საჭირო.

გადმოტვირთვის შემდეგ "Dummy" - ის გასაშვებად თქვენ უნდა გახადოთ ის "მთავარი კლასი, რომელიც სტანდარტულად უნდა შესრულდეს" პროექტისთვის:

1. გახსენით პროექტის თვისებები, როგორც ნაბიჯი 5. შეარჩიეთ გაშვების კატეგორია. დააწკაპუნეთ დათვალიერება ძირითადი კლასის ველის მარჯვნივ. თქვენ ნახავთ Browse Main Classes ამომხტარი ფანჯარა (სურათი მეორე).
2. შეარჩიეთ კლასი "Dummy". დააჭირეთ აირჩიეთ ძირითადი კლასი. თქვენ კიდევ ერთხელ ნახავთ პროექტის თვისებებს.
3. დააწკაპუნეთ OK. თქვენ დაუბრუნდებით მთავარ ფანჯარას.

როდესაც დააწკაპუნებთ გაშვების ხატზე, NetBeans აკმაყოფილებს/ააშენებს მთელ პროექტს, ჩამოტვირთავს ქილას, რომელიც შეიცავს ყველა კლასის ფაილს Pi- ში და ასრულებს "Dummy" კლასს (სურათი მესამე).

Pi– ზე თქვენი რეალური პროგრამის შესასრულებლად, თქვენ ახლა უნდა გამოიყენოთ java ბრძანება „classpath“ვარიანტით, რომელიც მოითხოვს მკაფიოდ განსაზღვროთ შესასრულებელი ძირითადი კლასი. Ssh კლიენტიდან გადადით dist პროექტის დირექტორიაში თქვენი პროექტისათვის. სათანადო ბრძანება არის ფორმა:

java -cp project_name.jar package_name.class_name

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

შემდეგი ბრძანება ასრულებს ჩემს მაგალით პროგრამას:

java -cp MyRemoteProg.jar myremoteprog. MyRemoteProg

ნაბიჯი 10: გამოიყენეთ NetBeans ბიბლიოთეკის მენეჯმენტი

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

მაგალითისთვის გამოვიყენებ Pi4J, რომელიც ჯავის პროგრამებს აძლევს წვდომას Raspberry Pi GPIO- ზე, I2C ავტობუსზე და სხვა ტექნიკის I/O- ზე. Pi4J არის მხოლოდ ერთ -ერთი მაგალითი Pi– სთვის Java– სთან ერთად ბევრი სახალისო საქმის კეთებისთვის.

თქვენ ჯერ ბიბლიოთეკა უნდა გადმოწეროთ თქვენს სამუშაო ადგილზე. იხილეთ Pi4J ჩამოტვირთვის გვერდი. მას შემდეგ, რაც Pi4J– ს Pi არ აყენებთ, გადმოწერეთ zip თქვენს სამუშაო სადგურზე. თქვენ შეიძლება დაგჭირდეთ ან არ დაგჭირდეთ მკაფიოდ გახსნა zip გადმოტვირთვის შემდეგ.

ახლა თქვენ უნდა შექმნათ "გლობალური ბიბლიოთეკა" NetBeans– ში:

1. NetBeans– ის მთავარ მენიუში დააწკაპუნეთ ინსტრუმენტები -> ბიბლიოთეკები. თქვენ ნახავთ Ant ბიბლიოთეკის მენეჯერის ამომხტარ ფანჯარას (სურათი ერთი).
2. დააწკაპუნეთ ახალ ბიბლიოთეკაზე ქვედა მარცხენა კუთხეში. თქვენ ნახავთ ახალი ბიბლიოთეკის ამომხტარ ფანჯარას (სურათი მეორე).
3. ჩაწერეთ მნიშვნელოვანი სახელი, რომლის გამოყენებაც გსურთ და დააწკაპუნეთ OK. თქვენ კიდევ ერთხელ იხილავთ Ant ბიბლიოთეკის მენეჯერის ამომხტარ ფანჯარას. ახლა ის აჩვენებს თქვენს მიერ შექმნილ ახალ ბიბლიოთეკას (სურათი სამი).
4. დააწკაპუნეთ დამატება JAR/Folder მარჯვნივ. თქვენ ნახავთ Browse JAR/Folder popup (სურათი ოთხი).
5. გადადით და აირჩიეთ pi4j-core.jar. შემდეგ დააჭირეთ დამატებას JAR/Folder. თქვენ დაუბრუნდებით ჭიანჭველების ბიბლიოთეკის მენეჯერის ამომხტარ ფანჯარას.
6. ჭიანჭველების ბიბლიოთეკის მენეჯერის ფანჯარაში დააწკაპუნეთ OK. თქვენ დაუბრუნდებით NetBeans მთავარ ფანჯარას.

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

1. მოიყვანეთ პროექტის თვისებების ამომხტარი ფანჯარა (იხ. ნაბიჯი 5) და შეარჩიეთ ბიბლიოთეკების კატეგორია (სურათი ხუთი).
2. დააწკაპუნეთ ბიბლიოთეკის დამატებაზე ამომხტარი ფანჯრის მარჯვენა მხარეს. თქვენ ნახავთ ბიბლიოთეკის დამატების ამომხტარი ფანჯარა (სურათი მეექვსე).
3. გადადით ბიბლიოთეკაში და შეარჩიეთ იგი. შემდეგ დააჭირეთ ბიბლიოთეკის დამატებას. თქვენ კვლავ ნახავთ პროექტის თვისებების ამომხტარ ფანჯარას. ბიბლიოთეკა ახლა გამოჩნდება ფანჯარაში შედგენის დროებითი ბიბლიოთეკების სიაში.
4. პროექტის თვისებების ფანჯარაში დააწკაპუნეთ OK. თქვენ დაუბრუნდებით მთავარ ფანჯარას.

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

სამჯერ გჭირდებათ ბიბლიოთეკა - შეადგინეთ, შექმენით და შეასრულეთ. საბედნიეროდ, NetBeans– თან ერთად, ბიბლიოთეკის დამატება, როგორც ზემოთ მოცემულია, ამუშავებს ყველაფერს. ამის დასადასტურებლად, მე შევქმენი კიდევ ერთი ძირითადი კლასი, რომელიც აკეთებს აბსოლუტურ მინიმუმს Pi4J– ში I2C შესაძლებლობების გამოსაყენებლად (სურათი მეშვიდე). ის ფაქტი, რომ შეცდომები არ არის ნაჩვენები ნიშნავს იმას, რომ კლასი TestPi4J ადგენს. დაწკაპვით გაშვება წარმატებით აშენებს და ჩამოტვირთვებს; NetBeans გადმოტვირთავს ბიბლიოთეკას jar ფაილის გარდა, ასე რომ პროგრამა შესრულდება. ამ უკანასკნელის გადამოწმების მიზნით, შეგიძლიათ გამოიყენოთ ტექნიკა მე –9 საფეხურზე და ssh კლიენტში შეიყვანეთ შემდეგი ბრძანება (დის დირექტორიადან):

java -cp MyRemoteProg.jar myremoteprog. TestPi4J

გასაგებია იმის გაგება, თუ როგორ მართავს NetBeans ბიბლიოთეკებს. სანამ თქვენი პროექტის dist დირექტორია, მიუთითეთ დირექტორიის შინაარსი (გამოიყენეთ ls ბრძანება) და დაინახავთ lib ქვე დირექტორიას. ჩამოთვალეთ ამ დირექტორიის შინაარსი და ნახავთ jar ფაილს, რომელიც გამოვლენილია გლობალურ ბიბლიოთეკაში, რომელიც ჩემს მაგალითში არის pi4j-core.jar. ყველა ბიბლიოთეკა, რომელსაც თქვენ დაამატებთ პროექტში, გამოჩნდება lib დირექტორიაში და, შესაბამისად, ხელმისაწვდომი იქნება პროექტის jar ფაილის ყველა პროგრამისთვის.

ნაბიჯი 11: წადი გაერთე

მე აღვწერე მიდგომა Raspberry Pi– სთვის ძალიან ეფექტური Java განვითარების მისაღწევად. Raspberry Pi არის უაღრესად პოპულარული ტექნოლოგია პროექტების ფართო სპექტრისთვის. ჯავა არის პროფესიონალური პროგრამირების ენა, რომელიც გთავაზობთ პითონთან შედარებით შესრულების უპირატესობას და გთავაზობთ უსაფრთხოების უპირატესობებს C/C ++ - თან შედარებით. NetBeans არის პროფესიონალური კლასის IDE, რომელიც მნიშვნელოვნად ზრდის პროგრამისტების პროდუქტიულობას.

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