3 ფაზის სინუსური ტალღის გენერატორი არდუინოს საფუძველზე: 5 ნაბიჯი

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

ამ გაზიარების მიზანია დაეხმაროს ვინმეს, ვინც ცდილობს გამოიყენოს დუეს უფრო დიდი შესრულება + მითითების ნაკლებობა + არასასურველი მონაცემთა ცხრილი.

ამ პროექტს შეუძლია შექმნას 3 ფაზის სინუსური ტალღა @ 256 ნიმუში / ციკლი დაბალი სიხშირით (<1 კჰც) და 16 ნიმუში / ციკლი @ მაღალი სიხშირე (20 კჰც -მდე), რაც საკმარისად კარგია მარტივი LPF– ით და გამომავალი თითქმის სრულყოფილია.

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

ვინაიდან პროცესორის სიმძლავრე მაქსიმალურად იზრდება მიმაგრებულ ფაილში ნაჩვენები მიდგომის საშუალებით, მე გამოვიყენე Arduino Uno როგორც საკონტროლო ერთეული, რომელიც იყენებს Arduino Due– ს გარე შეფერხებას, რათა გადასცეს სიხშირის მნიშვნელობა Arduino Due– ს. სიხშირის კონტროლის გარდა, Arduino Uno ასევე აკონტროლებს ამპლიტუდას (ციფრული პოტენციალის მრიცხველის + OpAmp- ის საშუალებით) ასევე I/O --- ბევრი ადგილი იქნება სათამაშოდ.

ნაბიჯი 1: შექმენით სინუს მონაცემთა მასივი

ვინაიდან რეალურ დროში გაანგარიშება მოითხოვს CPU- ს, უკეთესი მუშაობისთვის საჭიროა მონაცემთა სინუსური მასივი

uint32_t sin768 PROGMEM =…. ხოლო x = [0: 5375]; y = 127+127*(ცოდვა (2*pi/5376/*ან ზოგიერთი # სასურველია დამოკიდებულია მოთხოვნაზე*/))

ნაბიჯი 2: პარალელური გამოყვანის ჩართვა

Uno– სგან განსხვავებით, Due– ს შეზღუდული მითითება აქვს. თუმცა, Arduino Uno– ზე დაფუძნებული 3 ფაზის სინუსური ტალღის შესაქმნელად, პირველ რიგში, შესრულება არ არის აპლოდისმენტი დაბალი MCLK (16MHz, ხოლო 84MHz), მეორე, შეზღუდულ GPIO– ს შეუძლია აწარმოოს მაქსიმუმ 2 ფაზა და გჭირდებათ დამატებითი ანალოგური წრე წარმოებს მე -3 ფაზას (C = -AB).

GPIO- ს ჩართვა ძირითადად ემყარებოდა ცდას და ცდას+SAM3X– ის არასაიმედო მონაცემთა ცხრილს

PIOC-> PIO_PER = 0xFFFFFFE; // PIO კონტროლერი PIO ჩართე რეგისტრაცია (იხ. P656 ATMEL SAM3X მონაცემთა ცხრილში) და https://arduino.cc/en/Hacking/PinMappingSAM3X, Arduino Due pin 33-41 და 44-51 ჩართული იყო

PIOC-> PIO_OER = 0xFFFFFFE; // PIO კონტროლერის გამომავალი ჩართავს რეგისტრს, იხილეთ ATMEL SAM3X მონაცემთა ფურცლის p657 PIOC-> PIO_OSR = 0xFFFFFFFE; // PIO კონტროლერის გამომავალი სტატუსის რეესტრი, იხილეთ ATMEL SAM3X მონაცემთა ფურცელი p658

PIOC-> PIO_OWER = 0xFFFFFFE; // PIO გამომავალი ჩაწერის ჩართვის რეგისტრაცია, იხილეთ ATMEL SAM3X მონაცემთა ფურცელი p670

// PIOA-> PIO_PDR = 0x30000000; // სურვილისამებრ, როგორც დაზღვევა, როგორც ჩანს, გავლენას არ ახდენს შესრულებაზე, ციფრული პინ 10 უკავშირდება როგორც PC29- ს, ასევე PA28- ს, ციფრული პინ 4 უკავშირდება როგორც PC29- ს, ასევე PA28- ს, აქ გამორთულია PIOA #28 & 29

ნაბიჯი 3: შეწყვეტის ჩართვა

მისი მუშაობის მაქსიმალურად გაზრდისთვის, პროცესორის დატვირთვა უნდა იყოს რაც შეიძლება დაბალი. თუმცა CPU pin- სა და Due pin- ს შორის 1-დან 1-მდე კორესპონდენციის გამო, ბიტის ოპერაცია აუცილებელია.

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

