ხმები და მუსიკა 

კოდების ბლოკის პროგრამები borland-ისთვის გ. Code Blocks IDE - დაყენება და გამოყენება

ამ ტუტორიალში თქვენ იხილავთ ადვილად შესასრულებელ ინსტრუქციებს სკრინშოტებთან ერთად კომპილერის ინსტალაციისთვის (MINGW compiler), ინსტრუმენტი, რომელიც საშუალებას მოგცემთ გადაიყვანოთ თქვენ მიერ დაწერილი კოდი პროგრამად და Code::Blocks, უფასო განვითარების გარემო C-სთვის. და C++. ეს სახელმძღვანელო განმარტავს, თუ როგორ დააინსტალიროთ Code::Blocks Windows 2000, XP, Vista ან Windows 7-ზე. შენიშვნა: თუ Linux-ზე ხართ, მიჰყევით ბმულს, რომ გაიგოთ როგორ გამოიყენოთ GCC, თუ იყენებთ OS X-ს, დააწკაპუნეთ აქ დასაყენებლად. ის კეთდება Apple XCode-ის გამოყენებით.

ნაბიჯი 1: ჩამოტვირთეთ კოდი::Blocks

  • ეწვიეთ ამ საიტს
  • მიჰყევით ბმულს ჩამოტვირთეთ ბინარული გამოცემა (პირდაპირი ბმული)
  • გადადით Windows 2000/XP/Vista/7 განყოფილებაში
  • იპოვეთ ფაილი, რომელსაც აქვს mingw მის სახელში. (დაწერის დროს სახელი იყო codeblocks-10.05 mingw-setup.exe; 10.05-ის ვერსიები შეიძლება განსხვავდებოდეს).
  • შეინახეთ ფაილი თქვენს სამუშაო მაგიდაზე. ეს არის დაახლოებით 74 მეგაბაიტი.

ნაბიჯი 2: დააინსტალირეთ Code::Blocks

  • ორჯერ დააწკაპუნეთ ინსტალერზე.
  • რამდენჯერმე დააწკაპუნეთ შემდეგი. ინსტალაციის სხვა გაკვეთილები ვარაუდობენ, რომ თქვენ დააინსტალირეთ C:\Program Files\CodeBlocks (ინსტალაციის ნაგულისხმევი მდებარეობა), მაგრამ შეგიძლიათ დააინსტალიროთ ნებისმიერ სხვა ადგილას, თუ გსურთ
  • შეასრულეთ სრული ინსტალაცია
  • Run Code::Blocks

ნაბიჯი 3: გაუშვით Code::Blocks-ში

შემდგენელთა ავტომატური გამოვლენის ფანჯარა გაიხსნება თქვენს წინაშე:

როდესაც კომპილერის ავტომატური გამოვლენის ფანჯარა გამოჩნდება თქვენს წინაშე, უბრალოდ დააწკაპუნეთ OK. კოდი::ბლოკებმა შეიძლება გკითხონ, გსურთ თუ არა მისი ასოცირება C/C++ ფაილის ნაგულისხმევ მაყურებელთან - გირჩევთ ამის გაკეთებას.

დააწკაპუნეთ მენიუში ფაილი და ახალი განყოფილებაში აირჩიეთ პროექტი... გამოჩნდება შემდეგი ფანჯარა:

დააწკაპუნეთ Console Application-ზე და შემდეგ გადადით. დააწკაპუნეთ შემდეგი სანამ არ მიაღწევ:

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

შემდეგი დაწკაპუნების შემდეგ, Code::Blocks გკითხავთ, სად გსურთ კონსოლის აპლიკაციის შენახვა:

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

არაფრის გაკეთება არ გჭირდებათ, უბრალოდ დააწკაპუნეთ Finish-ზე და გამოიყენეთ ნაგულისხმევი მნიშვნელობები.

ახლა მარცხნივ შეგიძლიათ გახსნათ main.cpp ფაილი:

(შეიძლება დაგჭირდეთ Sources საქაღალდის შიგთავსის გაფართოება, თუ არ ხედავთ main.cpp).

ახლა თქვენ გაქვთ თქვენი საკუთარი main.cpp ფაილი, რომელიც შეგიძლიათ შეცვალოთ სურვილისამებრ. ამ ეტაპზე ის უბრალოდ ამბობს: გამარჯობა მსოფლიო! , ასე რომ ჩვენ შეგვიძლია გავატაროთ ის, როგორც არის. დააჭირეთ F9 ჯერ კომპილაციისთვის და შემდეგ გასაშვებად.

ახლა თქვენ გაქვთ სამუშაო პროგრამა! თქვენ შეგიძლიათ უბრალოდ შეცვალოთ main.cpp და შემდეგ დააჭიროთ F9, რომ შეადგინოთ და ხელახლა გაუშვათ.

ახლა, როდესაც დაასრულეთ კომპილერის ინსტალაცია, დროა ისწავლოთ პროგრამირება: C++ (ან, თუ სწავლობთ C, C პროგრამირებას).

პრობლემების მოგვარება

თუ რამე არ მუშაობს, ყველაზე ხშირად ჩნდება შეტყობინება:

CB01 — გამართვა" იყენებს არასწორ შემდგენელს. ალბათ, ინსტრუმენტთა ჯაჭვის გზა კომპილერის ოფციონებში არ არის სწორად დაყენებული?! გამოტოვება…

