Konstruktion av pedagogisk borstlös DC-motor för undervisning

(1)

Examensarbete 15 hp

Juli 2019

Konstruktion av pedagogisk

borstlös DC-motor för undervisning

(2)

Teknisk- naturvetenskaplig fakultet UTH-enheten Besöksadress: Ångströmlaboratoriet Lägerhyddsvägen 1 Hus 4, Plan 0 Postadress: Box 536 751 21 Uppsala Telefon: 018 – 471 30 03 Telefax: 018 – 471 30 00 Hemsida: http://www.teknat.uu.se/student

Abstract

Construction of pedagogic Brushless DC-motor for

educational purposes

Johan Nyström - Oscar Söderlund

The brushless DC (BLDC) motor is a crucial component of our modern society and exists in a number of everyday items. It is an evolution of the conventional brushed DC motor. It has several advantages compared to the brushed DC motor including less maintenance and better control and precision of the rotary displacement. The goal of this project is to construct a BLDC motor made by 3D printed plastic parts and a control system using Arduinos. The purpose of the motor is that it will be used to demonstrate its functions and to educate engineering students at Uppsala University in electrical propulsion systems. Therefore the motor is designed with educative purposes and it is supposed to be easily controlled by an operator with clear indications of the internal workings. The finished motor consists of a stator which holds six electromagnets placed equally distanced from each other that makes up the tree different phases. In the middle of the stator a rotor is placed which holds four poles of permanent magnets with different polarity. The position of the rotor is determined and controlled by placing three equally distanced hall sensors in the stator. The signals from the hall sensors is sent to the Arduinos which in turn control the polarity of the electromagnets and make the motor rotate. The control system is contained in a plastic box with controls for different modes available for the operator and also indications of the position of the rotor and polarity of the electromagnets.

(3)

Populärvetenskaplig sammanfattning

Den borstlösa likströmsmotorn (BLDC-motor) har en större verkningsgrad samt en längre livslängd än en vanlig DC-motor. Detta beror på att den inte använder sig av borstar för att överföra ström till lindningarna utan istället är uppbyggd så att

magneterna roterar samtidigt som elektromagneterna är statiska. En konventionell BLDC-motor består av metall för att erhålla en högre prestanda, men som resultatet av detta projekt visar så går det att konstruera en med delar gjorda av plast.

Arduino nano är enkelt att programmera och bygger på ett programspråk som till stor del liknar C++ men anpassad för Arduino. Programmeringen är en nyckelkomponent för att styra och strömföra de olika delarna av motorn och det är även enkelt att koppla samman två eller fler Arduinos med varandra och skapa en intern kommunikation sinsemellan. Denna kommunikation går under namnet I2C och bygger på att ena Arduinon sänder ut data som mottas av de övriga som i sin tur agerar olika beroende på vilken data som mottagits.

I detta projekt så har en BLDC-motor designats i CAD-programmet Solidworks där de olika delarna sedan skrivits ut med hjälp av en 3D-skrivare med namnet Zortax M200. Permanentmagneter placerades i rotor-delen av motorn och koppartråd med ett tunt lager plasthölje lindades runt lindningsfästerna.

För att sedan kunna styra och få denna BLDC-motor att fungera så

sammankopplades delarna med 5 stycken Arduinos, 3 stycken H-bryggor samt 4 strömbrytare och en OLED-display.

Syftet med detta examensarbete var att konstruera en BLDC-motor för

undervisningssyfte och enbart ha ett krav på att motorn ska vara pedagogiskt utformad men inget prestandakrav förutom målet att den ska rotera.

(4)

Förord

(5)

Beteckningar

Följande lista innehåller förkortningar och beteckningar för olika tekniska begrepp som används i detta projekt.

BLDC Brushless direct current

PWM Pulse Width Modulation

SCL Serial Clock Line

SDA Serial Data Line

(6)

Innehållsförteckning

Abstract 1 Populärvetenskaplig sammanfattning 2 Förord 3 Beteckningar 4 1 Inledning 6 1.1 Bakgrund/Avgränsning 6 1.2 Arbetsuppdelning 8 1.3 Syfte 9 2 Metod 10

2.1 3D Computer Aided Design 10

2.3 Konstruktion/sammankoppling 12

3 Resultat 13

3.1 Design och konstruktion av motor 13

3.2 Programmering 16

3.2.1 Master-Arduino 16

3.2.2 Slave-Arduino 18

3.2.3 Open vs closed loop 19

(7)

1 Inledning

Detta kapitel avser att vara en introduktion till projektets omfattning där bakgrundsfakta och syftet med projektet presenteras.

1.1 Bakgrund/Avgränsning

En BLDC-motor, eller borstlös likströmsmotor (står för _{brushless direct current), är en} likströmsmotor där magneterna roterar samtidigt som kopparlindningen är statisk och placerad runt magneterna. Den har namnet borstlös på grund av att den inte

