EVIA Paradigma. ուղեցույց

EVIA Paradigma-ն տեսողական ծրագրավորում է. բլոկները գունապնակից քաշեք կտավի վրա, միացրեք դրանք կապերով և սեղմեք Run։ Նույն ծրագիրը կարելի է վերածել C (C99, C11, C17) կամ C++ (C++98-ից մինչև C++20) կոդի և կառուցել Clang-ով կամ GCC-ով, ինչպես նաև Arduino և ESP32 տախտակների կոդի։ Ծրագրի ինտերֆեյսն անգլերեն է, ուստի ընտրացանկերի և կոճակների անունները բերված են այնպես, ինչպես երևում են էկրանին։

Միջերեսն ինքը նույնպես կարող է լինել անգլերեն, ռուսերեն կամ հայերեն՝ Կարգավորումներ > Միջերեսի լեզուն։ Ընտրացանկերը, կոճակները, ներկապնակը և բլոկների անունները փոխվում են դրա հետ. ստեղծված կոդը և կոմպիլյատորների հաղորդագրությունները մնում են անգլերեն։ Փոփոխությունը ուժի մեջ է մտնում EVIA Paradigma-ի հաջորդ գործարկման ժամանակ։

1. Կտավի վրա քաշեք Start-ը, մի քանի բլոկ և End-ը։
2. Բլոկի ներքևի փոքր շրջանից (նրա ելքի պորտից) քաշեք դեպի մեկ այլ բլոկ՝ դրանք միացնելու համար։
3. Բլոկի վրա կրկնակի սեղմումը բացում է նրա կոդը խմբագրելու համար։
4. Մկնիկի անիվը սխեմայի վրա մոտեցնում և հեռացնում է այն ցուցիչի ուղղությամբ։
5. Սեղմեք Run (F5)։ Ելքը երևում է ներքևի վահանակում. կատարվող բլոկը լուսավորվում է։
6. Գործիքագոտում ընտրեք Language և սեղմեք Generate code (F7)՝ ծրագիրը տեսնելու, պահելու, կառուցելու և գործարկելու համար։

Տեսք և լեզու։ View > Theme-ը ընտրում է IntelliJ-ի բաց թեման, Darcula մուգ թեման կամ ձեր համակարգի կարգավորումը. թեման փոխվում է անմիջապես և հիշվում է։ Բաժինների ցանկի վերևում կարելի է ընտրել այս ուղեցույցի լեզուն՝ անգլերեն, ռուսերեն կամ հայերեն։

Բլոկներ

Board բլոկները (Pin Mode, Digital Write, Digital Read, Analog Read, Analog Write, Delay, Millis, UART, SPI, I2C) միկրոկոնտրոլերների համար են. տե՛ս Arduino և ESP32 տախտակներ բաժինը։

Արտահայտություններ

Արժեքները թվեր են կամ տեքստ։ Օպերատորները՝ ցածրագույն առաջնահերթությունից դեպի բարձրագույն.

• ||   &&
• == != < <= > >= (տեքստերը համեմատվում են այբբենական կարգով)
• + - (+-ը միացնում է տեքստը, եթե որևէ կողմը տեքստ է)
• * / %
• ունար - և !, փակագծեր

Տեքստը գրվում է կրկնակի չակերտներով. թույլատրվում են \", \\, \n escape-հաջորդականությունները։ Պայմանը ճշմարիտ է, եթե դա ոչ զրոյական թիվ է կամ ոչ դատարկ տեքստ։

Դասեր և օբյեկտներ

Դասը միավորում է դաշտերը (տվյալներ, որոնք պահում է յուրաքանչյուր օբյեկտ) և մեթոդները (բլոկային ծրագրեր, որոնք աշխատում են այդ տվյալների հետ)։ Ստեղծեք այն Edit > New Class-ով, գունապնակի + New class-ով կամ նշեք բլոկները և սեղմեք Ctrl+G՝ դրանք դաս դարձնելու համար։

• Fields ներդիրը. յուրաքանչյուր դաշտի անունը և սկզբնական արժեքը։ Սկզբնական արժեքները արտահայտություններ են և կարող են օգտագործել ծրագրի փոփոխականները և նախորդ դաշտերը։ Մեթոդների ներսում դաշտը գրվում է this.անուն։
• Մեկ ներդիր յուրաքանչյուր մեթոդի համար. նրա անունը, պարամետրերը և մարմինը։ Մարմինը սկսվում է Enter-ով և ավարտվում Exit-ով։ Յուրաքանչյուր առանձին Exit անուն դառնում է կանչող բլոկի ելքային պորտ, օրինակ՝ yes / no։ Պարամետրերը գալիս են որպես դաշտեր. n պարամետրը կարդացվում է որպես this.n։
• Կոնստրուկտոր. init անունով մեթոդ (կոճակ՝ + Constructor)։ Օբյեկտ ստեղծելիս նրա դաշտերը նախ ստանում են սկզբնական արժեքները, ապա մեկ անգամ կատարվում է init-ը։