პირველ რიგში, დარწმუნდით, რომ გადმოწერეთ Code::Blocks-ის სწორი ვერსია, რომელიც შეიცავს MinGW-ს. თუ ეს არ გადაჭრის პრობლემას, მაშინ, სავარაუდოდ, პრობლემაა შემდგენელის ავტომატური გამოვლენის შესახებ. თქვენ შეგიძლიათ შეამოწმოთ ამჟამინდელი "ავტომატური ამოცნობის" მდგომარეობა ასე. გადადით პარამეტრებზე | შემდგენელი და გამართავი... . შემდეგ მარცხნივ აირჩიეთ Global Compiler Settings (მას აქვს გადაცემათა კოლოფის ხატულა) და მარჯვნივ აირჩიეთ Toolchain executables ჩანართი. ამ ჩანართს აქვს ავტომატური ამოცნობა, რომელიც შეგიძლიათ გამოიყენოთ. ამან შეიძლება პრობლემა მოაგვაროს - თუ არა, შეგიძლიათ ამის გაკეთება ხელით. სკრინშოტი აჩვენებს, როგორ გამოიყურება ეს ყველაფერი ჩემს სისტემაზე. შეცვალეთ გზა, რომელშიც მითითებულია Compiler-ის ინსტალაციის დირექტორია, თუ სხვაგან დააინსტალირეთ, და დარწმუნდით, რომ ყველაფერი შევსებულია, როგორც ნაჩვენებია.

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

ინტეგრირებული განვითარების გარემო (IDE) Code::Blocks (შემდგომში CB) არის სრულფასოვანი პროდუქტი C/C++ ენაზე აპლიკაციების შესაქმნელად. CB არის cross-platform Framework, რომელიც შემუშავებულია wxWidgets ინსტრუმენტების ბიბლიოთეკის გამოყენებით. არსებობს გარემოს ვერსიები როგორც Windows-ისთვის, ასევე სხვა ოპერაციული სისტემებისთვის (OS) - Linux და Mac OS. ეს IDE არის სრულიად უფასო, ღია წყარო და მთლიანად აგებულია ღია კოდის ტექნოლოგიების გამოყენებით. CB-ის ერთ-ერთი ყველაზე ძლიერი მხარე არის wxWidgets აპლიკაციების შექმნის მხარდაჭერა - ეს არის პროგრამული უზრუნველყოფა, რომელიც იყენებს OS API-ს გრაფიკული მომხმარებლის ინტერფეისის (GUI) გამოსატანად. სხვა სიტყვებით რომ ვთქვათ, CB გაძლევთ საშუალებას შექმნათ კროს-პლატფორმული პროგრამული უზრუნველყოფა ყველა გემოვნებისთვის.

CB-ს შეუძლია იმუშაოს დიდი რაოდენობით შემდგენელებთან. თუ სისტემაში რამდენიმე მათგანია დაინსტალირებული, თქვენ შეგიძლიათ მარტივად გადახვიდეთ მათ შორის, თქვენი საჭიროებიდან გამომდინარე. გარდა ამისა, ინსტალაციის ეტაპზე, თავად IDE დაასკანირებს სისტემას ხელმისაწვდომი შემდგენელებისთვის და შესთავაზებს მათ გამოყენებას, როგორც მთავარს. შესაძლებელია ამ პარამეტრების შეცვლა მოგვიანებით, როგორც გლობალურად, ასევე ინდივიდუალურად პროექტებისთვის. გლობალური გარემოს პარამეტრებისთვის, CB-ის მთავარ მენიუში არის მთელი „პარამეტრები“ განყოფილება. კონკრეტული პროექტისთვის რაიმე კონკრეტული პარამეტრის გასაკეთებლად, თქვენ უნდა გახსნათ პროექტის თვისებების ფანჯარა. ამისათვის თქვენ უნდა გამოიძახოთ პროექტის კონტექსტური მენიუ, დააწკაპუნეთ მასზე მარჯვენა ღილაკით და აირჩიეთ "თვისებები". თავად პროექტები (ამჟამად გახსნილი IDE-ში) ნაჩვენებია როგორც ხე "მენეჯმენტის" დოკის პანელში, მის "პროექტების" ჩანართში. ახლა, თვისებების ფანჯარაში, რომელიც იხსნება, შეგიძლიათ დააკონფიგურიროთ მრავალფეროვანი პარამეტრი, დაწყებული build მიზნების რედაქტირებიდან მესამე მხარის ბიბლიოთეკების დაკავშირებამდე. ღილაკი „Project's build options“ იმავე თვისებების ფანჯრის „Project Settings“ ჩანართზე საშუალებას გაძლევთ ძალიან მოქნილად დააკონფიგურიროთ build-ის კონფიგურაცია კონკრეტული პროექტისთვის: კომპილერის კლავიშები, შეარჩიოთ თავად შემდგენელი, დააკავშიროთ ბიბლიოთეკები ლინკერისთვის და ა.შ. ეს შეიძლება გაკეთდეს ინდივიდუალური რეჟიმებისთვის: "გამოშვება" "გამართვა".

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