använder sig av borstar för att överföra ström till lindningarna så som en vanlig DC-motor behöver göra. Detta bidrar till att BLDC-motorn har en högre

verkningsgrad och en lång livslängd i jämförelse med en DC motor med borstar [1]. En BLDC-motor är uppbyggd av en rotor bestående av ett antal magneter som bildar ett önskat antal poler. I detta projekt så konstrueras det en fyrpolig rotor med hållare för permanentmagneter i 3D-utskriven plast. Motorns yttre del består av en stator som är uppbyggd med kopparlindningar som bestäms med hänsyn till antalet faser som valts. Antalet lindningar ska vara jämnt delbart med antal faser man önskar. Dessutom får inte antalet lindningar vara lika som antalet poler i rotorn, då ett ostabilt läge där rotorns rotation blir ojämn och motorn inte får någon kraft bildas.

I detta projekt består statorn av sex kopparlindningar som är skyddade med ett tunt plasthölje, där lindningarna sitter i par om två med 180° separation mellan varandra, samt 60° mellan de olika faserna, se figur 1 nedan. Dessutom så finns det i detta projekt tre stycken hallsensorer placerade på statorns insida. En hallsensor är en elektrisk komponent som känner av styrkan av ett magnetfält och dess utsignal ändras från låg till hög och vice versa beroende på vilken polaritet den utsätts för. Så en hallsensor placerad på en stator ändrar värde likt en switch när rotorns

(8)

Figur.1 Vänstra bilden visar en BLDC-motor med 6 statorlindningar samt en fyrpolig rotor på plats i mitten. Högra bilden visar statorn där det tydligt framgår hur

lindningarnas koppling ser ut. De små svarta rektanglarna är de utplacerade hallsensorerna med 120_{° separation för att göra det möjligt att bestämma rotorns} position [2].

Arduino-programmering bygger mycket på en förenkling av programspråket C++. Det finns flertalet sorter av Arduinos men i detta projekt så byggs programkoden och kopplingarna upp för Arduino nano, vilken är en av de mindre varianterna av Arduino [3]. Fördelen med Arduino är att det är lätt att få två stycken ihopkopplade att

(9)

lindningarna samt så är en stor fördel med en H-brygga att det enkelt går att

bestämma åt vilket håll strömmen ska gå, vilket i detta projekt leder till att man kan skapa elektromagnetisk plus- och minuspol för de olika faserna.

För att styra effekten som går till motorn så används PWM signaler från Arduinon. PWM står för pulse width modulation (pulsbreddsmodulering) [6]. Detta innebär att man styr hur långa pulser som skickas som signal (pulsbredd). Exempelvis betyder 100 % pulsbredd att signalen alltid är på och kan ses som en DC signal som skickas, medan 0 % pulsbredd innebär att det inte skickas något alls. 50 % pulsbredd innebär således att signalen är hög hälften av tiden och låg den andra hälften. Detta görs i så pass hög frekvens att effekten som levereras står i samband med hur hög

procentsats PWM-signalen har.

Figur.2 Illustration över PWM [8].

1.2 Arbetsuppdelning

(10)

läsaren vilken student som skrivit och har ansvar för de olika delarna. Observera att det i många fall är underrubriker som anges.

Johan Nyström - _{Abstract. Inledning: Bakgrund/Avgränsning: PWM. Metod: 3D}

Computer Aided Design. Resultat: Design och konstruktion av motor, Färdigställande av motor. Diskussion

Oscar Söderlund -_{Inledning: Bakgrund/Avgränsning, Syfte. Metod: Programmering,}

konstruktion/sammankoppling. Resultat: Programmering. Delar av Diskussion. Slutsats

1.3 Syfte

Syftet med detta projekt är att konstruera en BLDC-motor med möjlighet att

(11)

2 Metod

I detta avsnitt visas de olika metoderna som används för att genomföra detta projekt upp. Huvudsakligen har tre olika delar och moment dominerat detta projekt, först konstrueras en 3D-design av motorn med hjälp av Solidworks för att sedan skrivas ut med 3D-skrivare. Sedan programmerades styrningen med en Arduinobaserad kod och slutgiltigen så sammankopplades dessa moment och motorn med

programmerad styrning konstruerades.

2.1 3D Computer Aided Design

Motorn designades till stor del med det datorbaserade designverktyget Solidworks. Solidworks är ett kraftfullt program där användaren kan konstruera 3D modeller av olika delar och sedan sammanfoga dem till en komplett konstruktion. I fallet med BLDC-motorn så är det tre olika delar som konstruerats: Statorn, rotorn, samt hållare till elektromagneter.

Den första delen som designades var rotorn. Rotorn innehöll fyra poler som interagerar med sex stycken elektromagneter i statorn via hallsensorer.

Permanentmagneter erhölls från tidigare projekt och dessa ska utgöra de magneter som är placerade i rotorn.

