სერვო ძრავის კონტროლი STM32F4 ARM MCU– ით: 4 ნაბიჯი

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

გამარჯობა მეგობრებო:) ასე რომ, ამ პროექტში ჩვენ გავაკონტროლებთ სერვო ძრავას STM32F4 ARM MCU– ით. ჩემს შემთხვევაში, მე გამოვიყენებ აღმოჩენის დაფას, მაგრამ თუ გაერკვევით პრობლემის არსში, მაშინ შეგიძლიათ გამოიყენოთ იგი თითოეული MCU– სთვის. Ისე. დავიწყოთ:)

ნაბიჯი 1: აპარატურისა და პროგრამული უზრუნველყოფის მოთხოვნები

აპარატურის თვალსაზრისით ჩვენ დაგვჭირდება:

• MCU, რომელიც ჩემს შემთხვევაში არის STM32f4 აღმოჩენის დაფა
• საერთო სერვო ძრავა, როგორიცაა SG90 ან სხვა

პროგრამული უზრუნველყოფის თვალსაზრისით ჩვენ დაგვჭირდება:

• STM32CubeMX
• Keil uVision

თუ ეს ყველაფერი გაქვთ, გადადით შემდეგ საფეხურზე:)

ნაბიჯი 2: STM32CubeMX კონფიგურაცია

როგორც მოგეხსენებათ, სერვო ძრავის გასაკონტროლებლად ჩვენ გვჭირდება PWM სიგნალი. მოთხოვნები PWM სიგნალის თვალსაზრისით ასეთია:

• PWM პერიოდი უნდა იყოს 20 ms
• დროულად უნდა იყოს 0.5 -დან 2.5 მლ -მდე. როდესაც დრო არის 0.5 mS, მაშინ სერვო გადატრიალდება 0 გრადუსზე, 1.5 mS 90 გრადუსზე და 2.5 mS 180 გრადუსზე.

ასე რომ, ჩვენ გვჭირდება კონფიგურაცია PWM და ამ მიზნით ჩვენ გამოვიყენებთ Timer1- ს.

• პირველი, აირჩიეთ TIM1 ტაიმერების განყოფილებიდან. ეს ნაბიჯი

• შემდეგ, რეჟიმის განყოფილებიდან

  1. აირჩიეთ შიდა საათი ეს ნაბიჯი
  2. PWM Generation CH1 ეს ნაბიჯი

• შემდეგ, კონფიგურაციის განყოფილებიდან

  1. დააყენეთ Prescaler 160 -ზე ეს ნაბიჯი
  2. დააყენეთ მრიცხველის პერიოდი 2000 წელს ეს ნაბიჯი
  3. დააყენეთ პულსი 50 -ზე ამ ნაბიჯზე
• გარდა ამისა, საათის კონფიგურაციიდან დააყენეთ APB1 ტაიმერის საათი 16 მჰც -მდე. ეს ნაბიჯი

ახლა მოდით ვისაუბროთ ამ ნაბიჯზე:

ჩვენი APB1 ტაიმერის საათის სიხშირეა 16 MHz. ასე რომ, ეს ნიშნავს, რომ 1 წამის მისაღებად საჭიროა 16, 000, 000 ტკიპა. თუმცა, ჩვენ დავაყენეთ ჩვენი წინასწარი გამყიდველი 160 -ზე. ეს ნიშნავს, რომ ჩვენ გავყოთ ჩვენი სიხშირე ამ რიცხვზე და შევამცირეთ ტკიპების რაოდენობა 100,000 -მდე. ასე რომ, 1 წამის განმავლობაში ჩვენ გვჭირდება 100,000 ტკიპა. თუმცა, ჩვენ გვჭირდება 20mS PWM პერიოდი, როგორც ადრე აღვნიშნეთ. ასე რომ, მარტივი მათემატიკის საფუძველზე, ჩვენ გვჭირდება 2000 ტკიპა 20mS– ისთვის. ასე რომ, Counter Period– ის 2000 – ზე დაყენებით ჩვენ განვსაზღვრავთ PWM სიგნალის პერიოდს, რომელიც არის 20 mS. ახლა ჩვენ უნდა განვსაზღვროთ ტკიპის რიცხვი 0.5mS– დან 2.5mS– მდე დროის მისაღებად. ჩვენ შეგვიძლია მივიღოთ ეს განტოლება მარტივი მათემატიკისგან და ის არის:

On_Time = (Tick_Number / 100). გაითვალისწინეთ, რომ ეს არის დრო, რომელიც ცვლის სერვო ძრავის კუთხეს. ასე რომ, სურათის ქვემოთ მე ვაჯამებ ამ ნაბიჯს. თუ თქვენ გაქვთ რაიმე შეკითხვა დაწერეთ კომენტარებში და მე გიპასუხებთ რაც შეიძლება სწრაფად.

გამოთვლების სურათი

ყოველივე ამის შემდეგ შექმენით კოდი:)

ნაბიჯი 3: Keil UVision კოდირება

მოდით, ჯერ განვსაზღვროთ რისი გაკეთება გვინდა? ჩვენ გვსურს, დავწეროთ ფუნქცია, რომელიც იღებს ხარისხს და დავწეროთ ის სერვოზე. მაშ, როგორ გავაკეთებთ ამას? როგორც უკვე ვთქვით, კუთხის შესაცვლელად საჭიროა დროულად შევცვალოთ. ჩვენი კუთხეები იცვლება [0, 180] და ტკიპების რიცხვი, რომელიც დროულად განსაზღვრავს [50, 250] შორის. ასე რომ, ჩვენ გვჭირდება რუქის ფუნქცია, რომელიც ასახავს მოცემულ კუთხეს ტკიპების რაოდენობის დიაპაზონში. მაგალითად, 0 გრადუსი 50 ტკიპისთვის, 180 გრადუსი 250 ტკიპისთვის და ასე შემდეგ … მოდით დავწეროთ ჩვენი რუქის ფუნქცია:

int რუკა (int st1, int fn1, int st2, int fn2, int მნიშვნელობა) {return (1.0*(value-st1))/((fn1-st1)*1.0)*(fn2-st2)+st2; }

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

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

void servo_write (int angle) {htim1. Instance-> CCR1 = რუკა (0, 180, 50, 250, კუთხე); }

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

თუმცა, იმისათვის, რომ ამ ყველაფერმა იმუშაოს, ჩვენ პირველ რიგში ვიწყებთ pwm- ს, რომელიც შეიძლება გაკეთდეს მხოლოდ კოდის ხაზით:

HAL_TIM_PWM_ დაწყება (& htim1, TIM_CHANNEL_1);

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

void servo_sweep (void) {for (int i = 0; i <= 180; i ++) {servo_write (i); HAL_გვიანება (10); } for (int i = 180; i> = 0; i--) {servo_write (i); HAL_გვიანება (10); }}

ასე რომ, ის უბრალოდ ითვლის 180 -მდე, შემდეგ 0 -მდე და ჩაწერეთ ეს მნიშვნელობები სერვოზე:) ასე რომ, ვნახოთ შედეგი!

ნაბიჯი 4: შედეგი:)

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