CB-ში მონიშვნის, კოდის შევსების და რედაქტირების ხელსაწყოები კოდთან მუშაობის პროცესს მარტივ და კომფორტულს ხდის. პარამეტრების უზარმაზარი არსენალი საშუალებას გაძლევთ ძალიან წვრილად მოარგოთ გარემო „თავისთვის“. ძალიან სასარგებლოა გარემოს ცვლადებთან მუშაობის მხარდაჭერა. ამ ფუნქციის წყალობით, CB შეიძლება იყოს ძალიან მჭიდროდ ინტეგრირებული სისტემაში და მისი შესაძლებლობები შეიძლება გაფართოვდეს, მაგალითად, ამ გზით შეგიძლიათ დააკავშიროთ wxWidgets ბიბლიოთეკა.

აპლიკაციის შემუშავება ჩაშენებული მოწყობილობებისთვის

ნაწილი 2. გამოიყენეთ Code::Blocks AVR აპლიკაციების შესაქმნელად

შინაარსის სერია:

წინა სტატიაში ჩვენ ვაჩვენეთ, თუ როგორ გამოვიყენოთ Eclipse განვითარების გარემო, რომ შევქმნათ აპლიკაციები Atmel-ის AVR სერიის მიკროპროცესორებისთვის GNU AVR GCC შემდგენელი კომპილაციის გამოყენებით. ჩვენ გავაშუქეთ Eclipse-ის დაყენება AVR მოდულის გამოყენებით, ასევე გარემოს ხელით დაყენება. ახლა ჩვენ გაჩვენებთ, თუ როგორ შეიძლება იგივე პრობლემის გადაჭრა სხვა, უფრო მსუბუქი და ძალიან მოსახერხებელი განვითარების გარემოს, Code::Blocks-ის გამოყენებით.

გარემოს გაცნობა

პროექტის შექმნა

თუ სამუშაო სივრცეში ჯერ არ არის შექმნილი პროექტი, მაშინ Code::Blocks-ის გაშვების შემდეგ ცენტრალურ პანელში აქტიურია მხოლოდ ჩანართი „დაიწყე აქ“. ახალი პროექტის შესაქმნელად, თქვენ უნდა აირჩიოთ ბრძანება „ახალი პროექტის შექმნა“ ან მენიუს პუნქტი „ფაილი->ახალი->პროექტი“. ნებისმიერ შემთხვევაში, გაიხსნება მომავალი პროექტისთვის შაბლონის არჩევის ფანჯარა, რომელშიც ვაზუსტებთ „AVR Project“ შაბლონს და ვაჭერთ ღილაკს „გადასვლა“.

გამოჩნდება AVR Project Creation Wizard-ის მისასალმებელი ფანჯარა. დააჭირეთ ღილაკს "შემდეგი" და გახსნილ დიალოგურ ფანჯარაში შეიყვანეთ პროექტის სახელი და დირექტორია, რომელშიც ის განთავსდება. ამ მონაცემებზე დაყრდნობით, პროგრამა ავტომატურად შესთავაზებს მომხმარებელს პროექტის ფაილის სახელს გაფართოებით *.cbp და პროექტის დირექტორია, რომელიც შეიქმნება. შემდეგი, დააჭირეთ ღილაკს "შემდეგი".

შემდეგი ფანჯარა მოგთხოვთ აირჩიოთ build-ის კონფიგურაციები, რომლებიც გამოყენებული იქნება პროექტში. ნაგულისხმევად, ორივე კონფიგურაცია აქტიურია: გამართვა და გამოშვება. კომპილატორი "GNU AVR GCC Compiler" წინასწარ არის მითითებული. აქ ასევე შეგიძლიათ შეცვალოთ ნაგულისხმევი დირექტორიები შედგენილი კონფიგურაციის ფაილებისთვის.

შემდეგ ფანჯარაში ჩვენ ვაზუსტებთ სამიზნე პროცესორის ტიპს ჩამოსაშლელი სიიდან არჩევით (მოგვიანებით ეს შეიძლება გაკეთდეს კომპილაციის ვარიანტებში). თუ პროექტი იყენებს გარე მეხსიერებას, ღირს მისი პარამეტრების მითითება. შემდეგი, თქვენ უნდა დააყენოთ გლობალური პროექტის ცვლადის მნიშვნელობა F_CPU, რაც მიუთითებს პროცესორის საათის სიხშირე ჰერცში. ნაგულისხმევად, ჩართულია სიმბოლოების რუკის ფაილის (.map) და თექვსმეტობითი ფაილების შექმნა, ასევე დემონტაჟის ჩამონათვალის ფაილის (.lss) შექმნა. ასევე სასარგებლოა პარამეტრის „Run avr-size აშენების შემდეგ“ ჩართვა - შემდეგ პროექტის აგების ჟურნალის ბოლოს გამოჩნდება ინფორმაცია იმის შესახებ, თუ რამდენი ადგილი დაიკავებს პროგრამის მეხსიერებას და RAM-ში. რაიმე მიზეზის გამო, ჩამონათვალის შექმნის ოფციის ჩართვას არავითარი ეფექტი არ აქვს პროექტის აგებისას და თქვენ უნდა ხელით დაამატოთ შესაბამისი ბრძანება „წინა/პოსტ build ნაბიჯებს“. დააჭირეთ ღილაკს "დასრულება" (სურათი 2).


პროექტი შეიქმნა და მას ავტომატურად დაემატა პირველი ფაილი - main.c.