Totalt 16 magneter placerades i rotorn för att få ett tillräckligt högt magnetiskt flöde som kan påverkas av elektromagneterna samt uppfattas av hallsensorerna. Dessa magneter placeras i fyra olika hållare som konstruerades i Solidworks och blev sedan utskrivna med hjälp av 3D-skrivare. Dessa hållare sätts i sin tur ihop och blir den kompletta rotorn.

(12)

färdig så sparas filen och öppnas i Zortrax egna program som gör modellen möjlig att skriva ut. I Zortrax program så definierar användaren tätheten på materialet samt hur noggrann utskriften blir. Genom att ändra dessa parametrar så påverkas

mängden plast som går åt samt hur lång tid utskriften tar.

De sex hållarna till elektromagneterna skrevs ut i omgångar om två stycken per gång för att spara på tid. De designas med en kil på baksidan i syfte att fästas mot

statorns innersida där motsvarande kilspår finns så att elektromagneterna blir placerade 60° relativt nästa elektromagnet för att ge maximalt vridmoment. Hela motorns design bygger till stor del på arbete utfört av en tidigare grupp som genomförde ett liknande projekt. Statorn har i stort sett samma mått som den tidigare versionen då det redan fanns en konstruktion som passade bra att bygga vidare på, vilket sparade tid och material.

2.2 Programmering

Styrningen till motorn konstruerades med hjälp av Arduinos som programmeras med en Arduinobaserad kod som liknar C++. Fem stycken Arduino nano med olika

programmeringskod kommunicerade genom Arduinos kommunikationssystem CI2 som sammankopplar två eller fler Arduinos i en “Master/Slave” relation, där den ena sänder ut information i form av bytes till motparten som enbart startar sin kod när den mottagit värden från sin Master-Arduino.

Arduino-relationen sinsemellan de fem är så att en Arduino agerar master åt tre av de övriga, som enbart tar emot värden och inte sänder tillbaka något till mastern. Dessa tre Arduinos representerar och styr varsin fas efter order från mastern. Master-Arduinon lokaliserar därför rotorns position i statorn med hjälp av rotorns magneter samt utplacerade hallsensorer. Dessa hallsensorer agerar kodmässigt som en strömbrytare som växlar varje gång den stöter på en magnetisk pol.

(13)

rotationshastigheten och omvandlar det värdet till procent för att visa på en OLED-display.

2.3 Konstruktion/sammankoppling

Målet med motorn är att den ska presenteras på ett pedagogiskt sätt och vara enkel att kontrollera gällande styrning av strömriktning i elektromagneterna och därmed rotorns position.

De totalt sex elektromagneterna är uppdelade i tre olika faser: A, B, och C. Dessa faser utgörs av motstående elektromagneter i statorn. Dvs. Fas A består av en lindning seriekopplad med en annan lindning skild med 180° från den första. När hallsensorn registrerar att en pol på rotorn passerar så skickas det en signal till master Arduinon som i sin tur kommunicerar med Arduinon som styr nästa fas. Denna slave Arduinon skickar då ut en PWM signal där strömriktningen bestämmer polaritet för denna fas i statorn och antar då polaritet som attraherar rotorns pol. Rotorn kommer då att ställa sig mot den nya polariteten. Därefter får nästa

hallsensor signal om rotorns position och kan kommunicera att efterföljande fas ska bli attraherande. När detta sker kontinuerligt så fås motorn i rotation. Detta kallas för elektronisk kommutering och är signifikant för skillnaden mellan den konventionella DC-motorn och BLDC-motorn där DC-motorn använder sig av mekanisk

kommutation [2].

Ett annat läge som ska implementeras är att styra polariteten på varje fas för sig. Detta läge medför att det enkelt påvisas hur fasernas magnetisering interagerar med permanentmagneterna i rotorn. Det läget benämns som open loop då det inte finns någon feedback från hallsensorerna som instruerar programmet om vad som ska ske härnäst. Elektromagneterna ska då kunna anta tre olika tillstånd: Positiv, neutral samt negativ polaritet.

För att kontrollera motorn och dess funktioner på ett enkelt sätt så konstruerades en kontrollpanel där motorns hastighet kan styras men även med möjlighet att ändra till open loop-läget och kontrollera faserna. Denna panel ska vara pedagogiskt utformad så att användaren får en förståelse om sambandet mellan hallsensorer och

(14)

3 Resultat

I denna del av rapporten visas resultaten upp och analyseras. Avsnittet delas upp i underrubriker för de olika delarna och avslutas sedan med det sammansatta resultatet och slutprodukten.

3.1 Design och konstruktion av motor

Figur.3 Mittendel av rotor designad i Solidworks

(15)

Figur.4 Slutdel av rotor designad i Solidworks.

(16)

Figur.5 Exploderad vy över den sammansatta rotorn bestående av två mittendelar och två slutdelar.

(17)

Figur.6 Bilden till höger föreställer en ihopsättning av motorn bestående av stator, lindningsfästen samt rotor, till vänster visas exploderad vy över alla motorns delar.