ბათილი TC7_Handler (void) {TC_GetStatus (TC2, 1);

t = t%ნიმუშები; // გამოიყენეთ t%ნიმუშები "თუ" -ის ნაცვლად, რათა თავიდან აიცილოთ ტ

ფაზა AInc = (წინასწარ*ტ)%5376; // გამოიყენეთ %5376 მასივის ინდექსის გადავსების თავიდან ასაცილებლად

ფაზა BInc = (ფაზა AInc+1792)%5376;

ფაზა CInc = (ფაზა AInc+3584)%5376;

p_A = sin768 [phaseAInc] << 1; // მიმართეთ PIOC: PC1 to PC8, შესაბამისი Arduino Due pin: pin 33-40, შესაბამისად გადაიტანეთ მარცხნივ 1 ნიშნით

p_B = sin768 [phaseBInc] << 12; // მიმართეთ PIOC: PC12 to PC19, შესაბამისი Arduino Due pin: pin 51-44, შესაბამისად გადაიტანეთ მარცხნივ 12 ციფრი

p_C = sin768 [phaseCInc]; // ფაზა C გამომავალი თანამშრომელი PIOC: PC21, PC22, PC23, PC24, PC25, PC26, PC28 და PC29, შესაბამისი Arduino Due pin: ციფრული პინი: შესაბამისად 9, 8, 7, 6, 5, 4, 3, 10

p_C2 = (p_C & B11000000) << 22; // ეს გამოიმუშავებს PC28 და PC29

p_C3 = (p_C & B00111111) << 21; // ეს წარმოქმნის PC21-PC26

p_C = p_C2 | p_C3; // ეს წარმოქმნის C ფაზის პარალელურ გამომუშავებას

p_A = p_A | p_B | p_C; // 32 ბიტიანი გამომავალი = ფაზა A (8 ბიტიანი) | ფაზა B | ფაზა C

PIOC-> PIO_ODSR = p_A; // გამომავალი რეგისტრი = p_A

t ++; }

ნაბიჯი 4: R/2R DAC

აშენება 3x8bit R/2R DAC, იტვირთება ref google- ში.

ნაბიჯი 5: სრული კოდი

#განსაზღვრეთ _BV (x) (1 << (x)); uint32_t sin768 PROGMEM = /* x = [0: 5375]; y = 127+127*(ცოდვა (2*pi/5376))*/

uint32_t p_A, p_B, p_C, p_C2, p_C3; // ფაზა A ფაზა B ფაზა C მნიშვნელობა-თუმცა გამომავალი არის მხოლოდ 8 ბიტიანი, p_A და p_B მნიშვნელობებით იმუშავებს ახალი 32 ბიტიანი ღირებულების შესაქმნელად, რათა გაუმკლავდეს 32 ბიტიანი PIOC გამომავალს

uint16_t ფაზა AInc, ფაზა BInc, ფაზა CInc, სიხშირე, სიხშირე ახალი; uint32_t ინტერვალი; uint16_t ნიმუშები, წინასწარ; uint32_t t = 0;