პროექტის და განვითარების გარემოს დაყენება

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

  1. აირჩიეთ მენიუს პუნქტი "პროექტი-> აშენების პარამეტრები". გაიხსნება ასამბლეის პარამეტრების პარამეტრების ფანჯარა (სურათი 3). მარცხენა პანელი შეიცავს აგების მიზნების ხეს. მის უმაღლეს დონეზე არის მთელი პროექტის მშენებლობის პარამეტრები. ყველაზე მოსახერხებელია პირველ რიგში მიუთითოთ პარამეტრები მთელი პროექტისთვის და მხოლოდ ამის შემდეგ დაამატოთ რაღაც ცალკეულ შეკრების ვარიანტებში.

    უპირველეს ყოვლისა, თქვენ უნდა დარწმუნდეთ, რომ „GNU AVR GCC Compiler“ არჩეულია „Selected Compiler“ ველში. ქვემოთ, „შემდგენელი დროშების“ ჩანართზე არის შემდგენელი დროშები. ნაგულისხმევად, აქ უკვე ჩართულია სასარგებლო დროშა „ჩართეთ ყველა შემდგენელი გაფრთხილება“. ასევე ღირს დარწმუნდეთ, რომ სწორად შევარჩიეთ პროცესორის ტიპი, რომლისთვისაც მიმდინარეობს პროექტი.

    ჩანართი „#defines“ აჩვენებს F_CPU ცვლადის მნიშვნელობას, თუ ის დაყენებული იყო პროექტის შექმნისას.

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

    გადადით "საძიებო დირექტორიების" ჩანართზე. ქვემოთ, "შემდგენელი" ჩანართზე, თქვენ უნდა ჩასვათ სათაურის ფაილების გზა, მაგალითად, /usr/avr/include/. ამისათვის გამოიყენეთ ღილაკი "დამატება" და შეიყვანეთ სწორი გზა. ანალოგიურად, "Linker" ჩანართზე ჩვენ ვაზუსტებთ გზას AVR GCC ბიბლიოთეკებისკენ, მაგალითად, /usr/avr/lib.

    ჩანართი "წინა/შემშენებლობის ნაბიჯები". ველში „აშენების შემდგომი ნაბიჯები“ შეგიძლიათ იხილოთ ბრძანებები avr-size, avr-objcopy, avr-objdump უტილიტების გასაშვებად. მაგალითად, ჩამონათვალის მისაღებად (რადგან პროექტის შექმნის ოსტატში ოფციის „შექმენით გაფართოებული ჩამონათვალის ფაილის“ ჩართვა არ იძლევა სასურველ ეფექტს, ყოველ შემთხვევაში, 8.02 ვერსიაში), დაამატეთ შემდეგი ბრძანება:

    avr-objdump -h -S $(TARGET_OUTPUT_FILE) > $(TARGET_OUTPUT_FILE).lss

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

    სტანდარტული პარამეტრები მოიცავს გამართვის ინფორმაციის შექმნის ავტომატურად ჩართვას Debug target-ში („-g“ ვარიანტი) და შედეგად მიღებული პროგრამის ზომის ოპტიმიზაციას Release target-ში („-Os“ ოფცია).

  2. აირჩიეთ მენიუს პუნქტი "პროექტი-> თვისებები". აქ სტანდარტული პარამეტრები საკმაოდ შესაფერისია პროექტთან მუშაობის დასაწყებად არაფრის შეცვლის გარეშე. ღირს ყურადღება მიაქციოთ ჩანართს "სამიზნეების აშენება". თითოეული build სამიზნისთვის (ნაგულისხმევი: Debug and Release), მითითებულია, სად იწერება მიღებული ობიექტის ფაილები და ველში “Build target files” შეგიძლიათ მიუთითოთ რომელი წყარო ფაილებია ჩართული ამ build-ში (სურათი 4).

    თუ გსურთ, შეგიძლიათ შეინახოთ თქვენი მორგებული პროექტი, როგორც შაბლონი მომავალი პროექტებისთვის. ამისათვის აირჩიეთ მენიუს ბრძანება „ფაილი->პროექტის შენახვა მომხმარებლის შაბლონად...“ და შეიყვანეთ შაბლონის სახელი. მოგვიანებით, ახალი პროექტის შექმნისას, შეგიძლიათ აირჩიოთ სასურველი შაბლონი კატეგორიაში „მომხმარებლის შაბლონები“ (სურათი 5). ამის შემდეგ, თქვენ უნდა მიუთითოთ ცარიელი დირექტორია, სადაც შეიქმნება ახალი პროექტი და შემდეგ შეცვალოთ პროექტის სახელი.


    თქვენ შეგიძლიათ შეცვალოთ არსებული სტანდარტული შაბლონიც. ამისათვის შაბლონის შერჩევის ფანჯარაში დააწკაპუნეთ მაუსის მარჯვენა ღილაკით სასურველ შაბლონზე და გამოიყენეთ ოფცია “Edit this script” მენიუში, რომელიც გამოჩნდება.

  3. სანამ რაიმეს შეკრებთ, ჯერ კიდევ უნდა გადახედოთ გლობალური შემდგენლის პარამეტრებს. ეს კეთდება მთავარი მენიუს მეშვეობით: „პარამეტრები->გამმართავი პარამეტრების შემდგენელი“. მარცხენა პანელის ფანჯარაში, რომელიც იხსნება, დააწკაპუნეთ "გლობალური შემდგენელი პარამეტრების" ხატულაზე. მარჯვენა პანელის ზედა ნაწილში, ზედა ველში „შერჩეული შემდგენელი“ აირჩიეთ „GNU AVR GCC შემდგენელი“ (სურათი 6).

    „შემდგენელის პარამეტრების“ ჩანართზე თითქმის არ არის საჭირო რაიმეს შეცვლა: ეს პარამეტრები გახდება სტანდარტული ყველა AVR პროექტისთვის. მაგრამ "Search Directories->Compiler" და "Search Directories->Linker" ჩანართებზე, ჩემს შემთხვევაში უკვე იყო სტანდარტული ბილიკები, შესაბამისად, /usr/include და /usr/lib, რაც არასწორი იყო. აქ შეგიძლიათ მიუთითოთ სწორი ბილიკები (მაგალითად, /usr/avr/include და /usr/avr/lib) და წაშალოთ იგივე ბილიკები პროექტის პარამეტრებში, მე უბრალოდ გავასუფთავე ეს ველები ღილაკებით „გასუფთავება“, რადგან პროექტის პარამეტრები ამ ეტაპზე უკვე კონფიგურირებულია.

    "Toolchain executables" ჩანართზე, ჩვენ ვამოწმებთ, არის თუ არა AVR GCC ნაკრებიდან შესრულებადი ფაილების სახელები და მათკენ მიმავალი ბილიკები სწორი. ღილაკის "ავტომატური ამოცნობის" გამოყენებით შეგიძლიათ სცადოთ ავტომატურად გამოავლინოთ ყველა ეს მნიშვნელობა. თუ რამე არასწორედ წარიმართა (მაგალითად, AVR GCC დისტრიბუცია დასრულდა ეგზოტიკური სახელებითა და განთავსების დირექტორიებით), მაშინ ეს არის ზუსტად ის ადგილი, სადაც ყველაფრის ხელით გამოსწორებაა შესაძლებელი. ნახაზზე 7, „შემდგენის ინსტალაციის დირექტორია“ ველში უნდა იყოს მითითებული „/usr“, თუ AVR GCC პროგრამები მდებარეობს /usr/avr/ დირექტორიაში.


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