Մեթոդը կանչելու համար այն գունապնակի Classes բաժնից քաշեք կտավի վրա։ Բլոկի վրա աջ կամ կրկնակի սեղմումով ընտրվում են մեթոդը, օբյեկտը և արգումենտները։ Նույն օբյեկտի անունով բլոկները աշխատում են մեկ օբյեկտի հետ (և նրա դաշտերի). առանց օբյեկտի անվան բլոկն ունի իր սեփական օբյեկտը։ Օբյեկտները ստեղծվում են առաջին օգտագործման ժամանակ։

Մոդուլներ

Մոդուլը (*.eviam) դասերի ֆայլ է, որը կարող են օգտագործել մի քանի ծրագրեր։

• File > Export Classes as Module-ը դասերը տեղափոխում է մոդուլի ֆայլ։ Ծրագիրն այնուհետև հղվում է մոդուլին, և ծրագիրը պահելիս պահվում է նաև մոդուլը։
• File > Import Module-ը մոդուլի դասերը ավելացնում է բաց ծրագրին։
• Դասի պատուհանը ցույց է տալիս, թե որտեղ է պահվում դասը։

Նախագծեր

File > New Project-ը ստեղծում է թղթապանակ՝ ծրագրին անհրաժեշտ ամեն ինչով.

MyProject/
  MyProject.eviaproj   նախագծի կարգավորումներ
  main.evia            գլխավոր ծրագիրը
  modules/             դասերի մոդուլներ
  build/               գեներացված կոդ (չի մտնում commit-ների մեջ)
  README.md
  .gitignore

Նախագիծը նորից բացեք File > Open Project-ով (ընտրեք թղթապանակը կամ .eviaproj ֆայլը)։ Նախագծում մոդուլները ներմուծվում են modules/-ից և արտահանվում են այնտեղ, իսկ Generate code-ը լրացուցիչ գրում է build/<անուն>.c կամ .cpp։ Նախագիծը հիշում է իր լեզուն։

Git և GitHub

Git ընտրացանկը գործարկում է ձեր համակարգչում տեղադրված git-ը և օգտագործում է արդեն կարգավորված մուտքը (Git Credential Manager, SSH բանալի կամ gh auth login)։ EVIA Paradigma-ն երբեք չի խնդրում և չի պահում գաղտնաբառեր կամ թոքեններ։

• Initialize Repository. git init main ճյուղում (նոր նախագծերը դա անում են ինքնուրույն, եթե git-ը տեղադրված է)։
• Commit (Ctrl+K). պահում է ծրագիրը և commit է անում բոլոր փոփոխությունները. հաղորդագրության խմբագրիչում աշխատում են Vim ստեղները։
• Connect to GitHub. մուտքագրեք սեփականատեր/պահոց կամ կլոնավորման URL։ Create repository on GitHub-ը բացում է github.com-ը զննարկչում՝ անունն արդեն լրացված. ստեղծեք դատարկ պահոց և սեղմեք OK։
• Push / Pull. commit-ները ուղարկել GitHub / ստանալ նորերը (միայն fast-forward, այնպես որ ոչինչ չի միաձուլվում ձեր գիտությունից թաքուն)։
• History-ն ցույց է տալիս վերջին commit-ները. Open on GitHub-ը բացում է պահոցի էջը։

Տեղադրեք git-ը git-scm.com-ից, եթե ընտրացանկը ասում է, որ այն բացակայում է։

Գեներացված կոդ. C և C++

Generate code (F7)-ը ամբողջ ծրագիրը վերածում է մեկ սկզբնական ֆայլի։ Գործիքագոտու երեք բացվող ցանկերը (և կոդի պատուհանում) որոշում են արդյունքը. նույն ընտրությունները կան Run > Code Language and Mode-ում։ Կոդի պատուհանում դրանք փոխելիս կոդը նորից է գեներացվում։

Յուրաքանչյուր համակցություն ստուգված է. ելքը համընկնում է ինտերպրետատորի ելքի հետ (Fast արժեքների դեպքում՝ առանց սխալների աշխատող ծրագրերի համար)։ Բլոկի, մեթոդի կամ դասի վրա աջ սեղմում → View source code՝ տեսնելու այն կոդը, որ դարձել է, լուսավորված, ձեր ընտրած լեզվով։