Fältstyrkan från elektromagneterna påverkas av vilket ämne man använder för lindningsfästena och i detta fall används plast vilket ger en mindre fälstyrka jämfört med järn [7].

3.2 Programmering

Programmeringsdelen delas upp i följande kategorier: Master-Arduino,

Slave-Arduino, OLED-Arduino samt Open vs closed loop som beskriver två olika lägen man kan driva motorn. Totalt 5 Arduinos används och de är programmerade med en egen kod anpassad för deras syfte. Master/Slave begreppet används för att beskriva två eller fler Arduinos som använder I2C _{kommunikation där den ena}

skickar ut data och den andra enbart kör sin loop när den mottar data från den första Arduinon.

3.2.1 Master-Arduino

(18)

Tabellen här nedan visar en förenkling hur Masterns kod är uppbyggd och hur den bearbetar de olika värdena hallsensorerna ger för att sedan bestämma hur de olika faserna ska agera, om de ska anta positiv, negativ eller neutral polaritet (åt vilket håll strömmen genom fasens lindning går). Observera att det enbart är dessa logiska kombinationer som hallsensorerna kan anta, då övriga kombinationer så som (0,0,0) och (1,1,1) skulle betyda att rotorn enbart bestod av plus- eller minuspolaritet vilket inte stämmer. För att försäkra sig om att hallsensorerna fungerar som de ska stängs därför alla faser av vid övriga kombinationen.