void setup () {

// პარალელური გამომავალი PIOC კონფიგურაცია: Arduino Due pin33-40 გამოიყენება როგორც ფაზა A გამომავალი, ხოლო პინ 44-51 მუშაობს B ფაზაზე

PIOC-> PIO_PER = 0xFFFFFFE; // PIO კონტროლერი PIO ჩართეთ რეგისტრი (იხილეთ ATMEL SAM3X მონაცემთა ფურცლის p656) და https://arduino.cc/en/Hacking/PinMappingSAM3X, Arduino Due pin 33-41 და 44-51 ჩართული იყო

PIOC-> PIO_OER = 0xFFFFFFE; // PIO კონტროლერის გამომავალი რეგისტრაციის ჩართვა, იხილეთ ATMEL SAM3X მონაცემთა ფურცელი p657

PIOC-> PIO_OSR = 0xFFFFFFFE; // PIO კონტროლერის გამომავალი სტატუსის რეგისტრი, იხილეთ ATMEL SAM3X მონაცემთა ფურცელი p658

PIOC-> PIO_OWER = 0xFFFFFFE; // PIO გამომავალი ჩაწერის ჩართვის რეგისტრაცია, იხილეთ ATMEL SAM3X მონაცემთა ფურცელი p670

// PIOA-> PIO_PDR = 0x30000000; // სურვილისამებრ, როგორც დაზღვევა, როგორც ჩანს, გავლენას არ ახდენს შესრულებაზე, ციფრული პინ 10 უკავშირდება როგორც PC29- ს, ასევე PA28- ს, ციფრული პინ 4 უკავშირდება როგორც PC29- ს, ასევე PA28- ს, აქ გამორთულია PIOA #28 & 29 // ქრონომეტრის დაყენება, მიმართეთ https://arduino.cc/en/Hacking/PinMappingSAM3X, pmc_set_writeprotect (ყალბი); // გამორთეთ ელექტროენერგიის მართვის კონტროლის რეგისტრების ჩაწერის დაცვა

pmc_enable_periph_clk (ID_TC7); // პერიფერიული საათის დროის მრიცხველის ჩართვა 7

TC_ კონფიგურაცია (/ * საათი */TC2,/ * არხი */1, TC_CMR_WAVE | TC_CMR_WAVSEL_UP_RC | TC_CMR_TCCLKS_TIMER_CLOCK1); // TC საათი 42MHz (საათი, არხი, შედარების რეჟიმის პარამეტრი) TC_SetRC (TC2, 1, ინტერვალი); TC_Start (TC2, 1);

// ტაიმერის შეწყვეტის ჩართვა ტაიმერზე TC2-> TC_CHANNEL [1]. TC_IER = TC_IER_CPCS; // IER = შეწყვეტა რეგისტრაციის ჩართვა TC2-> TC_CHANNEL [1]. TC_IDR = ~ TC_IER_CPCS; // IDR = რეგისტრაციის გამორთვა

NVIC_EnableIRQ (TC7_IRQn); // დაბლოკილი ვექტორის წყვეტის კონტროლერის ჩართვა freq = 60; // სიხშირის ინიციალიზაცია როგორც 60Hz წინასწარ განსაზღვრული = 21; // მასივის ინდექსი 21 ნიმუშით = 256; // გამომავალი ნიმუშები 256/ციკლის ინტერვალი = 42000000/(სიხშირე*ნიმუშები); // შეწყვეტის დათვლა TC_SetRC (TC2, 1, ინტერვალი); // დაიწყოს TC Serial.begin (9600); // სატესტო მიზნით}

void checkFreq ()

{freqNew = 20000;

if (freq == freqNew) {} სხვა

{freq = freq ახალი;

if (freq> 20000) {freq = 20000; /*მაქსიმალური სიხშირე 20 კჰც*/};

თუ (სიხშირე <1) {სიხშირე = 1; /*წთ სიხშირე 1Hz*/};

if (სიხშირე> 999) {წინასწარ = 384; ნიმუშები = 14;} // სიხშირისთვის> = 1 კჰც, თითოეული ციკლისთვის 14 ნიმუში

else if (სიხშირე> 499) {წინასწარ = 84; ნიმუშები = 64;} // 500 <= სიხშირე 99) {წინასწარ = 42; ნიმუშები = 128;} // 100Hz <= სიხშირე <500Hz, 128 ნიმუში/ციკლი

else {წინასწარ = 21; ნიმუშები = 256;}; // სიხშირეზე <100Hz, 256 ნიმუში თითოეული ციკლისთვის

ინტერვალი = 42000000/(სიხშირე*ნიმუშები); t = 0; TC_SetRC (TC2, 1, ინტერვალი); }}

ბათილი მარყუჟი () {

checkFreq (); დაგვიანება (100); }

ბათილი TC7_Handler (ბათილია)

{TC_GetStatus (TC2, 1);

t = t%ნიმუშები; // გამოიყენეთ t%ნიმუშები, რათა თავიდან აიცილოთ t ფაზა AInc = (წინასწარ*t)%5376; // გამოიყენეთ %5376 მასივის ინდექსის გადავსების თავიდან ასაცილებლად

ფაზა BInc = (ფაზა AInc+1792)%5376;

ფაზა CInc = (ფაზა AInc+3584)%5376;

p_A = sin768 [phaseAInc] << 1; // მიმართეთ PIOC: PC1 to PC8, შესაბამისი Arduino Due pin: pin 33-40, შესაბამისად გადაიტანეთ მარცხნივ 1 ნიშნით

p_B = sin768 [phaseBInc] << 12; // მიმართეთ PIOC: PC12 to PC19, შესაბამისი Arduino Due pin: pin 51-44, შესაბამისად გადაიტანეთ მარცხნივ 12 ციფრი

p_C = sin768 [phaseCInc]; // ფაზა C გამომავალი თანამშრომელი PIOC: PC21, PC22, PC23, PC24, PC25, PC26, PC28 და PC29, შესაბამისი Arduino Due pin: ციფრული პინი: შესაბამისად 9, 8, 7, 6, 5, 4, 3, 10

p_C2 = (p_C & B11000000) << 22; // ეს გამოიმუშავებს PC28 და PC29

p_C3 = (p_C & B00111111) << 21; // ეს გამოიმუშავებს PC21-PC26 //Serial.println(p_C3, BIN); p_C = p_C2 | p_C3; // ეს წარმოქმნის C ფაზის პარალელურ გამომუშავებას

p_A = p_A | p_B | p_C; // 32 ბიტიანი გამომავალი = ფაზა A (8bit) | ფაზა B | ფაზა C //Serial.println(p_A>>21, BIN); // PIOC-> PIO_ODSR = 0x37E00000;

PIOC-> PIO_ODSR = p_A; // გამომავალი რეგისტრი = p_A t ++; }