Կոդի պատուհանը կարող է պահել ֆայլը, կառուցել այն և գործարկել։ C-ի համար օգտագործվում է համապատասխան C կոմպիլյատորը (clang, gcc), ճիշտ -std= և -lm։ Կոմպիլյատորն ընտրվում է Settings-ում. Clang (clang++ / clang) կամ GCC (g++ / gcc, տարբերակ 13 կամ ավելի նոր)։ Windows-ում EVIA Paradigma-ն կարող է դրանցից ցանկացածը տեղադրել ինքնուրույն. llvm-mingw (Clang) կամ WinLibs (GCC, MinGW-w64)։ Visual Studio-ն պետք չէ։

Arduino և ESP32 տախտակներ

Եվս երեք լեզու կոդ են ստեղծում միկրոկոնտրոլերների համար։ Երկուսն էլ օգտագործում են արագ արժեքներ (թվեր. տեքստ՝ միայն Print-ում), իսկ Print-ը և Input-ը աշխատում են սերիական պորտով՝ 115200 բոդ արագությամբ։

Տախտակն ընտրվում է լեզվի կողքի Board ցանկում (նաև Settings-ում)։ Կոդի պատուհանի Build-ը ծրագիրը կառուցում է դրա համար. Upload-ը կառուցում է և ուղարկում ծրագիրը տախտակին՝ Settings-ում նշված սերիական պորտով։

MQTT։ Ցանցի անունը, գաղտնաբառը, բրոքերը և թեմաները ֆիքսված տեքստեր են, քանի որ դրանք գրվում են ծրագրի մեջ կառուցելիս։ PIC32 C-ն AT որոնվածքով ESP8266 կամ ESP32 մոդուլ է վարում UART2-ով (RB5/RB1՝ 28-կոնտակտանի չիպերում, RF4/RF5՝ մյուսներում), այնպես որ Print-ը մնում է UART1-ին։ Arduino-ն ESP32 տախտակի վրա օգտագործում է տախտակի սեփական WiFi-ը։ Run-ը պատասխանում է ձեր համակարգչի բրոքերից՝ բաժանորդագրված թեմայում հրապարակելը վերադարձնում է հաղորդագրությունը։ AVR տախտակը մերժում է MQTT բլոկները (մեկ սերիական պորտ, որը զբաղեցնում է Print-ը), FPGA-ն նույնպես։ Հաղորդագրությունը թիվ է՝ գրված այնպես, ինչպես Print-ն է գրում. քանի որ -1-ը նաև նշանակում է «ոչինչ չի եկել», MQTT Has Message-ը տարբերում է իրական -1-ը։ MQTT-ն կարող է անցնել նաև MX695F512L, MX795F512L չիպերի և Ethernet Starter Kit II-ի սեփական Ethernet պորտով. կարգավորումներում ընտրեք PIC32-ի MQTT-ն՝ → Ethernet, և գեներացված ֆայլը դառնում է MPLAB X Harmony ծրագրի հավելված, որը բերում է TCP/IP փաթեթը։ Այս ուղին փորձարարական է. այն այստեղ կոմպիլացվում է վերնագրերի կաղապարներով, բայց երբևէ չի կառուցվել իրական Harmony-ով և չի աշխատեցվել տախտակի վրա, այդ պատճառով ստուգվածը մնում է WiFi մոդուլը։

MQTT Ethernet-ով (փորձարարական)։ MX695F512L-ի, MX795F512L-ի և PIC32 Ethernet Starter Kit II-ի համար Settings > PIC32 MQTT over > Ethernet-ը ստացվող ֆայլը դարձնում է MPLAB X Harmony նախագծի հավելված՝ TCP/IP փաթեթը տալիս է Harmony-ն, կազմաձևումը, տակտը և main()-ը մնում են նախագծին, իսկ դուք այնտեղից կանչում եք app_run()։ Միացրեք TCP-ն, DHCP և DNS հաճախորդները, Ethernet MAC վարորդը և տախտակի PHY-ը (LAN8740 այս հավաքածուում)։ Հասցեն տալիս է DHCP-ն, ուստի ցանցի անունը և գաղտնաբառը չեն օգտագործվում։ Այս ուղին ստուգումներում կոմպիլացվում է վերնագրերի կրկնօրինակներով, բայց չի կառուցվել իրական Harmony-ով և չի գործարկվել տախտակի վրա. ստուգվածը WiFi մոդուլն է։

Պինները կարող են լինել թվեր, արտահայտություններ կամ տախտակի LED_BUILTIN, A0 ... A15 անունները. HIGH և LOW աշխատում են ցանկացած արտահայտության մեջ։ Այս անունները չի կարելի օգտագործել որպես փոփոխականներ։