Hallsensorvärde Instruktion till Slave-A (polaritet på fas A) Instruktion till Slave-B(polaritet på fas B Instruktion till Slave-C(polaritet på fas C 0,0,1 Negativ Av Positiv 0,1,0 Av Positiv Negativ 0,1,1 Negativ Positiv Av 1,0,0 Positiv Negativ Av 1,0,1 Av Negativ Positiv 1,1,0 Positiv Av Negativ Annan kombination Av Av Av

Tabell1: Tabellen visar styrningen från Mastern där 3 hallsensorer som antar ett värde 0 eller 1 bestämmer rotorns position och gör det möjligt för Mastern att

bestämma hur varje fas ska agera. Observera även att vid övriga kombinationer som inte står med på listan till vänster så stängs samtliga faser av.

Den data som mastern skickar vidare till Slave-A, Slave-B och Slave-C med hjälp av består av 8 bits, där vi först sänder ut bokstaven (character = char i kodspråk) C

I2

‘L’, ‘N’ eller ‘H’ som representerar L = Low = negativ polaritet, N = neutral =

(19)

potentiometer och sedan bearbeta det värdet för att passa in på den PWM-skala som önskas. Potentiometern som används ger ut ett värde mellan 0-1023, samtidigt som PWMs pulsbredd enbart kan vara ett värde mellan 0-255. Utöver det så klarade inte motorn av en pulsbredd på högre än ~130 vilket gjorde att värdet Mastern får från potentiometern divideras med 8 innan det sänds vidare till Slave-A,Slave-B och Slave-C.

3.2.2 Slave-Arduino

Tre Slave-Arduinos representerar och styr varsin fas. Både Slave-A, Slave-B och Slave-C är uppbyggd med i stort sett identisk kod, bortsett från ett eget

adressnummer på varje Arduino för att bestämma vilken Arduino man vill starta en dataöverföring till. Koden i samtliga Slave-Arduinos är uppbyggd med ett program Wire.onReceive(receiveEvent) som enbart körs när en annan Arduino anropar, och i detta projekt är det Mastern som sänder ut olika data till de tre Slave-Arduinos. Slave-Arduinon tar emot datan som Mastern skickat och programmet bearbetar värdena som kommer in. Först jämförs den inkomna bokstaven med en lista på olika if-satser där varje if-sats jämför bokstaven med de olika förbestämda bokstäverna för normal drift (‘L’,‘N’,‘H’) och ifall if-satsens bokstav är lika som den överförda

bokstaven aktiveras if-satsen. När detta sker bestäms riktningen på strömmen genom lindningarna för fasen, samt till vilken styrka (pulsbredd) lindningarnas elektromagnet ska anta med hjälp av det andra överförda värdet (heltalet) från mastern. If-satsen bestämmer även ifall H-bryggans inbyggda funktion “Enable” ska vara aktiverad eller inte, vilket avgör ifall ström kan gå igenom H-bryggan över huvud taget. Detta används främst för att skapa en stabil nolla så att fasen är riktigt

avstängd vid neutrala läget. Sist så används if-satsen för att en positiv eller negativ LED-lampa. Tabellen nedan visar en förenkling av Slave-programmet med olika input och vilka utfall det ger. Strömmen bestäms med hjälp av kommandot analogWrite() samtidigt som Enable och LEDs bestäms med kommandot

digitalWrite(), detta eftersom strömmen inte enbart antar ett värde “High/på” eller “Low/av” utan även en styrka (PWM).

(20)

Ström i negativ riktning pwm(överförda heltalet) 0 0 Enable (High or Low)

High High Low

Positiv LED(Röd) Av På Av

Negativ LED(Blå) På Av Av

Tabell 2: Tabell föreställande en Slave-Arduinos olika utfalll vid olika inputs i form av data från en Master-Arduino (vid normal drift). Observera att Enable är aktiverat och låter ström gå genom H-bryggan vid High.

3.2.3 Open vs closed loop

Det finns två lägen för BLDC-motorn i detta projekt. Normal drift som redan

presenterats i resultatdelen och som innebär en closed loop där en Master-Arduino sänder ut data till Slave-Arduinos baserat på hallsensorernas värde (och följaktligen rotorns position) för att skapa en rotation.

En switch med två lägen(på,av) är inkopplad på Master-Arduinon för att göra det möjligt att slå av den normala driften och därigenom “öppna upp loopen” istället. Detta är mer känt som open loop eftersom den vanliga kretsen/loopen är bruten. I detta fall så skickar Mastern enbart ut bokstaven ‘M’ till samtliga Slave-Arduinos med ett förbestämt värde på pulsbredd på 24 % som motsvarar ungefär 65 % av vad motorn klarar av att driva . Mastern skickar samma bokstav till alla, jämfört med tidigare läge där två Arduinos aldrig erhöll samma bokstav samtidigt. När en

(21)

krav är uppfyllda samtidigt. If-satserna kontrollerar om ena läget är på och de andra är av eller ifall båda lägena är av (vid neutralt läge). Därefter matas en ström i respektive riktning och fas beroende på vilket håll och vilken switch man ändrar. Dessutom så lyser positiva(röd) respektive negativa(blå) LED-lampor för de olika faserna när switchens position ändras. Nedan visar tabellen vad utfallet blir vid switchens olika positioner. Observera att switchläge High/Low innebär att den är i positivt läge, Low/High är negativt läge samt Low/Low betyder att den står i neutralt/avstängt läge.

Switchläge High/Low Low/High Low/Low

Ström i positiv riktning PWM(~24 %) 0 0 Ström i negativ riktning 0 PWM(~24 %) 0 Enable (High or Low)

High High Low

Positiv LED(Röd) På Av Av

Negativ LED(Blå) Av På Av

Tabell 3: Tabell som visar de olika utfallen vid open loop när man ansluter en switch med tre lägen(på,av,på). Detta används för att starta valfri eller varje fas manuellt. Observera att pulsbredd-värdet i denna tabell defineras som ~24 % av maximalt tillgängligt pulsbredd (100%) men att motorn har en maxkapacitet på ungefär 45 %

3.2.4 OLED-Arduino

(22)

display() som är en del av biblioteket Adafruit (Adafruit_GFX och Adafruit_SSD1306).

3.3 Färdigställande av motor

Motorns konstruktion överensstämmer i stor grad med vad som först planerades. Det som dock skiljer sig är att det inte gick att få till en transparent stator. Detta berodde på flera faktorer. Tanken var att skriva ut den i transparent plast men det visade sig inte uppfylla kravet på att vara just transparent när väl utskriften var färdig. Ett annat problem som uppkom var att 3D-skrivaren fallerade då en så pass stor utskrift skulle genomföras. Statorn saknade mycket material efter utskriften och kunde därför inte användas. Lösningen blev att använda föregående projektets redan utskrivna

statordelar och måla de olika segmenten som representerar faserna i olika färger för att på ett pedagogiskt sätt representera dem.

(23)

LEDs finns för att visa vilka av de tre hallsensorerna som skickar signal beroende på i vilket läge rotorn står.

(24)

4 Diskussion

Denna del är till för att ge synpunkter på projektet i helhet och förklara vilka delar som behövde ändras under projektets gång. Diskussionen är även till för att ge förslag på förbättringar och fler funktioner som kan implementeras för motorn.

Den resulterande BLDC-motor som konstruerats känns pedagogiskt designad samt enkel att manövrera för en person utan stor förkunskap. Den uppfyller de krav som sattes i början men det finns även funktioner och förbättringar att lägga till för en ännu mer optimal BLDC-motor i utbildningssyfte. Statorn består av tre färger (gul,grön,svart), för att lättare visualisera de tre faserna på ett pedagogiskt sätt, samtidigt som rotorns poler är utmålade i rött och blått för att enklare urskilja de olika polariteterna.

Vanligtvis kopplas en BLDC-motors lindningar i stjärnkonfiguration men i detta projekt så kopplades varje fas separat till varsin H-brygga. Detta medför att en extra H-brygga, totalt 3 stycken behöver användas men det ger fördelen att

programmeringen kan förenklas och man har i stort sett likadan kod för varje fas där varje H-brygga driver sin fas med hjälp av varsin Arduino.

Det enda momentet i projektet som har stört tidsplaneringen i någon grad är

utskriften av delarna till motorn. Flera delar till rotorn kunde skrivas ut utan problem i början men det noterades senare att vid flera utskrifter så saknades material i delar som gjorde dem oanvändbara. Detta gjorde att mycket tid gick till spillo då en komplett utskrift av en enda rotordel tar 12 timmar och en statordel tar 19 timmar. Efter flera försök så var samtliga delar till rotorn samt alla hållare till lindningar färdiga. Med dessa delar så kunde laborationsfasen påbörjas även fast statorn inte var färdig.

Planen från början var att skriva ut alla delar till motorn själv, men eftersom

3D-skrivaren slutade fungera korrekt så togs beslutet att istället använda statordelar från ett liknande projekt som använts tidigare. Detta ledde i sin tur inte till någon stor förändring i konstruktionen eftersom en hel del inspiration har hämtats från de

(25)

Den ursprungliga tidsplaneringen som gjordes i uppstartsfasen delade in projektet i tydliga moment som skulle slutföras efter varandra. Dessa moment inkluderade att först skriva ut alla delar för att sedan börja med programmeringen och introducera elektroniken när en komplett motor fanns att laborera på. I verkligheten så utfördes dessa moment sida vid sida och laboration utfördes på delar direkt när de hade blivit färdiga. Signaler från hallsensorer undersöktes tidigt och även magnetisering av lindningar gjordes tidigt. Så fort tre lindningar och en rotordel var utskrivna så kunde laboration börja på en nedskalad motor. Programmeringen som utfördes under detta moment behövde då inte skalas upp något när antalet delar till rotor och antalet lindningar fortsatte skrivas ut vilket sparade mycket tid.

Att göra statorn helt transparent från sidorna hade medfört en större insyn i motorns inre verkande delar. Det lyckades inte genomföras eftersom att 3D-skrivaren inte kunde skriva ut statordelarna och att den transparenta plasten som användes inte blev fullt så transparent som önskat när den skrevs ut. Lösningen med att använda existerande statordelar från tidigare projekt blev dock lyckad. Genom att färgkoda statorn beroende på fas samt använda plexiglas på båda sidor för att kunna fästa statorn och rotor-axeln på i stabiliseringssyfte så blev motorn tillräckligt transparent med bra insyn.

Att löda fast alla komponenter och kablar på ett gemensamt kretskort var ett av de sista momenten i projektet. Med den begränsade volymen på styrboxen var det svårt att placera kretskortet samt de tre H-bryggorna på ett utrymmeseffektiv sätt.

Kablarna på kretskortet färgkodades så gott det gick men det kan antas vara svårt för någon som inte är insatt i projektet fullt ut från början att förstå vilken funktion varje kabel har. Därför gjorde en kopia av alla kopplingar i programmet Eagle så att framtida redigering av funktioner eller felsökning av kortet kan göras enklare.

(26)

(27)

5 Slutsats

Slutsatsen är till för att knyta ihop resultatet med de inledande målen och syftet och ge en kortfattad bild om hur väl detta projekt har lyckats.

Målet var att konstruera en fullt fungerande 4-pols BLDC-motor med bra insyn (transparent stator) med lättmanövrerad panel för motor-/fasstyrning och med en Arduino-baserad motorstyrning. Dessa instruktioner efterföljdes i metod och

utförande och resultatet blev en fungerande BLDC-motor som uppfyller dessa krav. Resultat-delen redovisar hur de olika delarna konstruerades och de olika momenten så som design, programmering och sammansättning genomfördes samtidigt som diskussionen ger en större insyn på ändringar som gjorts allt eftersom projektets gång.

(28)

Litteraturförteckning

[1] P. Yedamale, "AN885, Brushless DC (BLDC) Motor Fundamentals." Microchip Technology Inc, 2003. [Online]. Available:

http://ww1.microchip.com/downloads/en/appnotes/00885a.pdf [Använd 27 maj. 2019].

[2] J.Abrahamsson, HT18-VT19 Electric Propulsion Systems Lecture 10: “The BLDC motor”. Lecture presented at; Uppsala University, 2019.

[3] Arduino, “Arduino Nano”, 2019. [Online].

Available: https://store.arduino.cc/arduino-nano [Använd 27 maj. 2019].

[4] J.Abrahamsson, HT18-VT19 Electric Propulsion Systems Lecture 11: “DIGITAL COMMUNICATION”. Lecture presented at; Uppsala University, 2019.

[5] Dr.R Hessmer, “IBT-2 H-Bridge with Arduino”, 23 december 2013 [Online] Available: http://www.hessmer.org/blog/2013/12/28/ibt-2-h-bridge-with-arduino/

[Använd 27 maj. 2019]

[6] K.Shirriff, “Secrets of Arduino PWM”, 2009 [Online]

Available: http://www.righto.com/2009/07/secrets-of-arduino-pwm.html [Använd 27 maj. 2019]

[7] H.Bernoff, “Roterande Elektriska Maskiner” Upplaga VT2015, Uppsala: Hans Bernoff; 2015

[8] T.Hirzel, “PWM”, 2019. [Online].

(29)

Appendix

Master-kod:

#include <Wire.h>

const int hallPin1 = 7; // the number of the hall effect sensor pin 1

const int ArduinoA = 7; //the number of the slave arduino for phase A

const int ArduinoB = 8; //the number of the slave arduino for phase B

const int ArduinoC = 9; //the number of the slave arduino for phase C

const int ArduinOLED = 15; //the number of the slave arduino for the OLED display

const int switchPinM = 3;

const int switchPin1 = 4;

int pwm = 60;

int switchvalue1 =0;

int switchvalueM =0;

const int PotentiometerIn = A0; //Analog input potentiometer

int PotValue = 0; //value potentiometer

int hallState1 = 0; // variable for reading the hall sensor status

int hallState2 = 0;

(30)

const int hallLED1 = 10;

void setup() { Wire.begin();

// Serial.begin(9600);

// Serial.println("I2C Master ready!");

pinMode(hallPin1, INPUT); pinMode(hallPin2, INPUT); pinMode(hallPin3, INPUT);

pinMode(hallLED1, OUTPUT);

pinMode(switchPinM,INPUT); pinMode(switchPin1,INPUT); pinMode(switchPin2,INPUT); pinMode(switchPin3,INPUT);

}

void loop() {

int PotValue2 = analogRead(PotentiometerIn); int PotValue = ((PotValue2)/8);

//delay(50);

(31)

digitalWrite(hallLED1,HIGH); }

else {

digitalWrite(hallLED1,LOW); }

if(hallState2 == 0){

else {

if(hallState3 == 0){

else {

if(switchvalueM>0) {

Wire.beginTransmission(ArduinoA); Wire.write('M');

Wire.write(pwm);

Wire.endTransmission(ArduinoA); Wire.beginTransmission(ArduinoB); Wire.write('M');

Wire.write(pwm);

Wire.endTransmission(ArduinoB); Wire.beginTransmission(ArduinoC); Wire.write('M');

Wire.write(pwm);

(32)

}

else {

if (hallState1 == LOW && hallState2 == HIGH && hallState3 ==

LOW) // LOW = Magnet close to hall sensor (Low distance)

{

Wire.beginTransmission(ArduinoA); Wire.write('N');

Wire.write(PotValue);

Wire.endTransmission(ArduinoA); Wire.beginTransmission(ArduinoB); Wire.write('H');

Wire.endTransmission(ArduinoB); Wire.beginTransmission(ArduinoC); Wire.write('L');

Wire.endTransmission(ArduinoC);

// Serial.println("Fas A av, Fas B plus, Fas C minus");

}

else if(hallState1 == LOW && hallState2 == HIGH && hallState3 ==

HIGH ) {

Wire.beginTransmission(ArduinoA); Wire.write('L');

Wire.endTransmission(ArduinoA); Wire.beginTransmission(ArduinoB); Wire.write('H');

Wire.endTransmission(ArduinoB); Wire.beginTransmission(ArduinoC); Wire.write('N');

(33)

}

else if (hallState1 == LOW && hallState2 == LOW && hallState3 ==

HIGH ) {

Wire.beginTransmission(ArduinoA); Wire.write('L');

Wire.endTransmission(ArduinoA); Wire.beginTransmission(ArduinoB); Wire.write('N');

Wire.endTransmission(ArduinoB); Wire.beginTransmission(ArduinoC); Wire.write('H');

//Serial.println("Fas A minus, Fas B av, Fas C plus");

}

else if (hallState1 == HIGH && hallState2 == LOW && hallState3 == HIGH){

Wire.beginTransmission(ArduinoA); Wire.write('N');

Wire.endTransmission(ArduinoA); Wire.beginTransmission(ArduinoB); Wire.write('L');

Wire.endTransmission(ArduinoB); Wire.beginTransmission(ArduinoC); Wire.write('H');

//Serial.println("Fas A av, Fas B minus, Fas C plus");

}

else if (hallState1 == HIGH && hallState2 == LOW && hallState3 == LOW) {

(34)

Wire.write('H'); Wire.write(PotValue);

Wire.endTransmission(ArduinoA); Wire.beginTransmission(ArduinoB); Wire.write('L');

//Serial.println("Fas A plus, Fas B minus, Fas C av");

}

else if (hallState1 = HIGH && hallState2 == HIGH && hallState3 == LOW) {

Wire.beginTransmission(ArduinoA);

Wire.write('H'); Wire.write(PotValue);

Wire.endTransmission(ArduinoA); Wire.beginTransmission(ArduinoB); Wire.write('N');

Wire.endTransmission(ArduinoB); Wire.beginTransmission(ArduinoC); Wire.write('L');

// Serial.println("Fas A plus, Fas B av, Fas C minus");

} else {

Wire.beginTransmission(ArduinoA);

Wire.write('N'); Wire.write(PotValue);

(35)

// Serial.println("Fas A av, Fas B av, Fas C av");

} } }

Slave-A kod: _{Observera att det enbart är anropningskonstanten ArduinoA som är} unikt för Slave-A, annars är koden lika för alla Slaves.

#include <Wire.h>

const int ArduinoA = 7; //Nummer på denna arduino så att maestro ska anropa rätt

const int FasPlus = 9; // the number of the PWMPin for plus (plusladdad)

const int FasMinus =10; // the number of the PWMPin for minus (minusladdad)

volatile char x = 0;

volatile int pwm = 0;

const int ENABLE =2; //Enable för att kunna slå av fasen helt vid "av".

const int LEDneutral =5;

const int LEDplus = 7;

const int LEDminus = 6;

(36)

int switchvalue1 = 0 ;

int switchvalue2 = 0 ;

void setup() {

Wire.begin(ArduinoA);

Wire.onReceive(receiveEvent); // data slave received

// Serial.println("I2C Slave ready!");

noInterrupts();

TCCR1A |= (1 << WGM10); TCCR1A &= ~(1 << WGM11); TCCR1B |= (1 << WGM12); TCCR1B &= ~(1 << WGM13);

// Here, we change the pre-scalar from 64 to 8, increasing PWM frequency with a factor of 8

TCCR1B &= ~(1 << CS10); TCCR1B |= (1 << CS11); TCCR1B &= ~(1 << CS12);

// Turn on interrupts

interrupts();

pinMode(switchPin1,INPUT); pinMode(switchPin2,INPUT); pinMode(LEDplus, OUTPUT); pinMode(LEDminus,OUTPUT); pinMode(LEDneutral, OUTPUT); pinMode(ENABLE, OUTPUT); pinMode(FasPlus, OUTPUT); pinMode(FasMinus,OUTPUT); }

(37)

switchvalue1=digitalRead(switchPin1); switchvalue2=digitalRead(switchPin2); if (x=='L'){

analogWrite(FasPlus, 0); //Fas A är minus vid 'L' "Low"

analogWrite(FasMinus,pwm);

digitalWrite(ENABLE,HIGH); digitalWrite(LEDplus, LOW); digitalWrite(LEDminus,HIGH); digitalWrite(LEDneutral,LOW); }

else if (x =='N'){

analogWrite(FasPlus, 0); //Fas A är neutral/av vid 'N'

"Neutral"

digitalWrite(ENABLE,LOW); digitalWrite(LEDplus, LOW); digitalWrite(LEDminus,LOW); digitalWrite(LEDneutral,HIGH);

}

else if (x =='H'){

analogWrite(FasPlus, pwm); //Fas A är plus vid 'H' "High"

analogWrite(FasMinus,0); digitalWrite(ENABLE,HIGH); digitalWrite(LEDplus, HIGH); digitalWrite(LEDminus,LOW); digitalWrite(LEDneutral,LOW); }

else if (x =='M'){

(38)

analogWrite(FasPlus, pwm); //Fas A är plus och LEDplus lyser

analogWrite(FasMinus,0); digitalWrite(ENABLE,HIGH); digitalWrite(LEDplus, HIGH); digitalWrite(LEDminus,LOW); digitalWrite(LEDneutral,LOW); }

else if (switchvalue1 == LOW && switchvalue2 == HIGH) {

analogWrite(FasPlus, 0); //Fas A är minus och LEDminus lyser

digitalWrite(ENABLE,HIGH); digitalWrite(LEDplus, LOW); digitalWrite(LEDminus,HIGH); digitalWrite(LEDneutral,LOW); }

else if (switchvalue1 == LOW && switchvalue2 == LOW) {

analogWrite(FasPlus, 0); //Fas A är neutral och LEDneutral

lyser

(39)

OLED-display kod: #include <stdio.h> #include <SPI.h> #include <Wire.h> #include <Adafruit_GFX.h> #include <Adafruit_SSD1306.h> #define OLED_RESET 4

const int analogInPin = A0; // Analog input pin that the potentiometer is attached to

int potValue = 0;

double val = 0;

Adafruit_SSD1306 display(OLED_RESET);

void setup() {

pinMode(analogInPin, INPUT);

display.begin(SSD1306_SWITCHCAPVCC, 0x3C); display.display(); display.clearDisplay(); display.setTextSize(1); display.setTextColor(WHITE); } void loop() {

// print the results to the Serial Monitor:

// wait 2 milliseconds before the next loop for the analog-to-digital

(40)

delay(2); display.setCursor( 71, 17); display.setTextSize(2); display.setTextColor(WHITE); display.println("%"); display.setCursor( 36, 17); display.setTextSize(2); display.setTextColor(WHITE);

val = analogRead(analogInPin);

display.println(int ((val / 1023) * 100)); display.drawRect(0, 1, 122, 10, 1);

display.fillRect(1, 1, val / 8.5, 10, 1); display.setCursor( 2, 2);

display.setTextSize(1);

display.setTextColor(BLACK);

display.println(""); display.display();

display.clearDisplay(); // Clear display must be used to clear

text etc