ახლა Code::Blocks მზადაა თქვენი პროექტის ასაშენებლად!

თქვენი საკუთარი მაკიაჟის გამოყენება თქვენი პროექტისთვის

არაჩვეულებრივი სიტუაცია ყოველთვის შეიძლება წარმოიშვას, როდესაც პროექტის შეკრების პროცესი სრული კონტროლის ქვეშ უნდა იქნას აღებული. ამისათვის Code::Blocks იძლევა შესაძლებლობას იმუშაოთ საკუთარ ასამბლეის ფაილთან. მის გამოსაყენებლად, თქვენ უნდა შექმნათ ცარიელი პროექტი და შეინახოთ იგი. ახლა თქვენ უნდა მიუთითოთ, რომ თქვენი საკუთარი მაკიაჟი გამოიყენება:

  1. აირჩიეთ მენიუს პუნქტი "პროექტი -> თვისებები".
  2. გადადით "პროექტის პარამეტრები" ჩანართზე.
  3. შეამოწმეთ ყუთი "ეს არის მორგებული მაკიაჟი".
  4. დარწმუნდით, რომ შეიყვანეთ ფაილის სწორი სახელი "Makefile:" ველში.
  5. ახლა ჩანართზე "Build targets" თქვენ უნდა შეცვალოთ ან დაამატოთ build targets არსებული მაკიაჟის შესაბამისად, მაგალითად: all cleanall

თუ იყენებთ საკუთარ მაკიაჟის ფაილს, უნდა შეამოწმოთ რა ბრძანებებია ხელმისაწვდომი ჩანართზე Make Commands, მენიუს პუნქტის Project ->Build Options ქვეშ.

საცდელი პროგრამა

AVR შაბლონის გამოყენებით ახლად შექმნილ პროექტს უკვე აქვს ფაილი main.c, რომელიც შეიცავს C-ში პროგრამის მთავარი მოდულის შაბლონს. მოდით დავწეროთ ახალი პროგრამა C++-ში.

გამოიყენეთ მენიუს ვარიანტი "ფაილი->ახალი->ფაილი...", აირჩიეთ "C++ წყარო" და დააჭირეთ ღილაკს "გადასვლა". გამოჩნდება New Source File Wizard-ის მისასალმებელი ფანჯარა. დააჭირეთ ღილაკს „შემდეგი“ და შემდეგ ფანჯარაში აირჩიეთ ამ ფაილის პროგრამირების ენა: C++. შემდეგი, მიუთითეთ ფაილის სახელი (მაგალითად, sample.cpp) და ამ ფაილის სრული გზა, ფაილის სახელის ველის მარჯვნივ მდებარე ღილაკზე „...“ დაწკაპუნებით. შემდეგ თქვენ უნდა მიუთითოთ შეკრების რა მიზნით იქნება ეს ფაილი, რისთვისაც შეგიძლიათ უბრალოდ დააჭიროთ ღილაკს "ყველა". დააჭირეთ ღილაკს "დასრულება".

შექმნილ ცარიელ ფაილში ჩაწერეთ უმარტივესი C++ პროგრამა:

int main(void) ( const int some_size = 1000; while (true) (for (int i = 0; i< some_size; i++) int a = 3; // какое-нибудь действие } return 0; // никогда не дойдет сюда }

შეინახეთ ფაილი Ctrl+S დაჭერით. ჩვენ არ გვჭირდება main.c ფაილი, მისი ამოღება შესაძლებელია პროექტიდან მის სახელზე მაუსის მარჯვენა ღილაკით და მენიუდან ბრძანების „Remove file from project“ არჩევით (სურათი 8).


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

მოდით შევადგინოთ პროგრამა. ამისათვის თქვენ უნდა აირჩიოთ მენიუს ბრძანება „Build->Build“ ან დააჭიროთ ნაცნობ კლავიშთა კომბინაციას Ctrl+F9, ასევე შეგიძლიათ გამოიყენოთ ინსტრუმენტთა პანელში ლურჯი გადაცემათა ღილაკი. პროგრამა შედგენილი იქნება და ეკრანის ბოლოში შეტყობინებების ფანჯარა ავტომატურად გადავა ჩანართზე "Build messages", სადაც იტყვის, რომ კონსტრუქცია დასრულებულია, იყო 0 შეცდომა და ერთი გაფრთხილება: არის გამოუყენებელი ცვლადი. "a" მე-8 ხაზზე.

ცოტა რამ გამართვის შესახებ

AVR აპლიკაციების გამართვის მიდგომა დიდწილად დამოკიდებულია გამოყენებულ აპარატურაზე. თუ თქვენ გაქვთ AVR JTAG ICE მოწყობილობა, შეგიძლიათ შეასრულოთ წრიული გამართვა პროცესორთან მიერთებით avarice უტილიტის გამოყენებით. თუ ასეთი მოწყობილობა არ არის, გამოიყენეთ simulavr პროცესორის სიმულატორი. სამწუხაროდ, ეს პროექტი რამდენიმე წელია არ არის შემუშავებული, მაგრამ დეველოპერები აგრძელებენ გამოსწორებების გამოშვებას.

Code::Blocks-ში გამართვის კონფიგურაციისთვის, თქვენ უნდა გახსნათ პროექტის თვისებები „Project->Properties“ და გადახვიდეთ „Debugger“ ჩანართზე. აქ, "აირჩიე სამიზნე" ველში აირჩიეთ "გამართვა". ამ კონფიგურაციისთვის, "დისტანციური კავშირი" ჩანართი განსაზღვრავს პარამეტრებს avr-gdb-ის დისტანციური გამართვის სამიზნეზე დასაკავშირებლად:

  • "კავშირის ტიპი": TCP.
  • „IP მისამართი“: localhost, თუ გამართვის მოწყობილობა (ან სიმულატორი) დაკავშირებულია იმავე კომპიუტერთან.
  • "პორტი": მაგალითად, 1212 წ.

ახლა "დამატებითი ბრძანებები" ჩანართზე "დაკავშირების შემდეგ" ველში თქვენ უნდა შეიყვანოთ შემდეგი ბრძანებები გამართვისთვის:

დატვირთვის შესვენების მთავარი

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

გამართვამდე, თქვენ უნდა გაუშვათ simulav ტერმინალში:

სიმულავრ -გ -პ 1212 -დ ატმეგა128

(atmega128 პროცესორისთვის), გამომავალი იქნება დაახლოებით ასეთი:

$ simulavr -g -p 1212 -d atmega128 atmega128 მოწყობილობის სიმულაცია. ... main.c:415: MESSAGE: 8000000 Hz საათის სიხშირის სიმულაცია 1212 პორტზე ელოდება gdb კლიენტის დაკავშირებას...

თუ მოწყობილობა დაკავშირებულია სერიულ პორტთან /dev/ttyS0, შეგიძლიათ დაიწყოთ სიძუნწე შემდეგი ბრძანებით:

სიხარბე -j /dev/ttyS0 -P atmega128:1212

ახლა თქვენ შეგიძლიათ დაიწყოთ გამართვა Code::Blocks მენიუს ბრძანების „Debug->Start“ გამოყენებით. ფანჯარაში, სადაც simulavr მუშაობს, დაემატება მსგავსი შეტყობინებები:

კავშირი გახსნილია ჰოსტის მიერ 127.0.0.1, პორტი -14999. decoder.c:737: შეტყობინება: შესვენების წერტილი: კომპიუტერი = 0x00000068: საათი = 34

ამ შემთხვევაში, ძირითადი ფუნქციის შემცველი საწყისი ტექსტი ჩაიტვირთება Code::Blocks რედაქტორში და გამართვის კურსორი გაჩერდება ამ ფუნქციაზე, როგორც ნაჩვენებია სურათზე 9. ახლა თქვენ შეგიძლიათ გამოიყენოთ მოსახერხებელი ღილაკები გამართვისთვის ხელსაწყოთა პანელი, ცვლადის მნიშვნელობების ნახვა და ა.შ. დამატებითი ინფორმაცია გამართვის შესახებ შეგიძლიათ იხილოთ დოკუმენტაციაში gdb, simulavr ან avarice.


დასკვნა

ასე რომ, ჩვენ ვაჩვენეთ, თუ როგორ, მინიმალური ძალისხმევით და დროით, დოკუმენტაციისა და გაკვეთილების გამოყენების გარეშე, შეგიძლიათ სწრაფად დაიწყოთ AVR აპლიკაციების შემუშავება შესანიშნავი და სწრაფად მზარდი Code::Blocks განვითარების გარემოს გამოყენებით. ამჟამად, გარემოს ინტერფეისი ითარგმნა მრავალ ენაზე და, ალბათ, მალე ლოკალიზებული ფაილები გახდება განვითარების მთავარი ფილიალის ნაწილი.

შემდეგ სტატიაში ჩვენ განვიხილავთ Eclipse-ის გამოყენებას აპლიკაციების შესაქმნელად მიკროპროცესორების ფართო სპექტრისთვის მცირე ოპერატიული მეხსიერებით, რისთვისაც შექმნილია SDCC ღია კოდის შემდგენელი.

ახლახან გამოვიდა განვითარების გარემოს ახალი ვერსია CodeBlocks (ოფიციალურად იწერება ორი ორი წერტილით - Code::Blocks).განვითარების ეს გარემო უკვე ძალიან პოპულარული გახდა დამწყებთათვის და პროფესიონალთა შორის. თუ მუშაობა CodeBlocksიგივე სულისკვეთებით გააგრძელებს, შეძლებს Microsoft Visual Studio-ს ძალიან ღირსეული კონკურენტი გახდეს.

CodeBlocksარის ძალიან პოპულარული უფასო კროს-პლატფორმული განვითარების გარემო. CodeBlocksაქვს არსენალში ყველაფერი, რაც გჭირდებათ განვითარებისთვის: რედაქტორი, შემდგენელი, გამართვა. განაწილებულია GPL ლიცენზიით და შექმნილია ისეთი პლატფორმებისთვის, როგორიცაა Windows, Linux და Mac OS X. განვითარების ეს შესანიშნავი გარემო შეიძლება შედგენილი იყოს წყაროს კოდიდან თითქმის ნებისმიერი Unix-ის მსგავსი სისტემისთვის (Linux, FreeBSD, ...). თვითონ CodeBlocksდაწერილია C++-ში და იყენებს wxWidgets ბიბლიოთეკას. ადვილად მასშტაბირებადია დანამატების გამოყენებით მისი ღია არქიტექტურის გამო. მხარს უჭერს პროგრამირების ენებს, როგორიცაა C, C++, D.

მოდით ახლა უფრო ახლოს მივხედოთ გარემოს შესაძლებლობებს.

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

  • MinGW / GCC C/C++
    • GNU ARM GCC შემდგენელი
    • GNU AVR GCC შემდგენელი
    • GNU GCC შემდგენელი PowerPC-სთვის
    • GNU GCC შემდგენელი TriCore-სთვის
  • ციფრული მარსი C/C++
  • Digital Mars D (გარკვეული შეზღუდვებით)
  • SDCC (მცირე მოწყობილობის C შემდგენელი)
  • Microsoft Visual C++ 6
  • Microsoft Visual C++ Toolkit 2003 წ
  • Microsoft Visual C++ 2005/2008 (გარკვეული შეზღუდვებით)
  • Borland C++ 5.5
  • უოტკომი
  • Intel C++ კომპილერი
  • GNU Fortran
  • GNU ARM
  • GNU GDC

ასევე შიგნით CodeBlocksარის მულტიდისციპლინარული პროექტების მხარდაჭერა, სამუშაო ადგილების მხარდაჭერა. შესაძლებელია Dev-C++ გარემოში შექმნილი პროექტების იმპორტი, პროექტების იმპორტი და Microsoft Visual Studio სამუშაო სივრცეები.

ინტერფეისი

  • სინტაქსის ხაზგასმა
  • იშლება კოდის ბლოკები
  • კოდის შევსება
  • კლასის ბრაუზერი
  • ციყვი სკრიპტირების ძრავა
  • განრიგი მრავალი მომხმარებლისთვის
  • Devpack დანამატების მხარდაჭერა (საინსტალაციო პაკეტები Dev-C++-ისთვის)
  • wxSmith მოდული (wxWidgets RAD ინსტრუმენტი)


გამართვა

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

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

C++-ში დაწერილია შემდეგი პროგრამა: კომპანიის თანამშრომელთა ხელფასის გაანგარიშება.
მეორე პროგრამა: ფეხების ინჩებად გადაქცევა.

ქვემოთ მოცემულია ამოცანები, მუშაობის ეკრანის ანაბეჭდები IDE შემდგენელში და პროგრამის კოდები C++-ში.

ასე რომ, წიგნში "C++ თვითმასწავლებელი", ჰერბერტ შილდტი, bhv გამომცემლობა 1998, შემოთავაზებულია შემდეგი ამოცანები:
"დაწერეთ პროგრამა, რომ შეიყვანოთ პერსონალის მიერ სამუშაო საათების რაოდენობა და თითოეულის საათობრივი ანაზღაურება. შემდეგ დაბეჭდეთ პერსონალის მთლიანი ხელფასი. (დარწმუნდით, რომ შეყვანა სწორია)."

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

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

gcc და g++ კომპილერის ინსტალაცია

Ubuntu-ში შეგიძლიათ გამოიყენოთ C შემდგენელი C-ში პროგრამების შედგენისთვის. gcc, ხოლო C++ პროგრამებისთვის - შემდგენელი g++. დააინსტალირეთ ორივე კომპილერი ასე:

sudo apt-get დააინსტალირე gcc g++

ამ შემდგენლებით შეგიძლიათ პროგრამების შედგენა კონსოლში და პროგრამირების გარემოც გამოიყენოს ისინი.
კონსოლის მეშვეობით შეიძლება ასე გამოიყურებოდეს: თუ თქვენი პროგრამა არის my.cpp ფაილში, ის ასე აწყობს:

g++ my.cpp -o ჩემი

ეს შექმნის შესრულებადს სახელწოდებით my, ან შეგიძლიათ მას სხვანაირად უწოდოთ.

როგორ დააინსტალიროთ Code::Blocks Ubuntu-ზე

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

ეს პროგრამა არასასიამოვნო მომეჩვენა, ალბათ იმიტომ, რომ პროგრამის დაწერის პროცესში დავწერე, როგორც ჩვეულებრივი ტექსტური ფაილი და იყო რამდენიმე მინიშნება და დახმარება IDE-დან, ძირითადად გზაში. მაგრამ ფაილის cpp გაფართოებით შენახვის შემდეგ, კოდი ხაზგასმული გახდა და დახვეწის პროცესში, ურთიერთქმედება გაუმჯობესდა.
კომპილაციისთვის და გასაშვებად საჭიროა გამოიყენოთ მწვანე ღილაკი Build and Run, ან რუსულად: Build and Run.

როგორ დავიწყოთ პროექტი Code Blocks-ში

ამისათვის თქვენ უნდა ნახოთ შემდგენელი შეტყობინების ფანჯარა შეცდომის შეტყობინებების წასაკითხად. ფანჯარა ჩართულია: ხედი - ჟურნალი, ან რუსულად მსგავსი რამ: ნახვა - ჟურნალები.
თუ პროგრამა ჯერ არ არის შედგენილი, მაშინ უნდა დააჭიროთ ღილაკს ააშენეთ და გაუშვითან კომპილირება და გაშვება. შემდეგ შეტყობინებები გამოჩნდება ჟურნალებში და გამოჩნდება პროგრამის ფანჯარა. თუ ის არ გამოჩნდება, შეასწორეთ ჩანაწერებში მითითებული შეცდომა.
Code Blocks ეკრანის სკრინშოტი

თქვენი პირველი C++ პროგრამის გაშვება Code::Blocks შემდგენელში

პროგრამის პრინტი 1

პროგრამის 2-ის პრინტი

პროგრამის კოდი საწარმოს თანამშრომელთა ხელფასების გაანგარიშება, C++

    #შეიცავს

    სახელთა სივრცის გამოყენებით std;

  1. int main()

    // ცვლადების განსაზღვრა

    int i, n, h;

    ორმაგი s, ჯამი;

  2. //აჩვენეთ სახელი და მოწვევა მონაცემების შესაყვანად

    კოუტ<< „საწარმოს ყველა პერსონალის ჯამური ხელფასის გაანგარიშება\n“;

    კოუტ<< "\nშეიყვანეთ თანამშრომელთა რაოდენობა: ";

    cin >> n; //ჩაწერეთ თანამშრომელთა რაოდენობა n ცვლადში

    კოუტ<< "შეიყვანეთ თითოეული თანამშრომლის სამუშაო საათების რაოდენობა და სამუშაო საათის ღირებულება\n";

    კოუტ<< "(შეიყვანეთ ინტერვალით გამოყოფილი ორი რიცხვი და დააჭირეთ Enter)\n";

    //მონაცემთა შეყვანის ორგანიზება მარყუჟში, სანამ არ შევიყვანთ მონაცემებს ყველა n თანამშრომლის შესახებ

    i = 1;

    ჯამი = 0;

    გააკეთე (

    კოუტ<< "საათები და ღირებულება სამუშაო საათში" << i << "ე თანამშრომელი:\n";

    cin >> h >> s;

    ჯამი += s * h; // დასაქმებულის ხელფასის დამატება მთლიან ბიუჯეტში

    მე++;

    ) ხოლო (ი<= n) ;

  3. კოუტ<< "შესვლა დასრულებულია\n \nკომპანიის თანამშრომლების ჯამური ხელფასია:\n";

    კოუტ<< sum << "\n";

  4. დაბრუნება 0;

ტერფები ინჩებში კონვერტაციის პროგრამის კოდი, C++

    #შეიცავს

    სახელთა სივრცის გამოყენებით std;

  1. int main()

    int i;

    ორმაგი f, d;

  2. კოუტ<< "ფუტები ინჩებში კონვერტაციის პროგრამა\n";

    კოუტ<< "ფეხი = 12 ინჩი\n";

    კოუტ<< "შეიყვანეთ ფუტების რაოდენობა, რომ მიიღოთ ეს სიგრძე ინჩებში\n";

    კოუტ<< "(ათწილადები შეყვანილია წერტილით)";

    კოუტ<< "(ნომრის შესაყვანად ჩაწერეთ ნომერი და დააჭირეთ Enter ღილაკს)\n";

    კოუტ<< "(პროგრამიდან გასასვლელად შეიყვანეთ 0 და დააჭირეთ Enter)\n \n";



რაიმე შეკითხვა?

შეატყობინეთ შეცდომას

ტექსტი, რომელიც გაეგზავნება ჩვენს რედაქტორებს:

გაგზავნა