Գծերի (bus) բլոկները աշխատում են Run-ում և տախտակների բոլոր երեք լեզուներում։ Օգտագործելուց առաջ գիծը պետք է բացել. հասցեները 7-բիթանոց են, թվերը՝ տասնորդական (80-ը 0x50-ն է)։ PIC32-ում պինները ֆիքսված են չիպի ընտանիքի համար և նշված են ստեղծված կոդի սկզբում (չիպի UART1, SPI և I2C1)։ Run-ը նմանակում է գծերը. UART-ի հաղորդիչը միացված է նրա ընդունիչին, ուստի UART Write-ի բայթերը վերադառնում են UART Read-ով (և երևում են նաև ելքում որպես տեքստ), SPI-ի մուտքը միացված է նրա ելքին, իսկ 80 հասցեով պատասխանում է 256 ռեգիստրով մեկ I2C սարք։

Run-ը նմանակում է Arduino Uno. պինների փոփոխությունները ելքում երևում են board [500 ms] pin 13 HIGH տեսքով, ժամանակը առաջ է գնում միայն Delay-ում (գլխավոր պատուհանը նաև իրականում սպասում է, եթե արագության սահողը լրիվ արագության վրա չէ), յուրաքանչյուր մուտքային պինի կոճակը սեղմվում է ամեն 2 վայրկյանի երկրորդ կեսին, իսկ անալոգային պինները կարդում են դանդաղ 0..1023..0 ալիք։ Ծրագիրը կատարվում է մեկ անգամ, կարծես setup()-ից. դրանից հետո պինները պահում են իրենց վիճակը։ File > Open Example > Arduino and ESP32 Boards-ում կան օրինակներ՝ blink, button, fade, analog meter, Led դաս և UART, SPI ու I2C օրինակներ։

Համակարգչի լեզուները (C, C++) չեն կարող օգտագործել Board բլոկները. Generate code-ը կասի, թե որ բլոկը փոխել։

FPGA՝ Artix-7 և GateMate

Եվս երեք լեզու՝ SystemVerilog, Verilog-2001 և VHDL (VHDL-2008), նույն սխեման դարձնում են սարքակազմ։ Յուրաքանչյուր բլոկ վերջավոր ավտոմատի մեկ վիճակ է և տևում է մեկ տակտ։ Փոփոխականները նշանով 32-բիթանոց ռեգիստրներ են։

Կոնտակտները ֆիքսվում են կառուցելիս, ուստի կոնտակտը պետք է լինի թիվ կամ անուն՝ LED0, SW3, BTNC, BTN0, JA1։ Եթե տախտակը այդպիսի կոնտակտ չունի, սխալը ցույց է տալիս առկաների ցանկը։ Կոնտակտը չի կարելի միաժամանակ կարդալ և գրել։

Ամբողջ թվեր։ Թվաբանությունը 32 բիթով շրջվում է; / և % կլորացնում են դեպի զրո, 0-ի բաժանումը տալիս է 0։ Գործարկումը օգտագործում է double թվեր, ուստի 5 / 2-ը Գործարկման մեջ 2.5 է, իսկ FPGA-ում՝ 2։ Դեռ չեն աջակցվում՝ դասերը, Input, Analog Read, SPI, I2C և տեքստը փոփոխականներում (Print-ում տեքստը աշխատում է)։

Կառուցում և բեռնում։ Artix-7՝ Vivado խմբաքանակային ռեժիմով կամ բաց շղթա (yosys, nextpnr-xilinx, Project X-Ray), ընտրվում է Կարգավորումներում։ GateMate՝ yosys, nextpnr-himbaechel, gmpack։ Բեռնումը՝ Vivado կամ openFPGALoader։ Կոնտակտների սահմանափակումները ֆայլի առաջին մեկնաբանության մեջ են, իսկ հրամանի տողում -o-ն գրում է նաև .xdc կամ .ccf ֆայլ։

Ստուգված է՝ սիմուլյացիա՝ Գործարկման հետ համեմատած, և սինթեզ բաց գործիքներով։ Ստուգված չէ՝ Vivado, openXC7 և իրական տախտակներ։

Օրինակներ՝ File > Open Example > FPGA Boards։

Ստեղնային համակցություններ

Vim ստեղներ

Կոդի դաշտերը, կոդի պատուհանը և commit-ի հաղորդագրության խմբագրիչը աշխատում են Vim ստեղներով (անջատվում են Settings-ում)։ Տեքստը բացվում է ներդրման ռեժիմում. Esc-ը անցնում է նորմալ ռեժիմի։

• Տեղաշարժ. h j k l, w b e, 0 ^ $, gg G, %, f t
• Խմբագրում. i a I A o O, x, dd, cw, yy, p, u, Ctrl+R, .
• Նշում. v, V. որոնում. /տեքստ, n N, *
• Հրամաններ. :w ընդունել/պահել, :q փակել, :wq, :s/a/b/g, :make կառուցել և գործարկել (կոդի պատուհան), :vim բացել իրական Vim-ում