CAM handleiding SolidWorks deel IV

CAD/CAM handleiding SolidWorks deel IV Vakcode 112430

Universiteit Twente Vakgroep Ontwerpen, Productie en Management door Ir. H.Tragter m.m.v. studenten B.Koopman, P.te Morsche, S.Wolbers en M. Röring

5e druk, 26 september 2003 (geschikt voor SolidWorks vanaf versie 2003) Copyright © 1999, 2003 by the University of Twente

Inhoudsopgave

Preface

xi

Hoe is het Opgebouwd: welke delen....................................................................................xii Beoogde gebruikers............................................................................................................ xiii Benodigde voorkennis........................................................................................................ xiii Structuur van deze handleiding...........................................................................................xiv Benodigdheden................................................................................................................. xviii Waar beginnen en hoeveel tijd kost het?.......................................................................... xviii Andere informatiebronnen ............................................................................................... xviii

Sectie 1 Methode Inleiding Methode

Hoofdstuk 1-1

Analyse van Ontwerpproces en Product ................................................................................3 Ontwerp van het CAD-systeem..............................................................................................5 Implementatie.........................................................................................................................7

Analyse van Ontwerpproces en Product

Hoofdstuk 2-1

Casebeschrijving Centrale Verwarmigs Installatie (CV) .......................................................2 Analyse van het Verloop van het Ontwerpproces..................................................................3 Analyse van het Product.........................................................................................................4 Eisen / wensen inventariseren ................................................................................................5 Systeem grenzen en Doel van de applicaytie .........................................................................6

Functies en Sub-functies

Hoofdstuk 3-1

Functies in het CV-installatie Systeem ..................................................................................2 Functiemodel Ontwerpen .......................................................................................................3 Functie analyse.......................................................................................................................4 Regels voor Functie analyse...................................................................................................5 Hiërarchisch Functiemodel ....................................................................................................6

Functionele Eenheden

Hoofdstuk 4-1

Functie Attribuut Specificatie (FAS) .....................................................................................2 Functionele Eenheden ............................................................................................................3

Gebruikers Interface

Hoofdstuk 5-1

Overzicht................................................................................................................................1 Algemene Richtlijnen.............................................................................................................2 Voorbeeld CV-installatie .......................................................................................................4

v

Inhoudsopgave

Onderdelen Bibliotheek

Hoofdstuk 6-1

ElementKlassenmodel ........................................................................................................... 2 Opslagnormen ....................................................................................................................... 5 Opslagnormen CV-installatie Applicatie............................................................................... 6 Symboolelementen ................................................................................................................ 7 Macro’s.................................................................................................................................. 9

Programma Ontwerp

Hoofdstuk 7-1

Ontwerp................................................................................................................................. 2 Programma Hiërarchie........................................................................................................... 3 Programma Definities............................................................................................................ 4 Selectie- en Constructieprogramma’s.................................................................................... 7 Voorbeeld CV-installatie Case .............................................................................................. 8

Implementatie

Hoofdstuk 8-1

Sectie 2 Visual Basic Visual Basic Inleiding

Hoofdstuk 1-1

Inleiding Visual Basic Design Environment

Hoofdstuk 9-1

Starting Visual Basic ............................................................................................................. 2 Starting and Loading Projects ............................................................................................... 3 The Parts of the Visual Basic Window.................................................................................. 4 The Code Window ................................................................................................................ 6 Menus and the Toolbar.......................................................................................................... 7

Creating a Project

Hoofdstuk 10-1

Three Programming Steps ..................................................................................................... 2 Step 1: Creating the User Interface ....................................................................................... 2 Adding the Program Source Code......................................................................................... 5 Creating Your Program's Executable File ............................................................................. 7

Variables

Hoofdstuk 11-1

Programs and Input/Output ................................................................................................... 2 Variables and Input ............................................................................................................... 3 Declaring Variables............................................................................................................... 5 Variable types........................................................................................................................ 7 Labeling Your Text Boxes .................................................................................................... 8 Example with Input and Output ............................................................................................ 9

Strings

Hoofdstuk 12-1

Joining Strings....................................................................................................................... 2 The Length of a String .......................................................................................................... 2 Extracting a Substring ........................................................................................................... 4 Finding Substrings................................................................................................................. 6 Changing Case....................................................................................................................... 8

vi

Inhoudsopgave Converting Numbers to Strings..............................................................................................9

Control Statements

Hoofdstuk 13-1

Program Flow and Branching ................................................................................................2 The If /Then Statement...........................................................................................................2 The Select Case statement......................................................................................................5 The For/Next Loop.................................................................................................................6 The Do, While, and Until Loop .............................................................................................8

File Input / Output

Hoofdstuk 14-1

Steps in Accessing a File........................................................................................................2 Opening a File........................................................................................................................2 Saving Data to the File...........................................................................................................3 Closing the File ......................................................................................................................3 Trying It Out ..........................................................................................................................4 Loading Data from a File .......................................................................................................5 Appending Data to a File .......................................................................................................6

Procedures and Functions

Hoofdstuk 15-1

Top-Down Approach to Programming ..................................................................................2 Using Procedures ...................................................................................................................3 Variable Scope .......................................................................................................................5 Using Functions .....................................................................................................................7

Objects and Controls

Hoofdstuk 16-1

Objects, Methods, Properties and Events...............................................................................2 User defined types..................................................................................................................3 CheckBox Controls ................................................................................................................4 OptionButton Controls ...........................................................................................................7 List Controls...........................................................................................................................9

Sectie 3 SolidWorks API API Inleiding Design Tables

Hoofdstuk 17-1

Dimensies hernoemen ............................................................................................................2 Design Tables aanmaken........................................................................................................3 Invoegen Design Tables.........................................................................................................3 Design tables aanpassen.........................................................................................................5

Macro's en API Help

Hoofdstuk 18-1

Opnemen en afspelen van Macro's.........................................................................................2 API Documentatie..................................................................................................................4

vii

Inhoudsopgave

Sketching

Hoofdstuk 19-1

Open a Visual Basic Project.................................................................................................. 2 Uitleg Programma Structuur.................................................................................................. 3 Eerste Run Programma.......................................................................................................... 5 Uitbreiden van het Programma.............................................................................................. 6 Test van het Programma........................................................................................................ 9

Besturing van Dimensies

Hoofdstuk 20-1

Openen Bestaande Documenten............................................................................................ 2 Uitleg Programma Structuur.................................................................................................. 2 Runnen van het programma .................................................................................................. 4 Opnemen van Excel Sheet in SolidWorks Part ..................................................................... 5 Opnemen van Solidworks Part in Excel Sheet ...................................................................... 5

Selecties behandelen

Hoofdstuk 21-1

Open Visual Basic Project..................................................................................................... 2 Eerste Run Programma.......................................................................................................... 3 Uitleg Programma Structuur.................................................................................................. 4 Aanpassen van de Basis Code ............................................................................................... 7 Testen van het Programma .................................................................................................. 10

Uitvoeren van Selecties

Hoofdstuk 22-1

Openen Visual Basic Project................................................................................................. 2 Eerste Run Programma.......................................................................................................... 3 Uitleg Programma Structuur.................................................................................................. 3 Implementatie SuppressFeatures Part.................................................................................... 6 Totale Programma ................................................................................................................. 9

Attributen creëren en opvragen

Hoofdstuk 23-1

Openen Bestaande Project..................................................................................................... 2 Eerste Run Programma.......................................................................................................... 2 Uitwerking Programma Frame .............................................................................................. 3 Form Form1........................................................................................................................... 4 Form AttrFrm ........................................................................................................................ 6 Implementatie Form1 ............................................................................................................ 7 Implementatie AttrFrm.......................................................................................................... 9

Attributen verzamelen

Hoofdstuk 24-1

Openen Bestaande Project..................................................................................................... 2 Toevoegen extra Command button ....................................................................................... 2 Implementatie Private Sub SummaryBtn_Click() ................................................................. 3

Creëren van een Assembly

Hoofdstuk 25-1

Open Visual Basic Project..................................................................................................... 2 Uitleg Programma Structuur.................................................................................................. 3 Macro Opnemen .................................................................................................................... 5 Aanpassen van de Basis Code ............................................................................................... 6

Configureren van een Assembly

Hoofdstuk 26-1

Aanmaken Design Tables...................................................................................................... 2 Aanpassen BuildAssembly.................................................................................................... 3

Assembly traversal

Hoofdstuk 27-1

Open Bestaand Document ..................................................................................................... 2

viii

Inhoudsopgave Structuur aanwezige module1 ................................................................................................2 Toevoegen extra code ............................................................................................................4 Test Run .................................................................................................................................6

Tekeningen creëren

Hoofdstuk 28-1

Uitleg Programma Code.........................................................................................................2 Aanpassen van de Basis Code................................................................................................4 The proof of the pudding is in the eating ...............................................................................8

Topology traversal

Hoofdstuk 29-1

Open Bestaand Document......................................................................................................2 Aanwezige Programma Code.................................................................................................2 Aanvulling Programma Code.................................................................................................4 Test het programma................................................................................................................6

APPENDICES Visual Basic Syntax

Appendix A-1

ix

Preface

SolidWorks is het modelleer programma dat bij de Faculteit CTW van de Universiteit Twente is gekozen als standaard gereedschap bij alle ontwerp activiteiten en voor het CAD/CAM onderwijs. Met deze software kunt u drie-dimensionale vormen vastleggen, er verschillende analyses op los laten en er de bijbehorende tekeningen van genereren. Nieuwe gebruikers kunnen er, dankzij een intuïtieve gebruikers interface, in korte tijd mee leren werken. Deze handleiding (deel IV) beschrijft een methode om een CAD-systeem te voorzien van een uitbreiding, een zogenaamde CAD-applicatie. Door een systeem aan te passen aan de specifieke situatie kan een ontwerpproces (gedeeltelijk) worden geautomatiseerd. De beschreven methode kent drie hoofdactiviteiten: de analyse van ontwerpproces en product, het ontwerp van de applicatie en de realisatie. De eerste twee hoofdactiviteiten zijn CAD-systeem onafhankelijk en kunnen dus voor iedere software-omgeving worden gebruikt. De laatste activiteit, de realisatie, is dat niet. In deze handleiding wordt de realisatie beschreven voor de SolidWorks CAD-software, in combinatie met een de Microsoft Visual Basic programmeer omgeving. Er is gebruik gemaakt van materiaal dat beschikbaar is gesteld door SolidWorks Corporation en van ingeleverde opdrachten van talloze studenten. Waarvoor dank. HT.

xi

Preface

Hoe is het opgebouwd: welke delen De serie handleidingen over SolidWorks bevat vier delen. In één (werktuigbouw-) studiejaar wordt telkens één deel behandeld. Eerder in uw studie heeft u gewerkt met de delen I , II , en afhankelijk van uw vakken pakket met deel III .

CAD/CAM Handleiding SolidWorks, Deel I In het eerste deel wordt de stof behandeld die voor een kennismaking met Solid Modelling nodig is. Er wordt uitgelegd wat solid modelling is. U leert eenvoudige onderdelen modelleren en er de tekeningen van genereren. Er komen er een aantal technieken aan de orde om samenstellingen te maken en u leert hoe u een foto-realistische afbeelding kunt maken. • Modelleren van onderdelen (2.5 D) • Maken van tekeningen • Gebruiken van een bibliotheek met onderdelen • Modelleren van samenstellingen • Maken van een samenstelling vanuit een ontwerpschets • Foto-realistische afbeeldingen (PhotoWorks)

CAD/CAM Handleiding SolidWorks, Deel II In het tweede deel worden een aantal onderwerpen toegevoegd die aan de order komen in het 2e jaar, met name in het project Consumentenproducten. Hiermee wordt erg goed geïllustreerd wat de toegevoegde waarde is van dit soort programma’s. Behandeld worden onder andere het modelleren van complexe oppervlakken (een grote vormgevingsvrijheid) en een breed scala van analyse gereedschappen die goed zijn geïntegreerd in SolidWorks. • Modelleren van dunwandige producten • Modelleren van complexe oppervlakken • Ontwerpen van een matrijs (R&B MoldWorks) • Animatie van het assemblage proces (SolidWorks Animator) • Spuitgiet-simulatie software (3D QuickFill)

CAD/CAM Handleiding SolidWorks, Deel III (gepland) In het derde deel komen allerlei specifieke CAD/CAM onderwerpen aan de orde, zoals interfacing naar andere CAD-systemen, werkvoorbereidingssytemen en de koppeling naar Rapid-prototyping tools. • Bill Of Materials • Interfacing naar o.a. CAM-, PDM-, ERP-systemen • Analyse tool voor stijfheid & sterkte (Design Space) • Werkvoorbereidingssoftware (CAMWorks)

CAD/CAM Handleiding SolidWorks, Deel IV In het vierde deel komt Applicatie bouw aan de orde. Dit is een onderdeel van het vak CAD/CAM waarin wordt uitgelegd hoe u zelf software kunt ontwikkelen en aan een CADprogramma kunt toevoegen. Voor iedere fase in de ontwikkeling van een dergelijke uitbreiding wordt een stuk theorie behandeld en geïllustreerd aan de hand van een voorbeeld. Uiteindelijk ontwikkelt u zelf (in teamverband) een bepaalde toepassing. • Analyse van het ontwerpproces • Ontwerpen van applicaties • Programmeren in een object georiënteerde omgeving • Microsoft Visual Basic • Gebruik van de SolidWorks API

xii

Preface

Beoogde gebruikers Deze handleiding is geschikt voor iedereen die de functionaliteit van een CAD-systeem wil uitbreiden: met name het ontwikkelen van software voor het programma SolidWorks zal uitgebreid aan de orde komen. Enige vaardigheid in het gebruik van SolidWorks, enige vaardigheid in het programmeren en kennis van de Engelse taal worden verondersteld.

Benodigde voorkennis Het grootste deel van deze handleiding is geschreven in de Nederlandse taal. Voor de sectie over Visual Basic (hoofdstuk 9 t/m 16) is de Engelse taal gebruikt. De overweging hiervoor is dat Engels een betere aansluiting geeft op de terminologie die bij softwareontwikkeling wordt gebruikt en op de documentatie over Visual Basic die op de computer beschikbaar is. Er wordt verondersteld dat u vaardigheid heeft in het gebruik van SolidWorks op het niveau dat wordt bereikt bij het doorlopen van de oefeningen in Handleiding SolidWorks deel I. Uitgebreide computerkennis is niet vereist, maar enige vaardigheid in het ontwikkelen van (kleine) programma’s wordt wel verondersteld. Wanneer u deze kennis niet heeft, kunt u literatuur bestuderen die een inleiding over programmeren geeft. Aan het eind van deze inleiding vindt u hiervoor een aantal suggesties.

xiii

Preface

Structuur van deze handleiding Deze handleiding bestaat uit drie secties. In de eerste wordt de methode voor het bouwen van een applicatie behandeld. De tweede sectie geeft een introductie in het gebruik van de programmeer taal Visual Basic. De derde sectie behandelt de SolidWorks API: de Application Program Interface. De laatste twee secties zijn geschreven in een tutorial vorm, door doen krijgt u de ervaring. Verder is er nog een Appendix.

Methode De sectie Methode beslaat de hoofdstukken 1 t/m 8. Hierin wordt de methode voor het bouwen van een CAD-applicatie beschreven met daarin de hoofdactiviteiten analyse, ontwerp en realisatie. Ieder hoofdstuk behandelt één stap van het ontwikkelproces.

Hoofdstuk 1, Inleiding Methode In dit hoofdstuk wordt een overzicht gegeven van de activiteiten die achtereenvolgens doorlopen dienen te worden voor het bouwen van een CAD-applicatie.

Hoofdstuk 2, Analyse Ontwerpproces en Produkt In dit hoofdstuk komen de analyse van ontwerpproces- en produkt aan de orde. Aan de hand van een voorbeeld (CV-installatiesysteem) wordt het een en ander verduidelijkt.

Hoofdstuk 3, Functies en Subfuncties Het derde hoofdstuk behandelt het opstellen van het functiemodel, een hiërarchische boomstructuur van functies en subfuncties in het product. Er wordt aandacht besteed aan het opstellen van functies en de bijbehorende subfuncties.

Hoofdstuk 4, Functionele Eenheden Het inventariseren van de functionele eenheden met hun kenmerken. Tevens worden eisen ten aanzien van de functies vastgelegd in FAS-diagrammen.

Hoofdstuk 5, Gebruikers Interface Opstellen van het gebruikers-interactiemodel oftewel, in wat voor termen de gebruiker de reacties van de applicatie gepresenteerd krijgt. Er wordt vastgelegd hoe de gebruiker (de ontwerper) de objecten (functionele eenheden) kan manipuleren om tot een eindproduct (een ontwerp) te komen dat aan de eisen voldoet.

Hoofdstuk 6, Onderdelen Bibliotheek Dit hoofdstuk behandelt het vastleggen van de onderdelenbibliotheek. De componenten die hierin staan vormen de bouwstenen voor het ontwerpsysteem.

Hoofdstuk 7, Programma Ontwerp In deze stap worden programma’s gedefinieerd en ontworpen. In een Windows omgeving heeft ieder menu-commando en iedere dialoog zijn eigen procedures. Per programma of procedure wordt vastgelegd welke gegevens er in gaan, welke gegevens eruit komen en hoe het probleem wordt opgelost.

Hoofdstuk 8, Implementatie Realisering van de gebruikersinterface in Visual Basic, vertaling van programma-ontwerp naar programma’s. Het maken van symbolen en onderdelen gebeurt waarschijnlijk met SolidWorks.

xiv

Preface

Visual Basic Deze sectie behandelt de Microsoft Visual Basic programmeeromgeving en de belangrijkste eigenschappen van die taal. Ieder hoofdstuk heeft een korte inleiding van het onderwerp. Daarna volgt er een voorbeeld in tutorial vorm: u maakt zelf een programma. Tot slot volgt een beknopte opsomming van de mogelijkheden.

Hoofdstuk 9, Visual Basic Design Environment Een kennismaking met de software ontwikkelomgeving. Uitgelegd wordt hoe het programma wordt gestart en wat er zoal op het scherm is te zien.

Hoofdstuk 10, Creating a Project Hierin start u een nieuw project, voegt code toe en creëert een eerste executable.

Hoofdstuk 11, Variabels Het declareren van variabelen, de verschillende data typen en de bijbehorende operatoren.

Hoofdstuk 12, Strings Het datatype string wordt gebruikt om karakters op te slaan. In dit hoofdstuk wordt uitgelegd hoe ze gebruikt kunnen worden.

Hoofdstuk 13, Control Statements In dit hoofdstuk wordt verteld hoe in een programma beslissingen kunnen worden genomen en hoe stukken code kunnen worden herhaald.

Hoofdstuk 14, File Input/Output Hierin wordt gewerkt met een eenvoudig programma dat een bestand opent, er gegevens in schrijft en vervolgens het bestand sluit.

Hoofdstuk 15, Procedures and Functions Een belangrijk hoofdstuk om gestructureerde software te kunnen ontwikkelen: het gebruik van procedures en functies.

Hoofdstuk 16, Objects and Controls Meer informatie over objecten en object-georiënteerd programmeren. Verder wordt het gebruik van een aantal elementen uitgelegd die voor het bouwen van een user-interface van pas komen: check boxes, option buttons en de list box.

xv

Preface

SolidWorks API Deze sectie behandelt het gebruik van de SolidWorks Application Program Interface (API). De API is de verbinding tussen uw programma en het SolidWorks systeem. Het wordt gevormd door een (groot) aantal data-types en proceduredefinities. Ieder hoofdstuk behandelt een aspect aan de hand van een opdracht. Bijvoorbeeld het werken met attributen of het verwerken van items die door de gebruiker zijn geselecteerd.

Hoofdstuk 17, Design Tables Alle afmetingen van onderdelen worden in SolidWorks bepaald door parameters. Design Tables geven de mogelijkheid verschillende configuraties te bouwen van onderdelen of assemblies door zogenaamde driving parameterwaarden in te lezen uit een Microsoft Excel spreadsheet.

Hoofdstuk 18, Macro’s en API Help In dit hoofdstuk wordt een inleiding gegeven over het gebruik van de SolidWorks macro faciliteiten. De macro taal van SolidWorks is (niet toevallig) dezelfde als de API programmeertaal: Visual Basic. Met behulp van voorbeelden wordt uitgelegd hoe u macro’s kunt opnemen en afspelen. Tegelijk maakt u kennis met eenvoudige Basic programma’s die via API-aanroepen opdrachten aan SWorks geven.

Hoofdstuk 19, Sketching Hier wordt stap voor stap het eerste ‘echte’ Visual Basic programma gebouwd. Er wordt een programma gemaakt waarmee ruwheidssymbolen aan een tekening kunnen worden toegevoegd.

Hoofdstuk 20, Besturing van Dimensies In dit hoofdstuk wordt een voorbeeld behandeld van het werken met onderdelen familie’s. Uit één tekening en een tabel met parameter waarden wordt een familie van parts gegenereerd. De tabel is een Excel spreadsheet, de celwaarden besturen de dimensies van het onderdeel.

Hoofdstuk 21, Selecties behandelen Het komt regelmatig voor, dat er een aantal handelingen moeten worden toegepast op een set onderdelen die door de gebruiker zijn geselecteerd. In dit hoofdstuk wordt stap voor stap aangegeven hoe u toegang krijgt tot een set geselecteerde vlakken en hoe de materiaaleigenschappen zoals kleur en transparancy van deze oppervlakken gewijzigd kunnen worden.

Hoofdstuk 22, Uitvoeren van Selecties Dit hoofdstuk legt uit hoe onderdelen van het ontwerp door het programma kunnen worden herkend en geselecteerd. Met het gebruikte voorbeeld programma kunnen naar keuze featuretypes worden suppressed en unsuppressed.

Hoofdstuk 23, Attributen creeren en opvragen In Solidworks kunnen gegevens worden toegevoegd aan het model. Dit wordt gedaan met attributen. Eerst wordt een attribuut type gedefinieerd, daarna wordt het aan een feature toegekend, vervolgens kunnen er attribuut waarden in worden gezet. Het voorbeeld laat zien hoe attributen aan een Face kunnen worden gekoppeld, gewijzigd en opgevraagd.

Hoofdstuk 24, Attributen verzamelen Het tweede hoofdstuk over attributen behandelt het verzamelen van gegevens uit de part. Het programma uit het vorige hoofdstuk wordt hiervoor verder ontwikkeld.

xvi

Preface

Hoofdstuk 25, Creëren van een Assembly Het komt voor dat assemblies opgebouwd worden uit een variabel aantal standaard delen. Hier wordt een voorbeeld behandeld dat een nieuwe assembly aanmaakt vanuit configuratie gegevens in een Excel spreadsheet. Aan de orde komen het toevoegen en plaatsen van onderdelen in een assembly.

Hoofdstuk 26, Configureren van een Assembly In deze oefening breiden we het programma uit het vorige hoofdstuk uit. In plaats van een groot aantal kopieën van onderdelen, wordt gebruik gemaakt van we design tables en configuraties.

Hoofdstuk 27, Assembly traversal Deze oefening is gericht op het vergaren van component informatie uit een assembly door het doorlopen van de datastructuur (traversal). De oefening is wordt uitgevoerd vanuit een Excel sheet. Er wordt een lijst gemaakt van alle componenten en het aantal keer dat ze in de assembly voorkomen.

Hoofdstuk 28, Tekeningen creëren Het kan wenselijk zijn om van een onderdeel in een bepaalde view een tekening te hebben, waarin attribuut waarden van vlakken worden weergegeven als notes bij die betreffende vlakken. Er wordt een Visual Basic programma ontwikkeld dat dit automatisch voor u doet.

Hoofdstuk 29, Topology traversal In het programma van hoofdstuk 24, Attributen verzamelen, is duidelijk geworden hoe alle faces van een part kunnen worden benaderd. In deze opdracht benaderen we ook andere geometrie. De complete topologie wordt gescand (traversal) om de verschillende loops en edges van faces te beoordelen. In deze oefening wordt het aantal gaten in een vlak geteld..

Appendices Achter in de handleiding kunt u een overzicht van de belangrijkste Visual Basic commando’s vinden.

Appendix A, Visual Basic Lijst met van de belangrijkste syntax, commando’s en systeemfuncties.

xvii

Preface

Benodigdheden Voor het uitvoeren van de oefeningen in deze handleiding heeft u nodig: • Een PC waarop is geïnstalleerd: • SolidWorks, • SolidWorks online User’s guide en API Help files, • Microsoft Visual Basic 6.0, • Microsoft Developer Network (de MSDN Visual Basic online documentatie), • Een aantal oefenbestanden te downloaden vanaf http://www.opm.ctw.utwente.nl/ Klik op Onderwijs, CADCAM, • De handleiding CAD/CAM Handleiding SolidWorks deel I, • Deze handleiding CAD/CAM Handleiding SolidWorks deel IV.

Waar beginnen en hoeveel tijd kost het? SolidWorks is een erg gebruikersvriendelijk programma maar gebruik ervan gaat niet helemaal zonder oefening. Om te kunnen werken met deze handleiding is enige vaardigheid in het bedienen van dit pakket vereist. Deze vaardigheid kunt u opdoen door de opdrachten uit de CAD/CAM handleiding deel I uit te voeren. De hoofdstukken 1 t/m 10 hieruit kosten u ongeveer 10 uur. De eerste sectie van de handleiding behandelt de te hanteren methode voor het ontwerpen van een CAD-applicatie. Alle uit te voeren stappen worden uitgelegd en met voorbeelden verduidelijkt. Ontwerp uw eigen applicatie parallel aan het doorwerken van de eerste 8 hoofdstukken. Benodigde tijd 5 uur. De tweede sectie behandelt de Visual Basic taal en ontwikkelomgeving. Er wordt verondersteld dat u al beschikt over programmeerervaring (b.v. door het volgen van het vak Inleiding Programmeren). Op een beknopte wijze worden de belangrijkste aspecten van deze taal behandeld zodat u er zelf mee aan de slag kunt om eenvoudige programma’s en user-interfaces te ontwikkelen. Het is de bedoeling dat u uw applicatie in deze taal gaat schrijven. Het beslaat de hoofdstukken 9 t/m 16, die vol staan met korte opdrachten. Benodigde tijd 5 uur. Het venijn zit in de staart: de laatste sectie behandelt de SolidWorks API (Application Program Interface). Dit is een (grote) set van procedures die je vanuit je eigen programma kunt aanroepen om SolidWorks iets te vragen of iets te laten doen. Het valt erg tegen om met weinig ervaring programma’s vanuit het ‘niets’ te schrijven. Vandaar dat voor dit complexe onderdeel gewerkt wordt met een groot aantal voorbeeld programma’s. Daarvan zijn telkens twee versies gegeven: het startprogramma dat dient als geraamte voor de ontwikkeling en een werkende eind versie voor wanneer u niet goed uit de opdracht komt, maar toch wilt zien hoe het probleem moet worden opgelost. De voorbeeldprogramma’s behandelen telkens een bepaald type probleem. U kunt een combinatie van deze oplossingen waarschijnlijk goed gebruiken als structuur voor uw eigen applicatie. Benodigde tijd 15 uur.

Andere informatie bronnen • • • • •

xviii

SolidWorks, user’s guide, SolidWorks Corporation Teach Yourself Visual Basic 6, Scott Warner, Osborne Visual Basic 6 in 24 hours, Perry and Hettihewa, SAMS Running Microsoft Windows, Microsoft Corporation CAD/CAM, From principles to practice, Mc Mahon and Browne, Addison Wesley

Methode De sectie Methode beslaat de hoofdstukken 1 t/m 8. Hierin wordt de methode voor het bouwen van een CAD-applicatie beschreven met daarin de hoofdactiviteiten analyse, ontwerp en realisatie. Ieder hoofdstuk behandelt één stap van het ontwikkelproces.

Hoofdstuk 1

Inleiding Methode

Alvorens in te gaan op een systematische methode voor het ontwerpen en bouwen van CAD-applicaties dient het duidelijk te zijn wat onder een CAD-applicatie verstaan wordt. Een CAD-applicatie is een software-systeem (programma) dat tot doel heeft een ontwerpproces of een deel van een ontwerpproces te ondersteunen. In het dagelijkse spraakgebruik wordt gesproken van een CAD-systeem. Een CAD-systeem is een combinatie van computerapparatuur (hardware) met standaard- en speciaal ontwikkelde CAD-software. Een voor de hand liggend voorbeeld van CAD is een systeem waarmee het mogelijk is om werktuigbouwkundige tekeningen te maken (voorbeelden zijn AutoCAD, Vellum of SolidWorks). In dit geval beperkt de ondersteuning zich tot de detailleringsfase van het ontwerpproces, waarin het definitieve ontwerp vastgelegd wordt in werkplaatstekeningen. Maar ook in andere fasen van het ontwerpproces kunnen CAD-systemen ingezet worden. Bijvoorbeeld een systeem waarmee producten kunnen worden geconfigureerd, een systeem dat het voorontwerp van schepen of vliegtuigen ondersteunt, of een systeem om schema's van procesinstallaties te ontwerpen (tekenen): Proces and Instrumentation Diagrams (PID). Een belangrijk aspect bij het invoeren van een CAD-applicatie is o.a. de herhalingsgraad van het product. De herhalingsgraad heeft te maken met de mate waarin het product / systeem "nieuw" is voor de onderneming: • Bij een nieuw ontwerp moeten alle ontwerpstappen worden doorlopen. • Voor een aanpassingsontwerp (onderhoud, renovatie) is zowel de functie als de principe-oplossing bekend, deze kunnen gehandhaafd blijven. De structuur van bestaande producten behoeft slechts aangepast te worden aan het nieuwe eisenpakket. • Bij een variantontwerp wordt gebruik gemaakt van reeds eerder ontworpen en gestandaardiseerde modules. Dit betreft zowel productmodules als ontwerpnormen en ontwerpregels. Door selectie van de juiste modules kan een nieuw product / systeem worden samengesteld en dimensies worden ingevuld. Door modulebouw wordt de herhalingsgraad per (deel)product / systeem groter. Het gaat steeds nadrukkelijk om het ondersteunen van het ontwerpproces, niet om het compleet automatiseren ervan. Dit betekent dat de ontwerper op essentiële momenten beslissingen moet kunnen blijven nemen en dat de ontwerper het ontwerpproces moet kunnen besturen. De acceptatie van een CAD-applicatie staat of valt met de mate waarin de ontwerper werkelijk gesteund wordt bij zijn ontwerpproces. Als eerste stap bij het ontwerpen en bouwen van een CAD-systeem is het noodzakelijk om het betreffende ontwerpproces (van producten) grondig te analyseren. Pas als er een bruikbare beschrijving van het ontwerpproces is, kunnen we gaan kijken hoever we voor dit ontwerpproces een ondersteunend CAD-systeem kunnen bouwen. Om het gehele traject succesvol te doorlopen is het noodzakelijk gebleken: • de complexiteit van de te bouwen applicatie af te breken in beheersbare (overzienbare) delen en functies, • top-down te analyseren en bottom-up te bouwen, • de applicatie systematisch en stapsgewijs te ontwerpen, te bouwen, te onderhouden en bij te stellen.

1-1

Hoofdstuk 1, Inleiding Methode In het gehele proces van ontwikkelen van een CAD-applicatie zijn drie hoofdactiviteiten te onderscheiden: • analyse van het te ontwerpen product en te ondersteunen ontwerpproces, • ontwerp van de CAD-applicatie, gebaseerd op de vorige activiteit, • bouw (programmering) en implementatie van het CAD-systeem. De hiervoor aangegeven drie hoofdactiviteiten staan ook in het volgende schema. Ieder hoofdactiviteit is op te splitsen in een aantal deelactiviteiten (stappen). Ieder deelactiviteit wordt afgesloten met een duidelijk resultaat. In de volgende paragrafen wordt het schema stap voor stap besproken.

Stappenplan Hoofdactiviteit Analyse van Ontwerpproces en Product

Ontwerp van het CAD-systeem

Activiteit Stap 1 Analyse verloop van het ontwerpproces Inventariseer eisen en wensen

Hiërarchisch functiemodel

Stap 3 Functie eisen opstellen Functionele eenheden met kenmerken vaststellen

FAS Functionele eenheden met kenmerken

Stap 4 Gebruikers interface ontwerpen

Stap 6 Programma’s ontwerpen Stap 7 Symbolen invoeren (geparametriseerde) Onderdelen invoeren Stap 8 Gebruikers interface bouwen Programmering Stap 9 Documentatie complementeren

Analyse van Ontwerpproces en Product 1-2

Ontwerpproces Product beschrijving Systeem grenzen en Doel

Stap 2 Functies en sub-functies van het product opstellen

Stap 5 Onderdelen bibliotheek ontwerpen

Implementatie

Resultaat

Menu en Dialoog ontwerp Gebruikers handleiding Elementklassenmodel Opslagnormen Definities van Symbolen, Geometrische macro’s, Geparametriseerde onderdelen Programma hiërarchie Programma definities Symbolen Geometrische macro’s Geparametriseerde onderdelen Menu’s Forms Programma's Documentatie Gebruikershandleiding

Hoofdstuk 1, Inleiding Methode

De activiteiten ten aanzien van de analyse van het te ondersteunen ontwerpproces zijn op te delen in een aantal stappen: 1 Analyse van het verloop van het ontwerpproces, analyse van het in dit proces te ontwerpen, dimensioneren of te configureren product. 2 Hoofdfunctie(s) van het product uiteen rafelen in functies en sub-functies tot een hiërarchisch functiemodel. 3 Functie eisen per sub-functies concretiseren in een FAS en de verschijningsvormen van de oplossingen vastleggen in functionele eenheden. In stap 1 gaat het om het vastleggen van drie dingen: •

•

•

het verloop van het ontwerpproces (handmatig en vervolgens computerondersteund) in beschrijfbare stappen die, wanneer het proces doorlopen wordt, een goed productontwerp opleveren. Hier moet dus duidelijk worden met welk type ontwerpproces we te maken hebben: in het algemeen zal het product opgebouwd worden uit standaard elementen en eventuele varianten daarop. Het "ontwerpproces" heeft in dit geval niet betrekking op het concipiëren van geheel nieuwe dingen, maar op het samenstellen, dimensioneren en configureren van (samengestelde) producten of productsystemen op basis van door een klant aangegeven eisen en wensen, de gang van zaken die binnen een product of productsysteem zorgt voor het juist functioneren van het product / ontwerp. Deze "gang van zaken" wordt vastgelegd door middel van: een eisenprogramma, specificaties en een blokschema. Dit blokschema legt "de gang van zaken" ofwel het procesverloop binnen het productsysteem vast in de vorm van een tijd-functiemodel. Het tijd-functiemodel geeft de samenhang in de tijd van de (hoofd)functies die zorgen dat het systeem "functioneert", Tenslotte moet in stap 1 duidelijk worden waar de systeemgrenzen liggen van de productsystemen die ontworpen moeten kunnen worden (het toepassingsgebied van de ontwerpen). Duidelijk moet ook zijn wat de applicatie gaat doen: wat wordt er geautomatiseerd en welke werkzaamheden blijven er over voor de gebruiker / ontwerper.

1-3

Hoofdstuk 1, Inleiding Methode In stap 2 wordt de productbeschrijving verder uitgewerkt in termen van functies en subfuncties op verschillende hiërarchische niveaus. Een functie beschrijft wat er moet gebeuren en niet hoe of waarmee. De functies worden op een logische manier gerangschikt in een functiemodel, waarvan de volgende figuur een voorbeeld geeft.

Figure 1, Hierarchisch Functie-model

In stap 3 worden de eisen gespecificeerd per (sub)functie. Om uiteindelijk te kunnen komen tot informatie die op een computer te verwerken is, is het nodig om de verschillende functies en sub-functies te beschrijven in termen van kenmerken, in relatie tot het eisenpakket. Het betekent dat hier een begin gemaakt wordt met het opstellen van de zogenaamde Functionele Attribuut Specificatie (FAS). Het FAS is een tabel met kenmerken (attributen) en bijbehorende waarden (soms gegeven, soms nog nader te bepalen of af te leiden in het proces). In het functiemodel zou men aan de functie "doorgang afscheiden" de kenmerken warmteen geluiddoorlaatbaarheid kunnen relateren. (Het werk in deze fase van het analyseproces komt overeen met de activiteiten die men verricht in de probleemdefiniërende fase van het ontwerpproces). Het is noodzakelijk om een functiemodel te maken, zoals hierboven aangegeven, om te kunnen waarborgen dat de functies en functievervullers onafhankelijk van elkaar zijn! Attribuut Afmeting Kleur Geluidsisolatie Prijs

Waarde 880 x 2015 mm RAL 2001 3 dB

Minimum

Maximum

2 205

Ook worden de functievervullers gedocumenteerd. De functie "doorgang afscheiden" in het functiemodel heeft o.a. als functievervuller (mogelijke oplossing) een deur. De verzameling mogelijke functievervullers (ook wel werkwijzen of principe oplossingen), worden beschreven als functionele eenheden. De variaties worden beschreven in termen van kenmerken (b.v. hoogte, breedte, kleur).

1-4


Ontwerp van het CAD-systeem Het ontwerp van het CAD-systeem (niet te verwarren met het ontwerp van het product) is op te delen in drie stappen: 4 Gebruikers interface ontwerpen, 5 Symbolenbibliotheek en / of (geparametriseerde) onderdelen ontwerpen, 6 Programma’s ontwerpen. Stap 4 legt vast hoe de gebruiker met het programma om gaat. Hiervoor wordt de gebruikers interface ontworpen: er wordt vastgelegd hoe de gebruiker (de ontwerper) de objecten (functionele eenheden) kan manipuleren om tot een eindproduct (een ontwerp) te komen dat aan de eisen voldoet. De gebruikers interface wordt beschreven met behulp van menu- en dialoog-ontwerpen en de gebruikershandleiding. Door de handleiding te schrijven voordat met programmeren wordt begonnen, is het bij de ontwikkeling duidelijk hoe de werking van de diverse commando’s en invoervelden zal worden. In stap 5 wordt alle vaste- en variabele geometrie gedefinieerd en in een bibliotheek opgeslagen. Functionele eenheden (oplossingen) die weinig of niet van vorm veranderen worden hier als symbool of standaard onderdeel gedefinieerd. In 2D-tekenapplicaties worden vaak symbolen gebruikt. Deze komen uit een bibliotheek. De bibliotheek is geordend en gecodeerd volgens een elementklassenmodel. Als in een bepaalde branche een uniforme codering is opgezet, moet deze gebruikt worden. Deze uniforme structuren kunnen bijna nooit volledig overgenomen worden, vaak moet men aanpassingen maken. Ook wordt voor de applicatie dikwijls maar een klein deel toegepast. Het opstellen van een eigen elementklassenmodel kan derhalve noodzakelijk blijven. Gewoonlijk worden alle elementen voorzien van een hiërarchische code die afgeleid is uit het elementklassenmodel. De volgende figuur geeft hiervan een voorbeeld.

elementklassenmodel gecodeerd volgens iec-code

1-5

Hoofdstuk 1, Inleiding Methode Voor 3D applicaties zijn geen normen beschikbaar, maar de 3D onderdelenbibliotheken kunnen volgens het zelfde principe worden opgezet. Het zal echter vaker voorkomen dat er gebruikt wordt gemaakt van een beperkte set geparametriseerde onderdelen. Deze worden dan door de applicatie van de juiste parameter-waarden voorzien en in een assembly gezet. Na afronding van stap 5 ligt vast welke objecten (functionele eenheden) met welke gegevens (FAS en variatie kenmerken) in het CAD-systeem gemanipuleerd moeten worden. Stap 6 omvat het ontwerpen van de programma’s. Per menu-commando wordt een programma uitgevoerd. Dit programma kan weer andere (sub)programma’s aan roepen. Deze wie-roept-wie wordt vastgelegd in de programma hiërarchie. Wat ieder (sub)programma doet is gedocumenteerd in de programma definities. Hoe de activiteit wordt verricht is vastgelegd in stroomdiagrammen. De programma hiërarchie, de programma definitie en de stroomdiagrammen beschrijven samen hoe producten (een productsysteem) door programma's (aangestuurd door menu's) worden samengesteld uit deelproducten.

Note De programma hiërarchie vertoont grote gelijkenis met het hiërarchisch functiemodel. De oplossing wordt namelijk volgens deze structuur opgebouwd uit functionele eenheden en / of standaard element. Tot nu toe zijn alle stappen onafhankelijk van de hardware, van de programmeertaal en van de CAD-software.

1-6


Implementatie In de vorige fase is het te bouwen CAD-systeem uitgewerkt in een vorm die computeronafhankelijk is. Dit betekent dat de beschrijving van de door het systeem te verwerken gegevens en de manier waarop dat in interactie met de gebruiker (ontwerper) gebeurt niet afhankelijk zijn van de ter beschikking staande of aan te schaffen onderliggende (basis)systeem. Met het onderliggende (basis)systeem wordt bedoeld de hardware en de basis-software als bijvoorbeeld een tekensysteem, een (grafische) programmeertaal en een databasesysteem. Het onderliggende basissysteem heeft bepaalde eigenschappen (mogelijkheden en onmogelijkheden) die het noodzakelijk maken het ontwerp van de CAD-applicatie aan te passen aan de basissoftware. Alfanumerieke en grafische informatie kan in het systeem worden geïntegreerd door het gebruik van attributen. Hierdoor kan alle relevante informatie als één object worden gemanipuleerd. De volgende werkzaamheden moeten nu worden uitgevoerd om de applicatie te realiseren. Stap 7 Symbolen invoeren, (geparametriseerde) onderdelen invoeren. Alle vaste geometrie en geparametriseerde geometrie wordt in het CAD-systeem aangemaakt en opgeslagen in een bibliotheek. Stap 8 Gebruikers interface bouwen en programmering. De menu’s en dialoog vensters worden gedefinieerd met behulp van een programmeer-tool, in ons geval Visual Basic. Hiermee worden ook de programma’s gebouwd. Stap 9 Documentatie complementeren. De programmadocumentatie moet worden samengesteld. De documentatie die in de vorige analyse- en ontwerp fasen stappen is gemaakt kan gebundeld worden tot een beschrijving van het ontwikkelde systeem. De gebruikershandleiding is gedeeltelijk al gemaakt in stap 4. De ontbrekende onderdelen moeten hieraan worden toegevoegd. Onder de gebruikersdocumentatie vallen vier onderdelen: • installatie handleiding, • tutorial, een voorbeeldsessie die op eenvoudige wijze verklaart hoe met het systeem om te gaan, • een referentie-handleiding: hierin staat tot in detail beschreven welke faciliteiten beschikbaar zijn en hoe ze gebruikt moeten worden, • gebruikershandleiding, waarin wordt uiteengezet hoe de bediener moet reageren op situaties die tijdens het gebruik van het systeem optreden. Afhankelijk van de grootte van het systeem worden de documenten apart afgeleverd of samengebundeld tot één boekwerk.

1-7

Hoofdstuk 2


Overzicht Hoofdactiviteit

Activiteit

Resultaat


Stap 1 Analyse verloop van het ontwerpproces Inventariseer eisen en wensen

Ontwerpproces Product beschrijving Systeem grenzen en Doel

Activiteit Dit hoofdstuk behandelt de eerste stap uit het stappenplan. Het betreft twee globale taken: analyse van het ontwerpproces en het inventariseren van gebruikerseisen. Ook wordt het product zelf globaal geanalyseerd. De resultaten uit deze analyse worden ook gebruikt om de systeemgrenzen aan te geven en het doel van de applicatie te formuleren. Deze stap wordt toegelicht aan de hand van een case (hydraulische cilinder).

Resultaat Een beschrijving van de ontwerpactiviteiten die nodig zijn om tot een ontwerp te komen (het ontwerpproces), een globale productbeschrijving en het doel van de te bouwen applicatie (wat er wordt geautomatiseerd, ofwel welk deel van de ontwerptaak door de computer verricht wordt). Wat er wel- en wat er niet wordt geautomatiseerd is vastgelegd in de systeemgrenzen.

2-1

Hoofdstuk 2, Analyse van Ontwerpproces en Product

Casebeschrijving Centrale Verwarmings Installatie (CV) Hiernaast staat de beschrijving van een situatie waarvoor een applicatie gebouwd moet worden. Dezelfde case wordt ook verder in de handleiding gebruikt. De complete beschrijving is opgenomen in bijlage C.

De firma Gaspiepe B.V. is een bedrijf dat installaties voor centrale verwarming, airconditioning en warmwatervoorzieningen ontwerpt, installeert en onderhoudt. Hun systemen worden toegepast in de grotere woningen en utiliteitsgebouwen, zoals kantoren en fabrieken. In de huidige situatie worden de installaties ontworpen met behulp van het Vellum systeem waarbij alle componenten afzonderlijk getekend worden. Als warmtebron hanteert men een voorkeursreeks van drie keteltypen. Wanneer één ketel onvoldoende capaciteit heeft, schakelt men een aantal ketels parallel. In één installatie worden altijd identieke ketels geplaatst. Het betreft een typische variant ontwerp: het aantal vrijheidsgraden is beperkt, de installatie wordt grotendeels samengesteld uit een set standaard componenten. Omdat dit soort ontwerpen zich goed leent voor automatisering, heeft de directie besloten een CADapplicatie te laten bouwen t.b.v. het CV-schema. Men denkt door middel van deze automatisering te komen tot: • een verdergaande standaardisering, door de ontwerper een aantal standaard regelkringen aan te bieden ten behoeve van de temperatuurbeheersing, • een automatische ketelconfiguratie, waarbij de gebruiker de totale capaciteit op geeft en het systeem automatisch het type en aantal ketels bepaalt, • een grote reductie in ontwerptijd die echter niet ten koste van de flexibiliteit mag gaan. schema van een CV

PI

ketel

1

ketel

N20

V1-

G1

G4

G2

G3

G4

2

1

V1-

TIC

M

2 TI

M

TA

tapwate r

TIC

R1-

TIC

M

1

G1

2-2

G3

N20

TI

installatie

G2


Analyse van het Verloop van het Ontwerpproces De complete beschrijving van de CV-installatie case is opgenomen in bijlage C.

De analyse dient om het doel van de CAD-applicatie te bepalen. De analyse bestaat uit het beschouwen van de gang van zaken omtrent het tot stand komen van het ontwerp van de CV installatie (zie case).

Voorbeeld CV-installatie Case eisen klant m.b.t. apparatuur in Bepaalde ruimtes

definieren van de geschematiseerde ruimtes kiezenvoor standaard Configuraties m.b.t. apparatuur

bepalen van de benodigde aansluitingen kiezen voor aansluiten bepaalde Ruimtes op groepen bepalen van de benodigde capaciteit

bepalen van de ketelconfiguratie

genereer het installatieschema

Resultaat van analyse (Case CV)

2-3


Analyse van het Produkt Vastleggen van kenmerken en eisen (van de hoofdfunctie) van het ontwerp.

Voorbeeld CV-installatie Case Kenmerken •

Ketels: ketel Viking-3 Viking-5 Viking-6

Type N16 N20 N24

Capaciteit 16 kW 20 kW 24 kW

•

Door middel van een of meerdere pompen moeten de volgende apparaten op de ketels aangesloten kunnen worden: radiator, vloerverwarming, luchtverwarming, warmtewisselaar.

•

Er kan een expansievat in de kring worden opgenomen.

•

De apparaten moeten handbediend en/of temperatuurgestuurd of zonder besturing uitgevoerd kunnen worden.

Eisen •

De leidingen worden, afhankelijk van hun functie, in verschillende lagen geplaatst. Alle andere componenten worden in laag 0 geplaatst. Leiding CV-aanvoer CV-afvoer Besturing

•

2-4

Layer PP4 PP5 PP6

color red red blue

In één installatie worden altijd identieke ketels geplaatst

linepattern outline hidden dashed


Eisen / wensen inventariseren Iedere CAD-applicatie dient gebaseerd te worden op een aantal uitgangspunten c.q. eisen en wensen van de gebruiker welke kunnen leiden tot een doelformulering. Binnen de geformuleerde doelen dient men na te gaan welke daarvan de primaire doelen vormen. Zo kunnen meerdere gebruikers van de te ontwikkelen applicatie hun eisen en wensen hebben waarvan deels dezelfde. Meestal worden meerdere eisen en wensen weer door een doel ondersteund, zie onderstaande figuur.

inventarisering eisen / wensen

Probleembeschrijving De eerstvolgende stap is het uitvoeren van een probleemanalyse. Het is hierbij de kunst en taak van de analist om ervoor te zorgen dat de gewenste eindresultaten vastgelegd worden. Wanneer deze inventarisatie van eisen en wensen overgeslagen wordt, moeten we vaak de analyse baseren op wat vage omschrijvingen en gegevens. Soms wordt een oplossing aangeboden. Zowel de vage aanduiding als de specifieke oplossing dient nader onderzocht te worden. In beide gevallen moet namelijk de vraag gesteld worden voor welke problemen men dan wel een oplossing wenst. De gebruiker is bij de inventarisatie sterk betrokken. Als deze gebruiker, met verantwoordelijkheid voor de probleemstelling, niet gevonden kan worden is een inventarisatie zinloos. De gebruiker moet immers met het "ontwerpsysteem" (CADapplicatie) werken. Gebruikers hebben dus recht om hun eigen problemen te beschrijven in hun specifieke termen. Het is niet aan te raden om de probleeminventarisatie alleen in een automatiserings- of projectgroep uit te voeren. De analist stelt de probleemformulering vast in eventuele individuele gesprekken met de gebruikers! Over het aantal eisen en wensen en de mogelijke relevantie ervan wordt niet ingegaan. Ze worden op schrift gesteld zonder selectie toe te passen. Een te vroege selectie doet geen recht aan de gebruiker en ontneemt het management een mogelijkheid bij de prioriteitsstelling.

2-5

Hoofdstuk 2, Analyse van Ontwerpproces en Product Samenvattend bestaat een goede probleembeschrijving uit een aantal eisen en wensen opgesteld in samenwerking met de gebruikers en wordt door deze personen gefiatteerd. De probleembeschrijving dient wel duidelijke grenzen van het te bouwen "ontwerpsysteem" aan te geven. Deze grenzen kunnen vastgesteld worden door een objectieve vaststelling van de gestelde eisen en wensen. De prioriteit die aan bepaalde zaken gegeven is kan aan de hand hiervan goed gemotiveerd worden en is bovenal controleerbaar.

Inventarisatie Eisen en Wensen De inventarisatie wordt vastgelegd in gesprekken tussen de analist (bouwer CAD applicatie) en de gebruiker (ontwerper van het product) in eventuele individuele gesprekken. Het werken in werkgroepverband betekent soms een inbreuk op de bij het bedrijf gevolgde procedures voor projectorganisatie. Men zal iedere keer de betreffende personen als werkgroep in vergadering bijeen willen roepen om vervolgens tot een formulering van eisen en wensen te komen. Dit betekent vaak een vertraging omdat de agenda's op elkaar afgestemd moeten worden, waardoor de doorlooptijd onnodig verlengd wordt.

Systeem grenzen en Doel van de applicatie

2-6

•

De applicatie ondersteunt de ontwerper hoofdzakelijk bij het tekenen van het schema (zie Analyse van het Verloop van het Ontwerpproces, blz 2.3).

•

Er komen commando’s waarmee standaardregelkringen kunnen worden geplaatst.

•

Een ketelconfiguratie kan worden gegenereerd op basis van een in te voeren totaal capaciteit.

•

Tijdwinst kan worden geboekt doordat groepen componenten die in min of meer vaste samenstelling voorkomen in één keer kunnen worden geplaatst.

Hoofdstuk 3

Functies en Sub-functies

Overzicht Hoofdactiviteit Analyse van Ontwerpproces en Product

Activiteit

Resultaat

Stap 2 Functies en sub-functies van het product opstellen

Hiërarchisch functiemodel

Activiteit Dit hoofdstuk behandelt het opstellen van het functiemodel. Het functiemodel is een hiërarchisch model dat een weerspiegeling is van het te produceren product (ontwerp) in termen van functies en sub-functies. Hulpmiddel hierbij vormt de analyse van het product en het vastleggen van eisen en wensen.

Resultaat Een hiërarchisch model waarbij functies naar behoefte worden opgesplitst in een aantal sub-functies die samen dezelfde functie vervullen. Een sub-functie komt vaak overeen met een sub-assembly in het product: een groep onderdelen die samen een taak vervullen in een groter geheel.

3-1

Hoofdstuk 3, Functies en Sub-functies

Functies in het CV-installatie Systeem

1

PI

ketel

1

ketel

N20

V1-

G1

G2

G3

G4

2

N20

1 TI

V1-

TIC

M

2 TI

M

3

TA

tapwater TIC

M

2

TIC

3

3 R1-

1

3 G1

G2

G3

G4

Opsporen van de te vervullen functies Na bestudering van een aantal voorbeeld ontwerpen (zie ook bijlage C) kan de volgende globale functie indeling gevonden worden: 1. Warmte opwek functie 2. Verdelende functie 3. Vier verschillende warmte overdracht functies verwarmen van de vloer verwarmen van het tapwater verwarmen van de lucht door straling (radiator) verwarmen van de lucht waarbij gedwongen convectie tot stand wordt gebracht

3-2


Functiemodel Ontwerpen Doel van deze stap is het vastleggen van alle functies welke met de CAD-applicatie gerealiseerd moeten worden. Alle gegevens voor de te bouwen applicatie worden in deze analyse vastgelegd, alsmede de eisen en wensen welke aan iedere functie binnen het product gesteld worden, de zogenaamde Functionele Attribuut Specificaties. Als uitgangscriterium voor de analyse wordt de probleembeschrijving met aanvullende kennis van de engineers als leidraad gebruikt. Hieruit moet afgeleid kunnen worden wat de uiteindelijke applicatie moet presteren. Het vastleggen van de analysegegevens voor het functie- en productmodel is het vooral grafisch noteren van de resultaten. Op deze wijze worden zodanig documenten geproduceerd dat een evaluatie hiervan op eenvoudige en toegankelijke manier plaats kan vinden. Ook na implementatie van de CAD-applicatie moet het mogelijk blijven de analyse eenvoudig uit te breiden en / of bij te stellen, dit is een voortdurend proces. Een goed overzicht van de gemaakte documenten en het accuraat bijhouden hiervan is van grote betekenis en helpt de gebruiker en de analist bij het beoordelen van het resultaat. Het is van belang dat de geproduceerde documenten onderhoudbaar zijn. Het overzicht en de toegankelijkheid van deze documenten moet zo duidelijk mogelijk zijn, meer grafisch dan tekstueel documenteren is hierbij een goed uitgangspunt. Tijdens de analyse zal men moeten onderkennen dat er voortdurend overleg gepleegd moet worden met de verschillende engineers en disciplines. Dit kan betekenen dat deze stap complex, lastig en tijdrovend kan zijn. Men moet er echter voor waken dat de voortgang van het project niet door lange discussies of andere zaken in gevaar komt. Het is veelal een goed compromis, vooral wanneer men voor de eerste keer een applicatie ontwerpt, de analyse in eerste instantie voor 80% goed op te zetten. Deze analyse kan men dan in een later stadium uitbreiden tot het gewenste resultaat. De aanpak van CAD-Applicatie Engineering is vooral gericht op het "altijd" snel en efficiënt aan kunnen passen van de CAD-applicatie bij het voordoen van nieuwe situaties.

3-3


Functieanalyse De functieanalyse concentreert zich voornamelijk op het in kaart brengen van alle functies van het te bouwen ontwerpsysteem. Het heeft tot doel de probleemstelling in zijn totale samenhang in kaart te brengen. Het is van groot belang dat de functies in een duidelijke relatie weergegeven worden. Een hiërarchische structuur is kenmerkend binnen de primaire taak van de functie analyse. Deze analyse is gebaseerd op een stapsgewijze opdeling van een functie in meer gedetailleerde functies. Dit houdt in dat delen die in de opsplitsing van een geheel worden onderscheiden zelf ook als geheel kunnen functioneren en eventueel weer kunnen worden opgesplitst in delen. Dit proces staat ook wel bekend als functionele decompositie of black box benadering en gaat door tot het niveau van elementaire functies, zie volgend figuur.

hoofd functie

subfunctie A

elementaire functie AA 1.1

0

1

elementaire functie BB 1.2

hiërarchische functiestructuur De functies krijgen een nummer dat afhankelijk is van de plaats in de hiërarchie. Een elementaire sub-functie is de kleinste eenheid van de applicatie welke voor de analyse van het ontwerpsysteem nodig is. Met de functie analyse is het mogelijk om op grote schaal ordening aan te brengen in het ontwerpproces. Het ontwerpen wordt hiermee meer een kunde dan een kunst, waarbij de combinatie van beide het sterkst is. Het opsplitsen van functies in sub-functies gaat door tot het laatste punt van detail is bereikt dat voor de ontwerper nog interessant is. Wanneer een schokbreker wordt ontworpen, zijn de componenten waaruit deze is opgebouwd wel interessant; wanneer daarentegen een machine wordt ontworpen, waar schokbrekers als koopdeel in voor komen, is een opsplitsing niet nodig.

3-4


Regels voor Functie analyse In de volgende tabel zijn een aantal algemene analyseregels om te komen tot een goede functie analyse opgesomd. Voor het analyseren van een hiërarchisch model moet men deze regels in acht nemen ten einde een goede structuur te verkrijgen. KENMERK TOP-DOWN

OMSCHRIJVING analyseer van globaal naar detail

HIERARCHIE

structuur "hiërarchisch" handhaven. Een functie heeft meerdere sub-functies (children) en één ouder-functie (parent).

AFLOOP

zoveel mogelijk de product / procesafloop aanhouden

SOM VAN SUBFUNTIES

de som van de sub-functies is gelijk aan de bovenliggende functie

MINIMALE AANTAL SUB-FUNCTIES

een functie heeft ofwel geen sub-functies of minimaal twee sub-functies

SUB-FUNCTIE

onderverdelen in sub-functies en het samenvoegen van eventuele hulpfuncties kan alleen als men een principe-oplossing voor ogen heeft

NIVEAU

analyseer niet verder dan voor het doel gewenste laagste niveau

WAT / HOE / WANNEER

een functie wordt uitgedrukt in termen van WAT er gebeurt en niet hoe of wanneer

ELEMENTAIRE FUNCTIE

een elementaire functie heeft geen subfuncties

NAAMGEVING

gebruik de juiste termen voor de naam van functies en functievervullers

NUMMER

nummer van de ‘ouder functie’ met een volgnummer er aan toegevoegd voor alle subfuncties binnen deze ‘ouder-functie’

3-5


Hiërarchisch Functiemodel Voorbeeld CV-installatie Case 1

warmte genereren

1.1

druk beveiligen

1.1.1 drukfluctuatie opvangen 1.1.2 lucht afvoeren 1.1.3 overdruk beveiligen

1.2

druk indiceren

1.1.4 water afvoeren

1.3

warmte genereren

1.3.1 water verhitten 1.3.2 water rondstuwen 1.3.3 water afsluiten

2

water distributeren

2.1

water transporteren

2.1.1 water aanvoren 2.1.2 water afvoeren

3

0

vloer verwarmen

gebouw verwarmen

2.2

water verdelen

3.1

temperatuur regelen

3.1.1 temparatuur terugkoppelen

3.2

water verdelen

3.1.2 stuurinfo naar afsluiter

3.3

water afsluiten

3.1.3 water stroom regelen

3.4

temperatuur indiceren

3.1.4 water vooruit koppelen

3.5

water overdragen

3.1.5 water terug koppelen 3.1.6 water rondstuwen

4

radiator verwarmen

4.1

temperatuur regelen

4.1.1 automatisch of

4.1.1.1 temperatuur terugkoppelen

4.2

water verdelen

4.1.2 handmatig of

4.1.1.2 stuurinfo naar afsluiter

4.3

warmte overdragen

4.1.3 niet

4.1.1.3 waterstroom regelen 4.1.1.4 water vooruit koppelen 4.1.1.5 water terug koppelen 4.1.1.6 water rondstuwen

5

hete lucht verwarmen

5.1

temperatuur regelen

5.1.1 temperatuur terugkoppelen

5.2

warmte overdragen

5.1.2 stuurinfo naar afsluiter 5.1.3 waterstroom regelen

6

tapwater verzorgen

6.1

temperatuur regelen

6.1.1 temperatuur terugkoppelen

6.2

warmte overdragen

6.1.2 stuurinfo naar afsluiter 6.1.3 waterstroom regelen 6.1.4 waterstroom afsluiten

3-6

Hoofdstuk 4

Functionele Eenheden


Activiteit

Resultaat


Stap 3 Functie eisen opstellen, functionele eenheden met kenmerken vaststellen

FAS Functionele eenheden met kenmerken

Activiteit Dit hoofdstuk behandelt het opstellen van functie eisen en het inventariseren van functionele eenheden. Per functie of sub-functie uit het functiemodel worden de kenmerken en eisen voor het vervullen van die functie vastgelegd alsmede de verschijningsvormen van de (deel)oplossingen.

Resultaat Per sub-functie een FAS-document. In deze Functie-Attribuut-Specificatie staan de gegevens die bij het vormgeven van dit onderdeel van belang zijn. Ook wordt er per subfunctie een (deel-)oplossing gegeven. Dit kan een principe-oplossing zijn maar ook een generieke verschijningsvorm waarbij de variatiekenmerken zijn aangegeven.

4-1

Hoofdstuk 4, Functionele Eenheden

Functie Attribuut Specificatie (FAS) De keuze van oplossingen waarmee straks het productmodel ingevuld wordt is afhankelijk van de eisen en wensen waaraan de functie van het "product" moet voldoen. Om deze toegankelijk te maken worden deze gegevens gedurende de analyse overzichtelijk vastgelegd in de Functie Attribuut Specificatie. In dit document kunnen alle belangrijke attributen van in- en uitgangskenmerken per functie vastgelegd worden. De weegfactor bepaalt de belangrijkheid van ieder aspect binnen de totale beoordeling van alle beschouwde attributen van de functie. Als voorbeeld is hieronder een ingevuld FASdocument weergegeven. Het is belangrijk om op te merken dat iedere FAS de basis is voor invulling van het betreffende sub-functie, het geeft weer aan welke eisen en wensen de oplossing(en) moet voldoen. Belangrijke aspecten van het "product" kunnen zijn de nauwkeurigheid, de levensduur, het productie-aantal, de productietijd, capaciteit, enz. Wanneer we de keuze- of ontwerpactiviteit willen automatiseren, wanneer gegevens in een stuklijst moeten komen of voor andere doelen binnen het programma beschikbaar moeten zijn, dient de sofware ook over deze data te kunnen beschikken. De attributen worden dan daadwerkelijk in de objecten geïmplementeerd. Het programma kan hieraan waarden toekennen en / of waarden opvragen.

Voorbeeld CV-installatie Case Case CV-installatie systeem Functie: Warmte genereren (1.3) Specificatie Attribuut Vermogen Brandstof Afmetingen (l x b x h) Prijs Bedrijfsmodus

Ondergrens 16 kW geen 1000

Norm gewenst 20 kW Aardgas 1 x 0,5 x 0,75 1500 Continu

Weegfactor bovengrens 24 kW 2 x 1 x 1,5 2000

FAS document

4-2


Functionele Eenheden Voor het invullen van een mogelijke oplossing voor een gevraagde functie bestaan vaak meerdere mogelijkheden (voorkeursselecties), gebaseerd op een aantal specifieke kenmerken. Deze selectie van mogelijke oplossingen dient tijdens de analyse op verschillende niveaus vastgelegd te worden als functionele eenheid. Alle mogelijke combinaties en verschijningsvormen die binnen de applicatie mogelijk zijn worden zo op een duidelijke wijze voor iedere oplossing vastgelegd. Op basis van deze gegevens zal de CAD-applicatie gestalte krijgen. Een belangrijke bijkomstigheid is dat met het vastleggen van de functionele eenheden met hun kenmerken, het algoritme en toegangspad van het ontwerpproces grotendeels vastgelegd is. Hiermee wordt de kwaliteit van het ontwerp beter beheersbaar. Denk aan het voorkomen van fouten en niet toegestane combinaties van de verschillende oplossingen. De kwaliteitszorg binnen een bedrijf dient immers het maken van fouten voorkomen, dit met name in het ontwerpstadium. Het vastleggen van alle functionele eenheden ten behoeve van de te bouwen CAD-applicatie draagt dus wezenlijk bij in de kwaliteit van het ontwerp en product. 1

Warmte opwekkingssysteem Variatie kenmerk: verschil van ketels i n soort (vermogensverschil) en aantal

PI

ketel

1

ketel

N16

2

ketel

N16

1.3.2

Verhitting van het water Variatie kenmerk: aantal ketels type ketels

ketel

1

N16

3

N16

1.3.3

Pomp kenmerk: geen

ketel

1

N20

ketel N24

1.1.2

1.3.4

Afsluiter (handbediend) kenmerk: geen

1

1.3.3 Expansievat

Ontluchting

Overloop

1.1.4 Drukmeter

1.2

kenmerk: geen

kenmerk: geen

kenmerk: geen

kenmerk: geen PI

4-3


Verdelersysteem

2

Variatie kenmerk: aantalaansluitingen

G1

2.2

Verdeelpunt kenmerk: geen

G3

Afsluiters (handbediend) kenmerk: geen

G1

4-4

G2

1.3.4


Warmte overdracht systeem Varatie kenmerk: verschillende manieren van warmte overdracht V1-

1 TI

V1-

TIC

M

2 M

TI

TA

TIC

tapwater TIC

M

R2-

1

Toevoer regelen

Drieweg afsluiter

Variatie kenmerk: vier verschillende regelaars

kenmerk: geen

M

TIC

M

TA

TIC

TIC kenmerk: geen

TIC

TIC

M

Servobediening geen automatische bediening

kenmerk: geen

M

4-5


.5 4.3 5.2 6.2

Verwarmingsprincipes Variatie kenmerk: vier manieren van warmte overdracht

radiator (4.3)

luchtverwarming (5.2)

warmte wisselaar (6.2) tapwater

vloerverwarming (3.5)

Waterverdeler kenmerk: geen

3.2 4.2

Temparatuurmeter kenmerk: geen

TI

4-6

3.4

Afsluiters (handbediend) kenmerk: geen

3.3 4.1.2 6.1.4


De Relatie tussen Functiemodel, FAS en Functionele Eenheid Functiemodel hiërarchische weergave van te vervullen functies

functie

FAS bevat gegevens over de functie in de vorm van eisen en andere data

Functionele Eenheid verschijningsvorm(en) van principe-oplossing(en)

functionele eenheid 1

FAS

functionele eenheid 2

Voorbeeld CV-installatie Case Functie:

FAS:

Temperatuur regelen

Temperatuur regelingstype

Functionele Eenheid: Toevoerregelen Variatie kenmerk: vier verschillende regelaars M TIC

M

TA

TIC

TIC

M

geen automatische bediening

4-7

Hoofdstuk 5

Gebruikers Interface

Overzicht Hoofdactiviteit Ontwerp van het CAD-systeem

Activiteit Stap 4 Gebruikers interface ontwerpen

Resultaat Menu en Dialoog ontwerp Gebruikers handleiding

Activiteit Dit hoofdstuk behandelt het ontwerp van de gebruikers interface. Er wordt vastgelegd hoe de gebruiker (de ontwerper) de objecten (functionele eenheden) kan manipuleren om tot een eindproduct (een ontwerp) te komen dat aan de eisen voldoet. De gebruikers interface wordt beschreven met behulp van menu- en dialoog-ontwerpen en de gebruikershandleiding. Hiermee ligt vast wat er ingevoerd kan worden. Door de handleiding te schrijven voordat met programmeren wordt begonnen, is het bij de ontwikkeling duidelijk hoe de werking van de diverse commando’s en invoervelden zal worden.

Resultaat De gegevens in deze stap zijn de basis voor de programma-ontwikkeling. Met een ontwikkelomgeving als Visual-Basic kunnen op een snelle en eenvoudige wijze de menu’s en dialoogvensters worden ontworpen. De ontwikkelomgeving genereert hierbij ook het programma-framework. Procedures die te maken hebben met de gebruikersinteractie worden al aangemaakt, maar zijn nog leeg. Wanneer bijvoorbeeld een menu-item wordt toegevoegd, ontstaat er automatisch een procedure die wordt aangeroepen wanneer de gebruiker dit menu-item selecteert. Door het toevoegen van programmaregels wordt hier later logica aan toe gevoegd.

5-1

Hoofdstuk 5, Gebruikers Interface

Algemene Richtlijnen In de gebruikers interface wordt vastgelegd hoe de gebruiker van de applicatie de objecten (functionele eenheden) kan manipuleren om tot een eindproduct te komen. Op basis van de resultaten van de taak- en product analyse (stap 1) kan de gebruikers interface worden geschreven; uit de taak-analyse volgen de handelingen, uit de productanalyse volgen de objecten. De hulpmiddelen zijn menustructuren, dialoog ontwerp en de commando-beschrijvingen. In het stroomdiagram staat aangegeven hoe de gebruiker zijn ontwerp kan voltooien (verrichten van de taak). In de menustructuren staat de layout van de menu’s beschreven en in de dialoog ontwerpen staat waar en hoe gegevens worden ingevoerd. De gebruikers-handleiding beschrijft nauwgezet de werking van ieder commando, eventueel aan de hand van een voorbeeld. De wijze waarop de gebruiker met het programma omgaat en om kan gaan is van grote invloed op de snelheid waarmee het werk gedaan kan worden (100%) en op het aantal fouten (200%). Hierna volgen een aantal aandachtspunten: • consistentie Zorg voor een consistente commando-opbouw en afhandeling. Als bijvoorbeeld met een F1-toets help-informatie verkregen kan worden dient dit te werken bij alle commando's. Indien er hoofd- en kleine letters door elkaar gebruikt kunnen worden, dient dit overal zo te zijn etc.

5-2

•

feedback Stelt u zich eens voor te communiceren met iemand die nooit lacht of knikt, maar slechts iets zegt indien daartoe gedwongen: het is een frustrerende ervaring omdat nooit duidelijk is of de luisteraar werkelijk begrijpt wat er gezegd wordt. Zorg ervoor dat uw programma altijd feedback geeft, hetzij als tekst, hetzij grafisch: na een MOVE commando bijvoorbeeld door het object op zijn nieuwe positie te tekenen.

•

zorg voor gemakkelijk te onthouden commando-namen Het gebruik van betekenisvolle commando-namen vereenvoudigd het onthouden. Voor nieuwe- en incidentele gebruikers is het erg handig wanneer de invoermogelijkheden van dat moment op het scherm zijn aangegeven.

•

help faciliteit De aanwezigheid van een (context-gevoelige) help-faciliteit vergroot de leersnelheid voor nieuwe gebruikers.

•

tolerantie bij foutieve invoer Het systeem mag in geen geval 'plat' gaan wanneer er foutieve invoer wordt gegeven. Zorg voor een duidelijke foutboodschap en geef de gebruiker een herkansing.


•

bied gegevens overzichtelijk aan Het groeperen van gegevens, het altijd op dezelfde plaats verschijnen van bepaalde data (bijv help informatie) en het uitlijnen van gegevens zorgen voor een 'rustige' layout. Hierop is informatie sneller te vinden en het werken ermee is minder vermoeiend.

•

undo Bouw zo mogelijk een optie in, waarmee het effect van een commando ongedaan gemaakt kan worden. Geef bij commando's waarvan het effect niet eenvoudig te herstellen is en die grote gevolgen hebben (bijv DELETE ALL) de gebruiker de keuze tussen 'accept' en ‘cancel’.

5-3


Voorbeeld CV-installatie Case Beschrijving van een aantal commando’s Vloerverwarming

Na het aanklikken van deze knop vraagt het programma u om het aansluitpunt van de bovenste vloerverwarming op het verdeelblok. Met de linkermuisknop kunt u dit punt invoeren. Daarna wordt het aantal gewenste elementen gevraagd. Met het toetsenbord kunt u het antwoord invoeren. Ook de elementnummers moeten worden gedefiniëerd, waartoe u om een ruimtenummer wordt gevraagd (niet meer dan 4 karakters). Vervolgens plaatst het programma het vloerverwarmingssysteem in de tekening.

Drukbeveiliging

Na het aanklikken van deze knop vraagt het programma om het aansluitpunt van de beveiliging. Met de linkermuisknop kunt u dit punt invoeren. Vervolgens wordt de drukbeveiliging in de tekening geplaatst.

Maak ongedaan

Hiermee wordt de laatste door u in de tekening verrichte handeling teniet gedaan.

Nieuwe tekening

Het programma vraagt of u de oude tekening wilt opslaan. Indien het antwoord op deze vraag ja is, wordt er ook om een naam voor de tekening gevraagd. Daarna wordt er een nieuwe tekening aangemaakt en wordt u gevraagd om de naam, datum en dergelijke in te voeren.

Beschrijving van een dialoog Hydraulische Cylinder De drie invoerparameters kunnen door de gebruiker worden ingevoerd. De druk heeft een default waarde van 15 Mpa. Wanneer alle velden een waarde hebben, laat het programma de ontwerpparameters zien. OK: het object wordt aan het ontwerp toegevoegd. Cancel: geen actie.

5-4

Hoofdstuk 6

Onderdelen Bibliotheek


Activiteit

Ontwerp van het CAD-systeem

Stap 5 Onderdelen bibliotheek ontwerpenen

Resultaat Elementklassenmodel Opslagnormen Definities van Symbolen, Geometrische macro’s, Geparametriseerde onderdelen

Activiteit Dit hoofdstuk behandelt het vastleggen van de onderdelenbibliotheek. De functionele eenheden op het laagste niveau (uit stap 3) vormen de bouwstenen voor het ontwerpsysteem. Zij moeten een unieke naam of nummer krijgen. Dit gebeurt middels een elementklassenmodel. Eerst wordt er geïnventariseerd welke elementen er aanwezig zijn. Op basis hiervan wordt het klassenmodel opgesteld. Samen met de opslagnormen vormt dit de basis voor de te definiëren bibliotheek.

Resultaat Een elementklassenmodel waaraan de onderdelen hun code ontlenen, een structuur beschrijving van de bibliotheek (de opslagnormen), en definities van de bibliotheek met alle vaste geometrie (b.v. 2D symbolen of 3D standaard onderdelen) en / of geparametriseerde onderdelen.

6-1

Hoofdstuk 6, Onderdelen Bibliotheek

ElementKlassenmodel Inventarisatie Aan de hand van analysegegevens uit de voorgaande stap wordt nu een inventarisatie gemaakt betreffende alle standaard elementen of symbolen. De inventarisatie van de te bouwen CAD-applicatie vindt plaats op basis van geanalyseerde functionele eenheden. Hiermee wordt voorkomen dat men niet "alle" grafische elementen of symbolen, waarvan doorgaans maar zo'n 5% in de CAD-applicatie gebruikt wordt, in het systeem gaat plaatsen. Het gevolg van opslag van niet toegepaste elementen of symbolen is dat de onderhoudbaarheid en overzichtelijkheid van deze gegevens afneemt. De grafische elementen of symbolen dient men eerst afzonderlijk weer te geven op een speciaal voor dit doel ingericht document. Hierop kan men op uniforme wijze gegevens ten behoeve van opslag naar vorm, afmetingen, plaatsing, aansluitpunten, aanvullende gegevens, enz. invullen. Wanneer een overzicht van alle elementen die in de CAD-applicatie worden toegepast is verkregen, kunnen de gegevens geordend worden in een elementklassenmodel zoals aangegeven in de volgende paragraaf.

6-2


Elementklassenmodel Opstellen Het doel van deze stap is het komen tot een ordening van de grafische elementen of symbolen voor opslag in de symbolenbibliotheek van het CAD-systeem. De ordening wordt weergegeven in een elementklassenmodel welke, evenals het functie- en produktmodel, hiërarchisch van opbouw is. In dit model is duidelijk het toegangspad en de codestructuur van de grafische elementen of symbolen herkenbaar. Deze wijze van klasseren voorkomt het fenomeen van dubbel opgeslagen elementen of symbolen onder een andere naam of code. Ook de kans op "zoek" raken van gegevens is bij een geordende opslag minimaal. De inrichting van het elementklassenmodel wordt bepaald door het te bouwen ontwerpsysteem en de bijbehorende discipline(s). Wel moet getracht worden om een "open" structuur op te zetten in verband met wijzigingen c.q. uitbreidingen van de CADapplicatie(s). In het verleden is door verschillende instanties op brancheniveau onderzoek gedaan naar uniforme codering van de grafische elementen en symbolen. Het is verstandig om, zo mogelijk, deze structuur te adopteren en binnen de CAD-applicatie toe te passen. Bedenk echter dat de bestaande structuren nooit voor de volle 100% over te nemen zijn binnen een te bouwen CAD-applicatie. Ook wordt voor de applicatie maar een klein deel toegepast. Het opstellen van een eigen overzicht, elementklassenmodel, blijft dus noodzakelijk voor een goede beheersing van de grafische elementen / symbolen. Alleen de elementen uit de analyse van de te bouwen CAD-applicatie komen voor in het elementklassenmodel. In de volgende figuur is een voorbeeld van een elementklassenmodel weergegeven welke gecodeerd is volgens de IEC-code structuur voor schema's betreffende elektrotechnische applicaties.

elementklassenmodel gecodeerd volgens iec-code

6-3


Voorbeeld CV-installatie systeem 010101 tweeweg afsluiter 0101 afsluiters

010102 drieweg afsluiter 010103 haakse afsluiter

01 onderbrekende en sluitende elementen 0102 logische elementen

010201 ontluchter

0201 radiator 02 warmte-overdragers

0202 luchtverwarming 0203 vloerverwarming 0204 warmtewisselaars

03 energie-omzetters

0301 ketel 0302 pomp 0401 meet elementen

040102 TI

04 Meet/ regel elementen 05 bedieningselementen

040101 PI

0402 regel elementen

040201 PIC 040202 TIC

0501 handbediening 05 bedieningselementen

0502 veerbediening 0503 servobediening 06010101 cv-aanvoer 060101 waterleidingen 0601 0601 leidingen leidingen

06010103 tapwater 060102 electraleidingen

06 transportelementen 0602 verdelers

06010102 cv-afvoer

06010201 snoer

060201 groepenverdeelblok 060202 verdeelblok

0701 expansievat 07 overig

0702 overloop 0703 ruimte-aanduiding

Elementklassenmodel

6-4


Opslagnormen Voor het opslaan van de grafische elementen of symbolen in de symbolenbibliotheek van het CAD-systeem worden alle elementen voorzien van een hiërarchische code. Deze code is afgeleid uit het elementklassenmodel. Behalve de code (naam) van het symbool moeten conventies zijn vastgelegd over plaats van de opslag, schaal, gebruik van layers etc. Samengevat noemen we dit de opslagnormen. De plaats en indeling van de bibliotheken in het CAD-systeem moeten zodanig bepaald worden dat uitwisselen en onderhoud ervan overzichtelijk en gemakkelijk uitgevoerd kunnen worden. De tekennormen moeten alle systeeminstellingen vastleggen. Er moeten zijn aangeven welke laagindeling, pendikte, tekstgrootte en tekstfont en schaal wordt gebruik, ISO- of DIN-bemating, projectie methode, e.t.c. De opslagcode waaronder de grafische elementen of symbolen ingevoerd worden is, zoals reeds opgemerkt, gelijk aan de hiërarchische code van het elementklassenmodel. Het is aan te bevelen deze code aan te vullen met een aantal speciale karakters. Dit heeft als voordeel dat het zoeken binnen bepaalde klassen eenvoudiger wordt. Binnen de opslagnormen zal ook aangegeven worden hoe de bibliotheek waarin de basiselementen / symbolen opgeslagen worden genoemd wordt.

6-5


Opslagnormen CV-installatie Applicatie Ieder symboolelement (basiselement) wordt op een speciaal voor de CAD-applicatie toe te passen ontwerpdocument weergegeven. Hierop kan voldoende informatie op uniforme wijze geplaatst worden om de basiselementen/symbolen in het CAD-systeem in te voeren. Het betreft gegevens als afmetingen, attributen, rotatiemogelijkheden, plaatsingspositie(s), aansluitpunten en referentiepunten. De paragraafcode voor het document wordt ten behoeve van de beheersbaarheid afgestemd op de hiërarchische code van het elementklassenmodel.

Classificatie Elementen (symbolen) De codering van de elementen is gebaseerd op het elementklassenmodel. Dit model kan als uitgangspunt voor andere applicaties dienen (zie elementklassenmodel voor deurbedieningsysteem).

Bibliotheek Grafische Symboolelementen Alle symbolen worden opgeslagen in de bibliotheek "\SYMB" (een subdirectory). De symboolnamen en opslagstructuur zijn te vinden in het elementklassenmodel. De code uit dit model dient te worden aangevuld met het karakter "0" (nul) tot een totaal van 8 karakters. Kenmerken komen in de symbooldefinities niet meer voor. Het elementklassenmodel is tot op het laagste niveau uitgesplitst waarbij de kenmerken zijn opgenomen in de code.

Tekennormen Elementen

6-6

•

Geometrie:

De symboolelementen komen zoveel als mogelijk overeen met de NENnormering. Worden er symbolen gebruikt die niet genormeerd zijn volgens een NEN-norm (denk bijvoorbeeld aan de bestaande principeoplossingen die aanwezig zijn bij een variantontwerp), stel dan een eigen norm op. Denk aan documentatie hiervan!.

•

Grootte:

De grafische symboolelementen dienen ontworpen te worden op een raster. Ontwerp deze dan ook zo dat ze netjes overeenkomen met het raster.

•

Raster:

Uitgangspunt is dat de symboolelementen op een raster van 4 x 4 getekend worden. De aansluitpunten dienen op eenheden (raster) van 4 x 4 te vallen.

•

Oorsprong:

De oorsprong van de symboolelementen moet men dusdanig kiezen dat plaatsing op een raster valt. Kies ook een consistente plaats van deze oorsprong zodat men bij rotaties altijd hetzelfde effect krijgt. De oorsprong wordt aangegeven in een daartoe bestemde laag "ORIGIN". Hiervoor gebruikt men het puntcommando met een zichtbaar puntsymbool Ä

•

Attributen:

Als attributen (voor gebruik van attributen word verwezen naar bijlage A) zijn aan de symbolen het attribuut "ITEM" (stuknummer) en "FUNCODE" toegevoegd.

•

Laagindeling: Binnen het bouwen van de grafische symboolelementen dient men een scheiding in de lagen aan te brengen ten aanzien van het plaatsen van de elementen. Binnen deze applicatie worden de volgende lagen gebruikt: - laag ‘0’ : grafisch symboolelement + tekst - laag ‘ORIGIN’ : oorsprong van het symboolelement - laag ‘ATTR’ : attributen (ITEM en FUNCODE)


Symboolelementen In stap 5 wordt alle vaste- en variabele geometrie gedefinieerd en voorbereid op invoer in een bibliotheek. Functionele eenheden (oplossingen) die weinig of niet van vorm veranderen, worden hier als symbool of standaard onderdeel gedefinieerd. In 2D-tekenapplicaties worden vaak symbolen gebruikt. Deze komen uit een bibliotheek. De bibliotheek is geordend en gecodeerd volgens een elementklassenmodel. Als in een bepaalde branche een uniforme codering is opgezet, moet deze gebruikt worden. Deze uniforme structuren kunnen bijna nooit volledig overgenomen worden, vaak moet men aanpassingen maken. Ook wordt voor de applicatie dikwijls maar een klein deel toegepast. Het opstellen van een eigen elementklassenmodel kan derhalve noodzakelijk blijven. Gewoonlijk worden alle elementen voorzien van een hiërarchische code die afgeleid is uit het elementklassenmodel.

Voorbeeld CV-installatie Case Symbooldefinitie:

Hierboven is de definitie van twee symbolen weergegeven. De rastermaat staat in de tekennormen. Per symbool dient vastgelegd te zijn: • symboolnaam en codenummer, • afmetingen, • plaatsingspunt, • aansluitpunten, • en plaats van de attributen.

6-7

Hoofdstuk 6, Onderdelen Bibliotheek Symbolenoverzicht (niet compleet) Onderdeel

codenummer

symbool

01-groepen

tweeweg afsluiter

01010100

drieweg afsluiter

01010200

haakse afsluiter

01010300

ontluchter

01020100

02-groepen

radiator

02010000

luchtverwarming

02020000

vloerverwarming

02030000

warmtewisselaar

02040000

03-groepen

ketel

03010000

pomp

03020000

1

04-groepen

6-8

druk indicator

04010100

temperatuur indicator

04010200

druk indicator ll

04020100

temperatuur indicator controller

04020200

PI

TI PIC

TIC


Macro's Macro's worden samengesteld uit ingevoerde grafische elementen of symbolen met wel of geen verbindingsinformatie. Ze worden direct vanuit de macrobibliotheek geplaatst, eventueel met behulp van een selectieprogramma. De verbindingsinformatie van de macro's bestaat meestal uit "standaard" lijnelementen waaraan een bepaalde intelligentie wordt toegekend door deze in een geselecteerde laag te plaatsen. Het gebruik van macro's is steeds een afweging van een aantal criteria. Het is afhankelijk van de samenstelling van de elementen (functionele eenheden) binnen de CAD-applicatie. Eén van de criteria is het aantal keren dat van een bepaalde samenstelling voorkomt in de te ontwerpen producten. Een andere overweging is het aantal toe te laten configuraties binnen de applicatie. Door gebruik te maken van macro's, kan de complexiteit van het programmaontwerp in sommige gevallen sterk verminderen.

Selectie criteria D

1

2

C

3

5

B

1

7

A

1

2

2

9

opbouw macrocode De macro's worden opgeslagen in een macrobibliotheek onder een macrocode waarvan het eerste deel afgeleid wordt van het programmamodel (het programmamodel komt in later nog aan de orde), zie bovenstaande figuur. Deze macrocode wordt aangevuld met een selectiecode voortvloeiend uit een aantal kenmerken van de macro. Alle macro's en hun geëigende kenmerken worden genoteerd op een daartoe bestemd document.

Voorbeeld CV-installatie Case Als er slechts een zeer bepaald aantal mogelijkheden zijn, kan het handig zijn bepaalde combinaties van elementen alvast samen te voegen tot enkele macro’s. Bijvoorbeeld een ketelgroep met of zonder afsluiter. Men zou dit natuurlijk met behulp van een constructieprogramma op kunnen lossen, maar omdat er hier slechts twee mogelijkheden zijn is het eenvoudiger een macro aan te maken voor een ketel met afsluiter en deze een eigen nummer mee te geven.

ketel N16

1

ketel

1

N16

6-9

Hoofdstuk 7

Programma Ontwerp

Overzicht Hoofdactiviteit Ontwerp van het CAD-systeem

Activiteit Stap 6 Programma’s ontwerpen

Resultaat Programma hiërarchie Programma definities

Activiteit In deze stap worden programma’s gedefinieerd en ontworpen. In een Windows omgeving heeft ieder menu-commando en iedere dialoog zijn eigen procedures. Per programma of procedure wordt vastgelegd welke gegevens er in gaan, welke gegevens eruit komen en hoe het probleem wordt opgelost.

Resultaat Sommige programa’s worden door een commando geactiveerd, andere worden door een procedure aangeroepen. Deze wie-roept-wie wordt vastgelegd in programma hiërarchie. Wat ieder (sub)programma doet is gedocumenteerd in de programma definities. Hoe de activiteit wordt verricht is vastgelegd in stroomdiagrammen. De stroomdiagrammen en de beschrijving van in- en uitgaande gegevens vormen samen de programma definitie. Note De globale programma hiërarchie vertonen grote gelijkenis met het hiërarchisch functiemodel. De oplossing wordt namelijk volgens deze structuur opgebouwd uit functionele eenheden en / of standaard elementen.

7-1

Hoofdstuk 7, Programma Ontwerp

Ontwerp Er zijn veel methoden en technieken beschikbaar om te komen tot een programma-ontwerp. Een bepaalde categorie methoden en technieken kan worden samengevat onder het begrip "gestructureerd ontwerpen van programma's". Het hanteren van deze technieken heeft tot doel: • Programma's realiseren die voldoen aan vooraf gestelde eisen, • Vastleggen van beslissingen, • Beter leesbare en gedocumenteerde programma's, • Betere onderhoudbaarheid van programma's, • Gemakkelijke uitbreidbaarheid van programma's, • Controleerbaarheid van programma's, • Reproduceerbaarheid in andere programmeertalen, • Versnelling van het hele programmeerproces. Met behulp van deze methode en technieken wordt getracht het ontwerpen van programma's te verheffen van een "kunst" naar een "kunde". Door het consequent toepassen ervan kan men op deze wijze de toegepaste technieken grotendeels aanleren. Uit de methoden voor gestructureerd programma-ontwerp die op de markt zijn zal binnen een organisatie een selectie gemaakt moeten worden, omdat men ze niet allemaal tegelijk kan toepassen. Bij deze cursus is een keuze gemaakt uit bestaande technieken die in de praktijk hun waarde al bewezen hebben. Dit wil echter niet zeggen dat andere technieken slechter of minder goed toepasbaar zijn. Bedenk echter wel dat het vastleggen van de toegepaste technieken binnen de eigen organisatie in de vorm van ontwerpen programmeernormen de kwaliteit en de uitwisselbaarheid van de te bouwen CAD-applicaties sterk verhoogd.

Ontwerpen van Programmastructuren Het ontwerpen van programmastructuren is globaal gebaseerd op de theorie van Michael A. Jackson. Deze gaat er vanuit dat de structuur van een programma af te leiden is uit de structuur van de data. Eenvoudig gezegd gaat men er van de logische gedachte uit dat het programma in staat moet zijn om de gegeven invoer om te zetten in de gewenste uitvoer. Deze uitvoer moet dan ook reeds op de een of andere wijze in de invoer aanwezig zijn. Deze in- en uitvoer worden dan in zogenaamde structuurdiagrammen vastgelegd. Deze structuurdiagrammen zijn de basis voor "gestructureerd" programmeren. Ten behoeve van onder andere het ontwerpen, testen en onderhouden van de programma's is het van groot belang de "globaal" toegepaste variabelen op een lijst bij te houden. Deze "globale" variabelen bevatten gegevens welke in verschillende (deel)programma's gebruikt worden. Het is als het ware de interface tussen de programma's, gelijk aan de relaties tussen de functies. Ook dienen binnen de op te zetten programmamodel de te initialiseren "globale" variabelen bij het verlaten van het (hoofd)programma hersteld te worden. Een programma mag dus nooit ongedefinieerd afgebroken worden!

7-2


Programma Hiërarchie De globale programma hiërarchie diagrammen beschrijven de aanroep relatie van de verschillende programma’s en subprogramma’s. Deze weergave laat tevens het verband zien tussen de verschillende producten en deelproducten en geeft ook een overzicht van de structuur en het toegangspad van de te bouwen CAD-applicatie. De programma hiërarchie is een afgeleide van het functiemodel, dat op zijn beurt gebaseerd is op een top-down analyse met een goede verdeling van de productfuncties en data-uitwisseling. Per commando wordt een programma hiërarchie gemaakt. In de onderstaande figuur bestaat er dus een commando Genereer Huis.

programma hiërarchie

7-3


Programma Definities Per programma dient te worden beschreven: • wat de taak is, • welke gegevens er in gaan en welke gegevens eruit komen, • hoe de inwendige programmastructuur eruit ziet, de principeoplossing wordt hier beschreven door een stroomschema.

stroomschema

7-4


Programmastructuur De analyse voor het opzetten van een programmastructuur dient zoveel mogelijk onafhankelijk van de toe te passen programmeertaal uitgevoerd te worden. Ieder programma met één ingang en één uitgang behoeft slechts te bestaan uit een combinatie van 3 basisstructuren: •

volgorde, de "sequentiële" structuur voor het achtereenvolgens uitvoeren van één of meer opdrachten. in opdracht 1 opdracht 2 opdracht 3 uit

volgorde structuur •

keuze, de "wissel" structuur voor het voorwaardelijk uitvoeren van opdracht(en) in blok A of B. in

voorwaarde ?

opdracht blok B

opdracht blok A

uit

keuze structuur •

herhaling, de "lus" structuur herhaalt de opdracht zolang aan een gestelde voorwaarde voldaan wordt. in

voorwaarde ?

F

T

opdracht

uit

herhaling

7-5

Hoofdstuk 7, Programma Ontwerp Deze drie basisstructuren hebben allen één ingang en één uitgang. Ze kunnen samengesteld worden tot een groot programma met dezelfde eigenschap. Dit "tweepool" principe dient op elk niveau van het programma-ontwerp gehandhaafd te worden.

in

in

voorwaarde ?

voorwaarde ?

F

F

T

T opdracht

opdracht uit

uit

goed

uit

fout

voorbeeld "tweepool" principe Een uitzondering op deze regel is een sprong naar een "foutroutine" wanneer continueren van het programma zinloos is! Dus het afbreken van een programma (terminate) als gevolg van een fatale fout.

in

voorwaarde ?

F

T opdracht FATALE FOUT? uit fout routine

voorbeeld "terminate" principe

7-6


Selectie- en Constructieprogramma's Bij het programma-ontwerp kunnen we onderscheid maken tussen constructieprogramma's, selectieprogramma's en een combinatie deze twee. Selectieprogramma's plaatsen een compleet model vanuit een grafische bibliotheek. We onderscheiden twee soorten bibliotheken (zie ook stap 5): - symbolen bibliotheek: waar enkelvoudige oplossingen in staan. Bijvoorbeeld een afsluiter, - macro-bibliotheek: waar gecombineerde oplossingen in staan. Bijvoorbeeld deelschema’s of onveranderlijke sub-assemblies. Met een constructieprogramma is het mogelijk om het model aan de hand van gegevens direct te genereren. Bij constructie- en selectieprogramma's kan een onderscheid worden gemaakt tussen vormen dimensievarianten. Een voorbeeld van een combinatie van beide kan men herkennen in bouten met verschillende kopsoorten en schachtlengte. In het onderstaande voorbeeld zijn de kopsoorten vormvarianten en de schachtlengte dimensievarianten.

parameters van een bout De parameters van de bouten zijn onder andere: • Kopsoort • Schachtlengte • Draadsoort • Draadlengte Bij elke parameter heeft men de keuze uit een beperkt aantal (bijvoorbeeld 7 kopsoorten) of een onbeperkt aantal (bijvoorbeeld schachtlengte) mogelijkheden. Bedenk altijd wel dat het aantal parameters, vermenigvuldigd met het aantal mogelijkheden per parameter, leidt tot een zeer groot scala van mogelijke bouten.

7-7


Voorbeeld CV-installatie Case In geval van de verdeelgroep van het CV-systeem zijn er in principe n verbruikers mogelijk. In plaats van al deze n mogelijkheden van te voren te tekenen en elk zijn eigen nummer te geven is het in dit geval gemakkelijk gebruik te maken van een constructieprogramma. Hierbij hoeven er slechts drie macro’s te worden opgeslagen om alle mogelijkheden te kunnen tekenen. Losse macro’s opgeslagen:

2 Verbruikers:

4 Verbruikers:

7-8

Hoofdstuk 8

Implementatie

Overzicht Hoofdactiviteit Implementatie

Activiteit Stap 7 Symbolen invoeren (geparametriseerde) Onderdelen invoeren

Resultaat Symbolen Geometrische macro’s Geparametriseerde onderdelen

Stap 8 Gebruikers interface bouwen Programmering Stap 9 Documentatie complementeren

Menu’s Forms Programma's Documentatie Gebruikershandleiding

Activiteit Wanneer de stappen 1 t/m 6 zijn uitgevoerd, is al het ontwerpwerk verricht. Proficiat, de ingredienten voor het bakken van de taart staan zogezegd klaar. Symbolen en onderdelen maken gebeurt waarschijnlijk met SolidWorks. Uitleg over het gebruik van dit programma wordt gegeven in de CAD/CAM handleiding SolidWorks, delen I , II en III . Hoe menu’s en dialogs worden gemaakt in Visual Basic en hoe de programmacode er in deze taal uit ziet, staat in de volgende secties van deze handleiding.

Resultaat Een onderdelen bibliotheek met documentatie. Een programma met documentatie en een gebruikershandleiding.

8-1

Hoofdstuk 9

Visual Basic Design Environment

So, here you are, excited and ready to get to work. There's only one problem. Not only do you not how to write a program, you don't even know how to get Visual Basic up & running or what to do with it when you do. The only way to alter this situation is to get started; you have Visual Basic work to do! In this chapter: Get Visual Basic up and running, Tour Visual Basic's main window, Find the commands that control Visual Basic.

9-1

Hoofdstuk 9, Visual Basic Design Environment

Starting Visual Basic Starting Visual Basic is as easy as opening your Start menu, finding the Microsoft Visual Basic folder, and then clicking on the Microsoft Visual Basic command. You can run Visual Basic from your Start menu.

When you run Visual Basic, after a short wait, its main window pops up on your screen. That screen should look something like this. Depending on the kind of installation Visual Basic's main window looks like this.

9-2


Starting and Loading Projects The little window in the middle of the main screen is the new project dialog box. It is politely waiting for you to decide exactly what kind of Visual Basic project you want to start. As you can see, the dialog box displays three tabs that enable you to access projects in different ways. The New tab enables you to start a brand-new project. The Existing tab enables you to choose any Visual Basic project already on your disk. The following figure shows the Existing page. Use the Existing page's controls to locate a Visual Basic project on your disk drive.

The last tab, Recent, gives you quick access to any projects you may have worked on recently. That page looks like this: If you want to restart a project you worked on recently, go to the Recent tab of the New Project dialog box

The New Project dialog box is extremely patient, so there's no point in sitting there and wait. To get things started, double-click the Standard EXE icon on the New page of the New Project dialog box. This action informs Visual Basic that you want to create a brand new program.

9-3


The Parts of the Visual Basic Window When you start that new project, a lot of other exciting things happen. First, a set of controls appears on the left side of the window in Visual Basic's toolbox. Also, your new program's starting window, called a form in Visual Basic, appears in the middle of the screen. And, as if that weren't enough, your new project's name and components appear in the Project window, and the form's property settings appear in the Properties window. Project window Visual Basic's main window displays several different areas

Toolbox

Form

Properties window

Now that you can see these wonders on the screen, you probably want to know what they are. If you don't, you are probably reading the wrong book. You can quit at this point, the rest of you take a look at Visual Basic's toolbox. See all those little icons? They represent controls that you can use with your program. Controls are objects like buttons, text boxes, labels, images, and shapes that you can position on your form in order to build your program's user interface. If all this sounds What's a User Interface? strange, don't worry about it. You'll learn how Almost all programs have a user to build a program in the next chapter, interface, which is the part of the Creating a Project. application that enables the user to interact with the program. A user The form part of Visual Basic's main display interface usually includes various looks like a window inside a window. The types of buttons, menus, dialog boxes, window with "Projectl" in its title bar is one of and other kinds of objects. By using Visual Basic's own windows, but the window the objects that make up the user inside the Projectl window, the one with interface, the user supplies commands "Forml" in its title bar, is your project's and information to the program. window. That is, when you run your program, Similarly, the program accesses the this is the window that appears on the screen. user interface in order to display Logically, then, this is also the window where information to the user you place the controls that make up your program's user interface.

9-4

Hoofdstuk 9, Visual Basic Design Environment The Project window gives you an overview of the objects in the currently loaded project. Usually, a form is one of these objects. You might, in fact, have more than one form in some projects. By clicking the plus and minus signs next to folders in the Project window, you can display more details about the project. Finally, the Properties window displays the properties of the object that's currently selected in the form. Currently, the form itself is selected, so its properties appear in the Properties window. What are properties? You can think of properties as the attributes of an object. For example, your project's form has a property called Caption, which is the text that appears in the form's title bar. If you change the text for the Caption property, the text in the form's title bar changes too.

Properties Most controls and other Visual Basic objects have properties that determine how the object looks and acts. Many of Visual Basic's objects, in fact, share similar properties. For example, all objects have a Name property, which enables a program to refer to that object. Most objects also have properties that determine the object's size, position, text, colors, borders, and much more. You'll learn more about properties as you work with Visual Basic. You'll learn more about methods, properties and events in the next chapters.

A form's title bar holds the text from the Caption property.

Changed caption

Caption property

9-5


The Code Window Although Visual Basic enables you to build much of your project by placing controls from the toolbox onto the form, sooner or later, you have to settle down to writing some program source code. Programs comprise many lines of commands that tell the program what to do. In Visual Basic, you type these commands into the code window. When you first start a new project, Visual Basic doesn't display the code window. To bring up the code window, just double-click the form. When you do, your Visual Basic window will look like this: The code window is a text editor into which you type your program's lines. Code Window

The new window that appears is the code window. As you can see, Visual Basic is pretty smart and often tries to guess what you want to do. In this case, Visual Basic has started something called a procedure, a procedure named Form_Load. If you were actually writing a program, you would probably finish the Form_Load procedure by typing Visual Basic commands between the two lines that Visual Basic already provided for you. In fact, you'll see how to do this in the next chapter.

9-6


Menus and the Toolbar Two important parts of the Visual Basic main window are the menu bar and the toolbar. The menu bar holds a series of menus, each of which contains commands you need to make Visual Basic do what you want. For example, if you want to add a new form to your project, you could select the Project menu's Add Form command. The menu bar provides a home for Visual Basic's many commands.

Many of the menu commands have hotkeys that you can use to select the command directly from the keyboard. For example, in the previous figure, you can see the keystroke Ctrl+D listed after the Add File command. This means that you can send Visual Basic the Add File command just by holding down your keyboard's Ctrl key and pressing D. The toolbar provides access to many of Visual Basic's most commonly needed commands. Most of the buttons on the toolbar are just quick ways to select a command from the menus. Clicking the button on the toolbar that looks like a floppy disk is the same as selecting the File menu's Save Project command. Some menu commands, such as Save Project, are represented as buttons on the toolbar.

9-7


If you are still paying attention, you might have noticed that the File menu's Save Project command has the same icon next to it as the icon used on the toolbar button. When you see an icon like this next to a command, you know that the command is also available in a toolbar, if you happen to have that particular toolbar turned on. (Visual Basic lets you turn different toolbars on and off.) What you have learned: You can start Visual Basic from your Windows Start menu. When Visual Basic first appears, you can choose to start a new project, load any Visual Basic project from your disk drive, or load a project on which you've recently worked. Visual Basic's toolbox contains the controls you use to put together your program's user interface. A Visual Basic form represents your program's window. The Properties window displays the attributes of an object selected in the form. The Project window shows the main objects in your project. Usually, a project has at least one form. You type your program's commands into Visual Basic's code window. You can access many of Visual Basic's commands from the menu bar and the toolbar. Some commands even have hotkeys that enable you to select a command directly from your keyboard.

9-8

Visual Basic Deze sectie behandelt de Microsoft Visual Basic programmeeromgeving en de belangrijkste eigenschappen van die taal. Ieder hoofdstuk heeft een korte inleiding van het onderwerp. Daarna volgt een voorbeeld in tutorial vorm: u kunt zelf een programma maken of aanpassen. Tot slot volgt een beknopte opsomming van de mogelijkheden. Deze sectie beslaat de hoofdstukken 9 t/m 16.

Visual Basic Inleiding

Visual Basic is een krachtige taal waarmee veel programmeer problemen kunnen worden opgelost. Hoewel Basic op zich voor een nieuwe gebruiker makkelijk te leren is, maakt de ontwikkelomgeving bij een eerste aanblik een overweldigende indruk. Dit deel helpt u vliegensvlug over de drempel. Door een aantal oefeningen in tutorial vorm, raakt u snel vertrouwt met de ontwikkelomgeving en het basis-gebruik van de taal. De onderwerpen die in deze sectie behandeld worden zijn: • Een kennismaking met de software ontwikkel omgeving, • Het beginnen met een nieuw project en het toevoegen van code, • Het declareren van variabelen, verschillende data typen en bijbehorende operatoren, • Het gebruik van strings; een data type dat wordt gebruikt om karakters op te slaan, • Control Statements, er wordt verteld hoe in een programma beslissingen kunnen worden genomen en hoe stukken code kunnen worden herhaald, • Een programma dat een bestand opent, er gegevens in schrijft en vervolgens het bestand weer sluit: File IO, • Procedures en functies, belangrijk om gestructureerde software te kunnen ontwikkelen, • Meer informatie over objecten en object-georiënteerd programmeren, • Het gebruik van elementen voor een user-interface: check boxes, option buttons en de list box.

Hoofdstuk 10

Creating a Project

In this chapter you will learn the basic skills you need to create a simple program. This knowledge will be important to you as you explore the language itself in the next part of the manual. In this chapter: Start a new Visual Basic programming project, Use controls to build a user interface, Write program source code, Convert a program into an executable Windows application.

10-1

Hoofdstuk 10, Creating a Project

Three Programming Steps Creating a simple Visual Basic program involves only three steps, after which you will have a program that can be run outside of Visual Basic’s programming environment, just like any other application you may have installed on your computer. The three steps are as follows: 1. 2. 3.

Create the program’s user interface, Write the program source code, which makes the program do what it is supposed to do, Compile the program into an executable file that can be run as a standalone application (able to run without being loaded into Visual Basic).

Of course, there are many details involved in each of these three steps, especially if you are writing a lengthy program. As you work, you will complete these steps in the order in which they are listed above. However, you will also frequently go back from step 2 to step 1 to fine-tune your user interface. You might even go back to step 2 from step 3 if you discover problems after compiling your program. Such is the nature of program development. In the rest of this chapter, you will take a close look at each of the three Visual Basic program development steps.

Step 1: Creating the User Interface As you learned in the previous chapter, a program’s user interface enables the user to interact with the program. The user interface comprises any objects that the user manipulates in order to give commands or information to the program. Such objects include buttons, menus, and text boxes, to name just a few. Visual Basic makes it easy to create a user interface by providing a set of ready-to-go controls in a toolbox. All you have to do to create your user interface is start a new project and position the controls on the form, which is the object that represents the program’s main window. In this chapter, you will create only a very simple user interface, learning just enough so you can understand the sample programs in the next sections. Go ahead and start Visual Basic. Visual Basic when it first appears.

Double-click the Standard EXE icon to start a new project. Visual Basic then creates a

10-2

Hoofdstuk 10, Creating aProject Form object for your program’s window, as well as displays a bunch of goodies in the toolbox, Project window, and Properties window. The following figure shows how Visual Basic should look at this point: Visual Basic with a new project ready to go.

Do you see all those icons in Visual Basic’s toolbox? Each icon represents one of the controls you can use to build your program’s user interface. For your reference and pleasure, here’s Visual Basic’s toolbox with all its controls labeled: Visual Basic’s toolbox contains the controls you need to build your program.

Label

PictureBox

Frame

TextBox

CheckBox

CommandButton

ComboBox

OptionButton

HScrollBar

ListBox

Timer

DriveListBox

DirListBox

VscrollBox

Shape

FileListBox

Image

Line

OLE Container

Data

This chapter will not go into a lot of detail about each of the controls; you will learn most of the details in the next chapters. Your goal right now is to get a general idea of how to create a Visual Basic program

10-3

Hoofdstuk 10, Creating a Project How to put a button on your new form? Just double-click the CommandButton control in Visual Basic’s toolbox. When you do, a button magically appears on the form. When you double-click a control in the toolbox, the control appears on the form

See the eight small squares that border the button object? Those are the button’s sizing handles. You can change the size of the button by placing your mouse pointer over one of the sizing handles, holding down the left mouse button, and dragging the handle. When you place your mouse pointer over a sizing handle, the mouse pointer changes to a new image that indicates the direction you can drag the handle. For example, place your mouse pointer over the sizing handle in the center of the button’s bottom edge. The mouse pointer changes into a double-headed arrow that points up and down. This arrow means that you can drag the button’s bottom edge either up or down. Go ahead and drag the edge down. You can resize most controls by dragging their sizing handles.

10-4

Hoofdstuk 10, Creating aProject You should notice two things as you drag the button’s edge. First, an outline follows the mouse pointer wherever you drag it. Second, the button’s new size appears in a small box as you resize the button. When the button outline is the size you want the button to be, just release your mouse button. The button then redraws itself to the new size. Here’s the button after it has been resized.

Adding the Program Source Code You now have a button in a form, which is all fine and good except for the fact that the button does nothing. Click the Start button on Visual Basic’s toolbar (not the toolbox). (When your mouse pointer is over the correct button, a little box appears containing the word ”Start.”) When you click the Start button, Visual Basic runs your program. You will see a small window that looks like this:

Your first Visual Basic program.

Current Events

Go ahead and click your program’s Commandl button. What’s important to notice is that clicking the button doesn’t make the program do anything useful.

Many of the things that happen in a Visual Basic program happen in response to events. An event is nothing more than something the user or the computer does to interact with your program. For example, when you clicked your program’s Command1 button, you caused a Click event. To tell Visual Basic what to do with this event, you must complete the Command1 Click event procedure. You will have learned plenty of other events by the time you get to the end of this section.

10-5

Hoofdstuk 10, Creating a Project Click the End button (the one that looks like a small, blue square) in Visual Basic’s toolbar to stop your program and get back to Visual Basic’s main window. Now, double click your form’s Commandl button. Your project’s code window pops up, as shown in the following figure: The code window appears whenever you double-click an object

When you double-clicked the CommandButton object, Visual Basic not only displayed the code window, but also started some program source code for you. This piece of source code is called a procedure. To put it simply, whenever a user clicks the Commandl button, Visual Basic goes to the Command1 Click procedure and performs all the commands the procedure contains. When you ran the program previously and clicked the button, Visual Basic did exactly what it was supposed to do and went to the Command1 Click procedure. Unfortunately, you have not yet placed commands in the procedure, so nothing happened. You can change that easily, by adding the source code line MsgBox ”Visual Basic rocks”

to the Command1 Click procedure, as shown. You type your own program code between the start and end of a procedure.

10-6

Hoofdstuk 10, Creating aProject Now, run the program again (by clicking the Start button). When you click the Commandl button this time, a message box appears with the message ”Visual Basic rocks”. Now your Commandl button actually does something.

As you might have already guessed, the MsgBox command tells Visual Basic to display a message box. The text in the quotes after the MsgBox command is the text the message box should display. You will see the MsgBox command a lot throughout this book. In the following section, you will see how to convert your Visual Basic program into a standalone application.

Creating Your Program’s Executable File Now, if you are done patting yourself on the back and yelling for the family to come and fuss over your first Visual Basic program, you can take the step that converts your Visual Basic project into a full-fledged, standalone Windows application. If you look in the File menu, you will see a command called Make Projectl.exe. The Make command changes your program into an executable file.

Click the Make Projectl command, and when the Make Project dialog box appears, click the OK button. When you do, Visual Basic changes your program into an executable Windows application.

10-7

Hoofdstuk 10, Creating a Project Now that Visual Basic has converted your program to an executable file, you don’t need Visual Basic to run the program. To prove this, first save your program by clicking the Save Project button in the toolbar (that’s the button that looks like a floppy disk), or you can select the File menu’s Save Project A Matter of Execution command. Visual Basic prompts you for two filenames. The first is for your form. Click Not all files on your disk drive OK to select the default name of Forml.frm. represent applications. Many are data The second file you need to save is your files that other programs need to load. project settings. When the dialog box appears, Files that end in .exe, however, are accept the default project name of executable files that you can doubleProjectl.vbp. click to run. For example, Visual Basic 6.0’s executable file is named Now you can exit from Visual Basic by Vb6.exe. If you find this file with pressing Alt+Q on your keyboard. Visual Windows Explorer and double-click it Basic vanishes from your screen and is now with your mouse, you’ll start Visual closed. Find the file Projectl.exe, which Basic, same as if you selected Visual should be in your VB98 folder if you didn’t Basic from your Start menu. Visual change any of the defaults. Projectl.exe is the Basic can convert your program to an executable file that Visual Basic created from executable file, using a process called your program. Double-click the file, and your compilation. Visual Basic application appears on the screen. Go ahead and click the Commandl button to display the message box.

What have you learned: To create a Visual Basic application, you build a user interface, write the program source code, and then compile the program into an executable file, You build a user interface by placing controls from Visual Basic’s toolbox on your program’s form, You can resize a control (and the form) by dragging the control’s sizing handles, which appear when the control is selected, One way to display the code window is to double-click the object for which you want to write program code, When the user clicks a button, Visual Basic generates a Click event. The program code you add to the button’s Click event procedure determines what the button does, The File menu’s Make command converts your Visual Basic program into a standalone Windows application.

10-8

Hoofdstuk 11

Variables

A computer would not be of much use if you did not have a way of getting data in and out of it. For example, to understand computer input and output, let’s say you want to type a letter. Your first task is to get the characters that make up the letter into your computer’s memory where you can manipulate them. You have to use one of the computer’s inputs, to type your letter, placing it into memory one character at a time. When you finish typing and editing the letter, you need a way to get it out of the computer’s memory so it can be read. You need an output device (typically a printer), to which you can send the letter to get it into a form that is useful. In this chapter: Understand input and output, Learn to use the Print, EndDoc, and Cls commands, Discover variables and how to declare them, Use TextBox controls for input, Use Label controls to give the user information.

11-1

Hoofdstuk 11, Variables

Programs and Input/Output The program that is currently running controls most Input and Output. If you load a program that doesn’t use the keyboard, the program will not notice your keystrokes, no matter how much you type. Likewise, if a program wasn’t designed to use your printer, you have no way of accessing the printer when running the program. A programming language without I/O commands would be about as useful to you as a book of matches would be to a fish. By providing commands for putting data into the computer and getting data back out again, a computer language allows you to create interactive programs. Interactive programs allow two-way communication between the user and the computer. For example, the computer might output a question to the user by printing the question on the screen. The user might then answer the question by typing on his or her keyboard. Visual Basic, like any other computer language, features several commands for controlling input and output. The Print command, for example, allows you to make text appear on the computer’s screen. You might want to do this in order to ask the user a question or to show the user a piece of information he asked for. Suppose you want to print a simple message on the screen. Try this: Get Visual Basic running and start a new project. Place a CommandButton control at the bottom of the form, double-click the button to display its Click procedure in the code window, and complete the procedure like this: Private Sub Command1 Click() Form1.Print ”Here’s some text output.” Form1.Print ”Here’s some more text output.” Form1.Print ”And here’s still more text output.” End Sub

When you run the program and click the button, you see the screen shown here: Windows applications display text in their windows

Text in Your Programs A string is a group of text characters A string literal is text that you want the computer to use exactly as you type it. You tell the computer that a line of text is a string literal by enclosing the text in quotation marks. You will run into strings and string literals a lot as you program with Visual Basic or any other computer language.

As you can see, each Print command creates a single line of text onscreen, in the form’s window. The text the command prints is, the text that you place after the word Print. This text, called a string literal, must be enclosed in quotation marks. Print is actually a command that belongs to the Visual Basic Form object. By placing the name of the Form object, Form1 in this case, followed by a dot in front of the Print command, Visual Basic knows where to look for the Print command.

11-2

Hoofdstuk 11, Variables Now, suppose you wanted the text printed on your printer instead of onscreen? In Visual Basic, this task is easy to do. Just change all the Form1.Print commands in the program to Printer.Print You should also make a couple of other changes, as shown here: Private Sub Command1 Click() Form1.Print ”Printing...” Printer.Print ”Here’s some text output.” Printer.Print ”Here’s some more text output.” Printer.Print ”And here’s still more text output.” Printer.EndDoc Form1.Cls End Sub

Notice the first line in this program. It displays the word Printing... onscreen. Without this line, the program’s user would not know what the computer was doing until text started appearing on the printer. Your program should always tell the user what it’s doing (if it’s not immediately obvious), especially when it’s doing processing that takes more than a few seconds to complete. Next, notice that by changing the Form1 to Printer in the Print commands, the program sends the text to the printer rather than to the screen. You can see now why it’s important to place an object name in front of a command. In this case, the object names tell Visual Basic which text to send to the screen and which text to send to the printer. After printing the text to the printer, the program executes the Printer object’s EndDoc command. This command causes the printer to finish printing and to eject the page from the printer. Finally, notice the last line (before the End Sub). The Form object’s Cls command clears the form’s window, which causes the word Printing... that appeared during the printing process to vanish. In fact, your computer system might send the text to the printer so fast that Printing... seems to just blink on and off. Now you know how to use Visual Basic to ask a computer user a question, which is one form of output. But how can you get the user’s answer into your program? As you might have guessed, Visual Basic has a way to get typed input from the user. You need to add a TextBox control to your form. But before you can learn about the TextBox control, you need to know about Variables.

Variables and Input To get user input into your Visual Basic programs, you can use something called a TextBox control. Suppose, for example, you’re writing a program that needs to know the number of cars in a parking garage. Suppose also that when the user runs the program, the first thing he or she must do is input the current car count. To solve this problem, try this: 1. Start a new Visual Basic project, 2. Then place a TextBox control and a CommandButton control on the form (refer to the following figure), 3. Double-click the CommandButton control to display its procedure in Visual Basic’s code window,

11-3

Hoofdstuk 11, Variables 4.

Complete the code,

Private Sub Command1 Click() cars = Text1.Text Form1.Print ”You have ” & cars &” cars.” End Sub

5.

Now, run the program, type a number into the text box (after deleting the ”Textl” that’s already there), and click the button.

When you do, Visual Basic jumps to the button’s procedure, where the program grabs your input from the text box, and prints the results in the window, as shown in this figure: A program can easily display data that’s been stored in a variable

What happened here? Look at the first line of the procedure (not counting the line with the procedure’s name). The line cars = Text1.Text takes the contents of the text box and places it into a variable named cars. To see how this works, you first need to know that More About Variables and Literals the TextBox control’s name is Text1. (Visual Basic automatically assigned this name to the Notice that Visual Basic can easily control. Later in this book, you’ll see how to tell the difference between the string rename objects.) It just so happens that a literal ”cars” and the variable cars. TextBox control has variables of its own. Now you know why the quotation These special variables called properties marks are so important. In fact, enable the TextBox control to store without the quotation marks, Visual information about itself. One of these pieces Basic would interpret each word of information is the text the control contains, following the Print command as a which the control stores in its Text property. variable, rather than as a string. You can copy the text into your own variable by using the equals sign. The word cars is a variable name, which is used to identify the little box in memory where Visual Basic stores the response. Visual Basic has assigned the variable cars to a memory location and has placed the value 786 into that location. Luckily, you don’t have to worry about where Visual Basic puts variables in memory; Visual Basic handles all that for you. The last line in the program shows how powerful the Print command can be. In this case, the Print command displays not only string literals, but also the value stored in the variable cars. By using ampersands, you can build a line of text from different elements. In the Print command above, the line of text displayed onscreen comprises three elements: the string literal ”You have ”, the variable car s, and the string literal ” cars”. The ampersands tell the Print command to place each of these elements one after the other on the same line.

11-4


Declaring Variables Variables can exist as many different types. When you wrote the previous program, you didn’t tell Visual Basic too much about the variable cars, so Visual Basic waited to see what the program was going to do with it. When the program assigned the TextBox control’s text to the variable, Visual Basic made cars into a string variable and copied the control’s text into the variable. Visual Basic is smart about figuring out how a program uses its variables. However, this cleverness comes with a price: When Visual Basic has to figure out how to use a variable, it takes longer for Visual Basic to assign a value to the variable. For this reason, it’s not a bad idea to declare your variables before you use them.

Implicit declaration versus explicit Declaration. Using Implicit Declaration Variables do not have to be declared, although it is good programming practice to do so. If you use a variable in code with no declaration, it takes on the data type of the value that is assigned to it. This is called implicit declaration because the declaration of the variable is implied. Declaring variables this way can be useful, but it can also lead to unwanted errors. For example, one of the benefits of declaring variables is that Visual Basic checks the spelling of variables in code against the variables that you have declared. Visual Basic doesn’t actually think the variable is spelled wrong, it only knows that the variable name that you tried to use isn’t declared. This method of variable declaration should be avoided. A better way to assign values of an unknown data type is to declare the variable using the Variant data type. That way, you can assign any type of value to the variable and Visual Basic still helps you avoid errors in your code. Using Explicit Declaration the Require Variable Declaration option on the Editor tab of the Options dialog box forces variables to be specifically declared before they can be used. This is called explicit declaration. Placing an Option Explicit statement at the beginning of a module also forces all variables to be declared within that module. Enforcing explicit declaration is performed separately on each module, which means that every module must contain the Option Explicit statement to use this option. Any modules that do not contain this statement will allow implicit declaration. Because implicit declaration is allowed, this does not mean that explicit declaration is not allowed. However, Visual Basic does not flag misspelled variables as non-existent without the explicit option. It uses the misspelling as an implicit declaration. When you declare a variable, you not only tell Visual Basic the variable’s name, but also how the variable is to be used. For example, the following is a rewritten version of the previous procedure:

Example Private Sub Command1 Click() Dim cars As Integer cars = Text1.Text Form1.Print ”You have ” & cars & ” cars.” End Sub

Notice the line Dim cars As Integer. This line tells Visual Basic that the program will use the variable cars to store integer data. Now, when Visual Basic transfers the text from the TextBox control, it changes the text from a string to a numerical value and stuffs the result into cars. This is all well and good, but what happens if the user types non-numerical characters into the TextBox control? For example, what if the user typed ten into the box instead of 18? There’s no way that Visual Basic can change the string ten into a numerical value, so

11-5

Hoofdstuk 11, Variables Visual Basic generates an error, which looks like this: Visual Basic displays errors when something goes wrong in your program.

A type-mismatch error tells you that the program tried to store the wrong type of data into a variable. You can never store a string in a numerical variable. You can however, create a variable for holding text, by declaring the variable’s type to be a string. Here’s a version of the procedure that declares cars as a string variable: Private Sub Command1 Click() Dim cars As String cars = Text1.Text Form1.Print ”You have ” & cars & ” cars.” End Sub

11-6


Variable types There are many different types to store different kinds of data. So far you encountered two of the: a string, which is a actually a string of characters, and the integer type that can hold different (whole) numbers. This table gives an overview of the data types that are available in Visual Basic. Data Type Byte Boolean Integer Long (long integer) Single (single-precision floatingpoint)

Storage 1 byte 2 bytes 2 bytes 4 bytes 4 bytes

Double (double-precision floatingpoint)

8 bytes

Currency (scaled integer)

8 bytes

Decimal

14 bytes

Date Object String (variable-length) String (fixed-length) Variant (with numbers)

8 bytes 4 bytes 10 bytes + string length Length of string 16 bytes

Variant (with characters)

22 bytes + string length

User defined (using type)

Number of required elements

Range 0 to 255 True or False – 32,768 to 32,767 – 2,147,483,648 to 2, l 47,483,647 – 3.402823E38 to – 1.401298E-45 for negative values; 1.401298E-45 to 3.402823E38 for positive values -1.79769313486232E308 to – 4.94065645841247E-324 for negative values; 4.94065645841247E-324 to 1.79769313486232E308 for positive values – 922,337,203,685,477.5808 to 922,337,203,685,477.5807 +/ – 79,228,162,514,264,337,593,543,950, 335 with no decimal point; +/7.9228l62514264337593543950335 with 28 places to the right of the decimal; smallest non-zero number is +/0.0000000000000000000000000001 January 1, 100 to December 31, 9999 Any Object reference 0 to approximately 2 billion characters 1 to approximately 65,400 characters Any numeric value up to the range of a Double Same range as for variable-length String User-defined (using Type) Number required by elements The range of each element is the same as the range of its data type.

11-7


Labeling Your Text Boxes A TextBox control without a label is very confusing. After all, unless you tell the user what you expect him to enter, how will he know what to do? Because you frequently need to prompt for information in programs, Visual Basic provides a special control, called a Label control, for labeling items in a window. You can easily add a label to the program you’ve been working on in this chapter. First, place a Label control on the form, dragging it into place above the TextBox control. Then, change the Label control’s Caption property to Enter the number of cars:. You can make this change by clicking the label to select it, and then changing the value of the Caption property in the Properties window, as shown in this figure: Change the label’s text in the Properties window.

If you like, you can also erase the string Text1 from the text box by deleting the text from the TextBox control’s Text property in the Properties window. This figure shows the program in its final form: Now the text box has a label so the user knows what to type

11-8


Example with Input and Output Now that you have learned a little about Visual Basic input and output, how about finishing up with a program that puts this new knowledge to the test? First, start a new Visual Basic project, and place three TextBox controls, two Label controls, and one CommandButton control like this:

Position your controls as shown here.

(Be sure to place the controls in order from top to bottom so that the TextBox controls are in the order Text1, Text2, and Text3.) Next, clear all the text from the TextBox controls’ Text properties. Then, change the first label’s Caption property to Enter first name: and the second label’s Caption property to Enter last name:. Finally, double-click the CommandButton control to display its Click procedure, and complete the procedure as follows: Private Sub Command1 Click() Dim firstName As String Dim lastName As String firstName = Text1.Text lastName = Text2.Text Text3.Text = ”Hallo, ” & firstName & ” ” & lastName End Sub

Now, run the program, and type your first and last name into the appropriate text boxes. Press the button, and a personalised greeting appears in the third text box, as shown in the following figure: This chapter’s final program says hallo

11-9

Hoofdstuk 11, Variables You should be able to figure out most of what’s going on in this program’s Click procedure. The first two lines tell Visual Basic that the variables firstName and lastName will be holding text data. The next two lines copy the text from the TextBox control into your new string variables. The final line is something new. There, rather than copying text from a TextBox control’s Text property, the program is copying text to TextBox control’s Text property. This action makes the text appear in the control, you can see in the previous figure. What you have learned

11-10

Input and output devices transfer data to and from a computer, The Print command print a line of text on the screen or a printer, String literals must be enclosed in quotation marks, Your computer’s memory can be thought of as a series of little boxes, with each box holding a single value, Variables are named places in memory where a program can store data, Numeric variables can hold only numeric values. String variables can hold only text (or numbers that the computer treats as text), You can use TextBox controls to get input from a program’s user. You should use Label controls to label text boxes, A TextBox control’s Text property holds the text in the control, whereas a Label control’s Caption property holds the text displayed in the label.

Hoofdstuk 12

Strings

Most information laid on your computer screen is in text form. Because text displays are so important in computing, Visual Basic has a number of actions and commands that manipulate text. These functions enable you to join two or more strings of characters into one, find the length of a string, extract a small portion of a string, and convert numbers to strings or strings to numbers. In this chapter, you will to use many of Visual Basic’s stringhandling functions. In this chapter: Join strings together, Calculate the length of a string, Manipulate substrings, Convert between strings and numbers.

12-1

Hoofdstuk 12, Strings

Joining Strings You will often have two or more strings in your programs that you must combine into one. For example, you might have a user’s first name and last name in two separate strings. In order to get the user’s entire name into a single string, you have to concatenate the two strings. Use Visual Basic’s concatenation operator, which is the ampersand on your keyboard, to handle this string-handling task. Simply joining the strings, however, is not a complete program statement; you also must tell Visual Basic where to store the new string. To do this, use Visual Basic’s assignment operator, the equals sign (=). The assignment operator for strings works just like the assignment operator for numeric variables. To see how all this works, look at these lines: Dim str1 As String Dim str2 As String Dim str3 As String str1 = ”This is “ str2 = ”a test.” str3 = str1 & str2 Form1.Print str3

These lines first declare three string variables and assign strings to two of the variables, str1 and str2. Then, the sixth line joins the first two strings together and assigns the result to the third string variable, str3.

The Length of a String Every string has a length, which is the number of characters contained in that string. For example, the string Why did the chicken cross the road? has a length of 35 because it contains 35 characters. Theoretically, a string can have any length, from 0 to infinity. In Visual Basic, however, a string is much more conservative and can be any length from 0 to 32,767 characters. Sometimes in your program, you might need to know the length of a string. To find the length of a string variable, use Visual Basic’s Len function, as in the following: length = Len(string1)

Here, the function’s single argument, string1, is the string for which you want the length. The Len function returns the length of the string as a numerical value that can be used anywhere you can use a numeric value. A function is simply a command that performs a specific task and then sends a result, the return value, back to your program. After doing the calculation, Len sends the number of characters back to you, so you can use it in your program. Usually, you assign a function’s return value to a variable.

Empty Strings An empty string is a string that contains 0 characters. How can a string contain 0 characters? When you assign a string variable to an empty string, you get a string with a length of 8, as shown in the following example: string1 Notice that there are no characters between the quotation marks. This creates an empty string. At first, you might think creating an empty string makes about as much sense as drinking from an empty glass. But sometimes you might want to initialise a string variable this way so that you know the string contains no old data.

Visual Basic features two types of functions. The first type includes Visual Basic’s built-in functions such as Len, Abs (absolute value), and Sqr (square root). Visual Basic boasts dozens of built-in functions that you can use in your programs. Visual Basic also lets you

12-2

Hoofdstuk 12, Strings write your own functions, which usually comprise several program lines that perform a specific task. You will learn about this second type of function in later chapters. A Functional Definition A function call in Visual Basic consists of a function name followed by parentheses that contain the function’s arguments. A function call always returns a single value (sends a value back to your program), which you usually store in a variable. For example, in the case of the Len function, the return value is the number of characters in the string used as the argument. In other words, when you use the Len function, the function sends the string’s character count back to your program.

No Keywords for Names Notice that the previous paragraph refers to a string variable called string1. Why is there a number after the name? The number is actually part of the variable’s name, and is required because String is a Visual Basic keyword. Remember: You can’t use Visual Basic keywords as variable names, so you must change (or add) at least one character to set the variable name apart from the keyword or function name. Please refer to Chapter 11, ”Variables” if you need to review the rules of creating variable names.

To get a better idea of how the Len function works, try this: Start a new Visual Basic project, and place four Label controls, two TextBox controls, and one CommandButton control. Position the controls as shown here.

Double-click the Form object to display the code window, and then type the following lines. Visual Basic will have already started the Form_Load procedure for you. Option Explicit Private Sub Form_Load() Label1.Caption = ”First name:” Label2.Caption = ”Last name:” Label3.Caption = ”Full name:” Label4.Caption = ”Name length:” Command1.Caption = ”Process Names” Text1.Text = ”” Text2.Text =”” End Sub Private Sub Command1_Click() Dim firstName As String Dim lastName As String Dim fullName As String Dim nameLength As Integer firstName = Text1.Text lastName = Text2.Text fullName = firstName & ” ” & lastName nameLength = Len(fullName) Label3.Caption = ”Full name: ” & fullName Label4.Caption = ”Name length: ” & nameLength End Sub

12-3


In the previous lines, the Option Explicit tells Visual Basic that all variables in the program must be declared before they are used. The Form_Load procedure sets the various controls’ Caption and Text properties to the text the controls need to display. As you might remember, Visual Basic jumps to the Form_Load procedure the instant you run the program, so it is a good place to assign starting values to controls’ properties. Finally, the Command1_Click procedure, which Visual Basic jumps to when the user clicks on the button, performs the following actions: 1. 2. 3. 4.

Declares the variables needed in the procedure, Retrieves the names typed into the text boxes, Joins the names together, Uses the third and fourth Label controls’ Caption properties to display the final name and the length of the name

Try the program yourself. Run the program, and then type a first name and last name into the appropriate boxes. Click the Process Names button, and the program displays the full name and the name’s length, as shown in the following figure: This program can count the number of characters in a name.

Extracting a Substring

A substring is a portion of a larger string. For example, the string ”ans T” is a substring of ”Hans Tragter”

Just as you can join strings to create a larger string, so too can you separate strings into smaller strings called substrings. Visual Basic has several special string-handling functions that were created especially to extract whatever portion of a string you need. These string-handling functions are Left, Right, and Mid. The Left function returns a specified number of characters in a string, beginning with the leftmost, or first, character of the string. Except cutting a substring from another string is a lot less messy than separating a chicken from its head. To use Left, you might type a command such as the following: string2 = Left(string1, 7)

This function call has two arguments. The first argument is the string from which you want to extract a substring; the second argument is the number of characters, counting from the first character in the string, that you want to include in the substring. So, the previous example returns the first seven characters of the variable string1. The function Right returns a specified number of characters in a string starting from the rightmost, or last, character of the string. So, the statement string2 = Right(string1, 7)

returns the last seven characters of the variable string1. Finally, the function Mid, which has two forms, allows you to extract text from any position in a string. In fact, you can use Mid to do anything you can do with the Left and Right functions – and much more. In other words, if you can remember only one string-

12-4

Hoofdstuk 12, Strings handling function, Mid is the one to remember. In the first form of Mid, you supply as arguments the source string (the string from which you will cut your substring) and a starting position. The function then returns a substring consisting of all the characters from the starting position to the end of the string. To get a little practice with substrings, try this: Start a new Visual Basic project, and place four Label controls, one TextBox control, and one CommandButton control. Position the controls as shown here.

Double-click the Form object to display the code window, and type the following lines. Visual Basic will have already started the Form Load procedure for you. Option Explicit Private Sub Form_Load() Label1.Caption = ”Enter string:” Label2.Caption =”” Label3.Caption =”” Label4.Caption = “” Text1.Text = ”This is a test.” Command1.Caption = ”Get Substrings” End Sub Private Sub Command1_Click() Dim string1 As String Dim string2 As String Dim string3 As String Dim string4 As String

Dividing Long Program Lines In the previous program listing, you might notice the underscore character (_). The underscore tells Visual Basic that the current program line continues on the next line. By using the underscore character (preceded by a space character), you can divide unusually long program lines into smaller chunks.

string1 = Text1.Text string2 = Left(string1, 5) string3 = Right(string1, 5) string4 = Mid(string1, 3, 5) Labe12.Caption = ”First five characters are ” & _ “’” & string2 &”” Labe13.Caption = ”Last five characters are ” & ”’” & string3 & ”’” Labe14.Caption = ”Five characters in the middle are ” & ”’” & string4 & ”’” End Sub

12-5

Hoofdstuk 12, Strings The Form_Load procedure sets the various controls’ Caption and Text properties to the text the controls need to display. Finally, the Command_Click procedure, which Visual Basic jumps to when the user clicks the button, performs the following actions: 1. 2. 3. 4.

Declares the variables needed in the procedure Gets the string typed into the text box Calls the Left, Right, and Mid functions to extract substrings from the string1 string Uses the remaining Label controls’ Caption properties to display the substrings

Try the program yourself. Run the program, and then type some text into the text box. Click the Get Substrings button, and the program displays the results, as shown in the following figure: This program can extract and display substrings.

Almost Foolproof Strings When you run the previous program, try entering a string that’s fewer than five characters. Because, in this program, the Left and Right string-handling functions assume a string length of at least five characters, and the function Mid assumes a string length of at least seven characters, you might expect the program to drop dead if you give it a string shorter than it expects. But Visual Basic’s string functions are smart little devils. If you give them values that don’t make sense, they usually can still figure out how to handle the situation. For example, if the string you typed was This, the string2, string3, and string4 substrings would be This, This, and is, respectively. Despite Visual Basic’s cleverness, you should watch out for this kind of error.

Finding Substrings Now that you know how to extract a substring from a larger string, you might wonder how you can find the exact substring you want. Suppose, for example, you have a string containing a list of names, and you want to find the name Twitdum. The function InStr was created for just this task. Like the function Mid, InStr has two forms. One form of InStr enables you to find the first occurrence of a substring by providing the function with the source string (the string to search through) as well as the substring for which to search. When you find the position of the string, simply use Mid to extract the actual string. If InStr cannot find the requested substring, it returns a value of 0. After finding the first occurrence of a substring, you might want to search the rest of the string for another occurrence. After all, your name list might contain more than one Twitdum. To continue searching, you use the second form of the InStr function. This second form takes as arguments not only the string to search and the substring for which to search, but also the starting position of the search.

12-6

Hoofdstuk 12, Strings You could use the value returned to continue searching the string. The following program demonstrates how all this substring search stuff works. To build the program, start a new Visual Basic project, double-click the form to display the code window, and then complete the Form_Load procedure. Private Sub Form_Load() Dim string1 As String Dim string2 As String Dim msg As String Dim position As Integer string1 = "SmithTwitdumFreemanTwitdumRothTwitdum" position = InStr(string1, "Twitdum") string2 = Mid(string1, position, 7) msg = "The first occurrence of " & "'" & string2 & "'" msg = msg & " is at position " & position msg = msg & vbCrLf & vbCrLf position = InStr(position + 1, string1, "Twitdum") string2 = Mid(string1, position, 7) msg = msg & "The second occurr ence of " & "'" & string2 & "'" msg = msg & " is at position " & position msg = msg & vbCrLt & vbCrLf position = InStr(position + 1, string1, "Twitdum") msg = msg & "The third occur rence of " & "'" & string2 & "'" msg = msg & " is at position " & position MsgBox msg End End Sub

This program requires no input. Just run it and compare the message shown in the message box with the program listing. A message box displays the results of all this string handling.

A few things about this program might have you scratching your head, so it might be a good idea to go through it a little at a time. First, the following lines declare the variables used in the procedure: Dim string1 As String Dim string2 As String Dim msg As String Dim position As Integer

The next line in the program sets the source-string variable to its starting value: string1 = ”SmithTwitdumFreemanTwitdumRothTwitdum”

With the source-string variable ready to go, the program can call the InStr function to look for the first occurrence of the name Twitdum, like this: position = InStr(string1, ”Twitdum”)

Next, the program assigns the located substring to the string2 variable by using, as one of the Mid function’s arguments, the position value returned by the InStr function: string2 = Mid(string1, position, 7)

The next lines start building the message that the program will display in its message box:

12-7


msg = ”The first occurrence of ” & ”’” & string2 & ”’” msg = msg & ” is at position ” & position msg = msg & vbCrLf & vbCrLf

There’s some curious stuff going on in these lines. First, notice how the program can build a long string message by continually adding text to the msg string. This technique is similar to the way you learned to add values to an integer value. Also, see the two instances of vbCrLf. You might be wondering what language that is. The value vbCrLf is a symbol that Visual Basic uses to represent two special characters, a carriage-return and a linefeed. To put it simply, when you add this symbol to a string, you are starting a new line. By using two of these symbols, the program starts a new line twice, which puts a blank line after the preceding text string. Getting back to the program, most of the rest of the procedure finds the next two occurrences of the name Twitdum and continues to build the msg string, which will be displayed in the message box. And speaking of message boxes, the following line, found near the end of the procedure, is where the program displays the message box: MsgBox msg

As you can see, to display a message in a message box, all you need to do is to type the MsgBox command followed by the string you want to display. Finally, the procedure ends appropriately enough with the End command: End

Passing Strings to MsgBox As you’ve learned, the MsgBox statement can display a line of text (and other types of data). In the previous example, the line of text was stored in a variable called msg. However, if the line of text you want to display is a string literal, rather than the contents of a variable, don’t forget that you need to enclose the string in quotes, like this: MsgBox ”This is your text.”

This one word is all you need to end the program. Because the End command terminates the program inside the Form Load procedure, the form never even appears on the screen. From the user’s point of view, the program does nothing more than display a message box and then end.

Changing Case As you know, alphabetic characters in Visual Basic can be typed either in uppercase or lowercase letters. Sometimes, you might want your strings to be displayed all in one case or the other. To change all characters in a string to either uppercase or lowercase, use Visual Basic’s handy UCase (which stands for ”uppercase”) and LCase (which stands for ”lowercase”) functions. There’s not much to say about these functions; they just do what they do. For example, look at these lines: Dim myString As String Dim LcString As String Dim UpString As String myString = ”This Is a Test” LcString = LCase(myString) UcString = UCase(myString)

After Visual Basic executes these commands, the LcString variable will contain the string this is a test and the UcString variable will contain the string THIS IS A TEST.

Converting Numbers to Strings You probably remember that there’s a big difference between numerical values and text

12-8

Hoofdstuk 12, Strings strings, even if the text string contains numeric characters. Numerical values, such as the number 5 or the integer variable number, can be used in mathematical operations Strings however cannot. Visual Basic includes the Val function, that lets you convert number strings into numerical values that can be used in mathematical operations. You can also change numerical values into strings with the Str function. To convert a number string into a numerical value, use the Val function The following statement makes number equal to 3.4: number = Val(”3.4Apples”)

In this example, because the characters that compose the word ”Apples” are not numerical characters, Val can do nothing with them and ignores them. If Val cannot convert the string at all, as in the case of number = Val(”Apples” ), it returns a value of 0. You should also know that Val ignores spaces in strings, and that it understands number strings in scientific notation form. The following table shows a summary of the results of the Val function when it is used with different strings. (If you don’t know about scientific notation, don’t worry. Just be aware that the last example in the table shows a string using this number form.) Function Call Val(”34”) Val(”56.23”) Val(”23.6&HYG”) Val(”-76”) Val(”2 3 4”) Val(”764,345”) Val(”0”) Val(”SJuHGd”) Val(”HFGYR345”) Val(”nine”) Val(”3.4D+4”)

Result 34 56.23 23.6 -76 234 764 0 0 0 0 34000

The Trouble with Zero The fact that Val returns a 0 when it cannot convert a string to a numerical value can lead to problems in your programs. Problems arise because 0 is a perfectly valid numerical value. For example, both of the expressions number = Val(”0”) and number = Val(”Apples” ) return a value of 0; the value is really only valid, however, for the first example. Be aware of this possible ambiguous outcome when using Val in your programs.

Converting strings to numerical values is only half the story. You might also need to go the other way and convert a numerical variable into a string. You might, for example, want to convert a numerical value to a string so you can add it to a text document. You can do this conversion by calling the Str function, which looks like this: string1 = Str(number)

Here, number is the numerical value you want to change into string form. For example, the program statement string1 = Str(34.45)

makes string1 equal to the string 34.45.

Spacing Out When the function Str converts a numerical value into a string, it always reserves a space for the value’s sign. Strings created from positive numbers always have a leading space, and strings created from negative numbers always begin with a minus sign.

12-9

Hoofdstuk 12, Strings Now that you know all about Val and Str, Visual Basic is smart enough to do many conversions for you automatically. For example, the following two lines produce the same result, except that the second line doesn’t add leading space to myString: myString = Str(188) myString = 188

These lines also do exactly the same thing, making the integer variable value equal to 35: value = 35 value = ”35”

What have you learned: You can use the ampersand operator & to join strings together. This process is called concatenation. The equals sign (=) can be used with strings just as it is used with numerical values. Specifically, you use the assignment operator to set a string variable to a specific string value. The length of a string is the number of characters contained in the string. An empty string contains no characters and so has a length of 0. The Len function returns, as a numerical value, the length of a string. A substring is a portion of a larger string. The functions Left, Right, and Mid enable a program to extract substrings from other strings. The function InStr returns the position of a substring within a string. You can use the functions LCase and UCase to convert strings to lowercase and uppercase, respectively. The function Val converts number strings to numerical values. The function Str does the opposite, converting numerical values to strings.

12-10

Hoofdstuk 13

Control Statements

In previous chapters, you learned much about the way Visual Basic works. You now know how to type programs, how to input and output data and how to handle strings. But these techniques are merely the building blocks of a program. To use these building blocks in a useful way, you have to understand how computers make decisions. In this chapter, you learn how your programs can analyse data in order to decide what parts of your program to execute or repeat. Now it is time to learn how you can control your program’s flow, the order in which the statements are executed so that you can do different things based on the data your program receives. In this chapter: Discover the If /Then statement, Replaced the If /then statement with the Select Case statement, Write a For/Next loop, Use variables in For/Next loops, Discover how to use Do Until, Do/Loop While and Do/Loop Until loops.

13-1

Hoofdstuk 13, Control Statements

Program Flow and Branching Program flow is the order in which a program executes its code. Your programs so far in this book have had sequential program flow. Truth is, almost all program code executes sequentially. However, virtually every program reaches a point where a decision must be made about a piece of data. The program must then analyse the data, decide what to do about it, and jump to the appropriate section of code. This decision making process is very important to computer programming. When a program breaks the sequential flow and jumps to a new section of code, it is called branching. When this branching is based on a decision, the program is performing conditional branching. When no decision-making is involved and the program always branches when it encounters a branching instruction, the program is performing unconditional branching.

The If /Then Statement Most conditional branching occurs when the program executes an If /Then statement, which compares data and decides what to do next, based on the result of the comparison. If the comparison works out one way, the program performs the statement following the Then keyword. Otherwise, the program does nothing and drops to the next program line. This gives each comparison two possible outcomes. A simple If /Then statement includes the keyword If followed by a Boolean expression. You follow the Boolean expression with the keyword Then and, finally, with the statement that you want executed if the Boolean expression is true. A Boolean expression is an expression that evaluates to either true or false. For example, the expression 3 + 4 = 7 is true, whereas the expression 6 + 1 = 9 is false. To get feeling for the if statement, try this: Start a new Visual Basic project and then place a Label control, a TextBox control, and a CommandButton control on the form. Position the controls on your form as shown here.

13-2

Hoofdstuk 13, Control Statements Now, double-click the form to display the code window, and type the following lines. Visual Basic will have already started the Form Load procedure for you. Private Sub Command1_Click() Dim choice As Integer Dim entry As String entry = Text1.Text choice = Val(entry) If choice = 1 Then MsgBox "You chose red." Form1.BackColor = vbRed End If If choice = 2 Then MsgBox "You chose green." Form1.BackColor = vbGreen End If If choice = 3 Then MsgBox "You chose blue." Form1.BackColor = vbBlue End If End Sub Private Sub Form_Load() Label1.Caption = "Chose background color" & vbCrLf & "1 = Red, 2 = Green, 3 = Blue" Text1.Text = "" Command1.Caption = "Process Selection" End Sub

The Command1_Click procedure, which Visual Basic jumps to when the user clicks the button, performs the following actions: 1. 2. 3.

Declares the variables needed in the procedure Retrieves the text typed into the text box Converts the text value to an integer Uses If /Then statements to determine which message box to display and which color to set to the background.

Try the program yourself. Run the program and then type a value from 1 to 3 into the text box. Click the Process Selection button, and the program displays a message box that tells you the color you selected. This program shows how a program can make decisions.

Else and ElseIf One thing to notice about this program is what happens if you type a value other than a number from 1 to 3. If you type anything else, including non-numerical characters, no message box appears because the variable choice will not contain one of the three values the program checks for in the If /Then statements. This causes the program to skip over all If /Then statements and jump to the end of the procedure.

13-3


This problem can be solved be adding an extra line. The If / then statement will become an If / then / else statement. There also is another statement that makes programming more simple: ElseIf. Using these statements the control statements will change as shown. If choice = 1 Then MsgBox "You chose red." Form1.BackColor = vbRed End If If choice = 2 Then MsgBox "You chose green." Form1.BackColor = vbGreen End If

Æ

If choice = 3 Then MsgBox "You chose blue." Form1.BackColor = vbBlue End If

If choice = 1 Then MsgBox "You chose red." Form1.BackColor = vbRed ElseIf choice = 2 Then MsgBox "You chose green." Form1.BackColor = vbGreen ElseIf choice = 3 Then MsgBox "You chose blue." Form1.BackColor = vbBlue Else MsgBox "You choose a invalid value" End If

Relational Operators The previous programs in this chapter used only the equal operator to compare values. Often you will need to compare values in other ways. You might, for example, want to know if a value is less than or greater than another value. Visual Basic features an entire set of relational operators you can use in If /Then statements and other types of comparisons. Relational Operators = <> < > <= >=

Meaning Equal Not equal Less than Greater than Less than or equal Greater then or equal

Logical Operators A single comparison in an If /Then statement often isn’t enough to determine whether data matches your criteria. How can you be sure, for example, that the user enters a number within a specific range? A way to ensure that data is in the correct range is to use logical operators in your If /Then statements. Visual Basic features four logical operators: Logical Operators And Or Xor Not

13-4

Meaning True if both sides of the expression are true True if one or both sides of the expression are true True if only one side of the expression is true Reverse true to false and vice versa


The Select Case statement The program explained in the previous chapter is can also be programmed with the Select case statement. You might recall that the Command1_Click gets a number from a text box and sets the form’s background color based on that number. You can rewrite the previous Command1_Click procedure like this: Private Sub Command1_Click() Dim choice As Integer Dim entry As String entry = Text1.Text choice = Val(entry) Select Case choice Case 1 MsgBox ”You chose red.” Form1.BackColor = vbRed Case 2 MsgBox ”You chose green.” Form1.backColor = vbGreen Case 3 MsgBox ”You chose blue.” Form1.BackColor = vbBlue Case Else MsgBox ”Invalid selection.” End Select End Sub

This procedure not only demonstrates using a Select Case statement with an integer, but also shows how you can have more than one program line associated with each Case clause. Here, except for the Case Else, each Case shows a message box and then changes the form’s background color. You can have as many lines as you want with each Case.

13-5


The For/Next Loop Probably the most often used loop in Visual Basic is the For/Next loop, which instructs a program to perform a block of code a specified number of times. You could, for example, use a For /Next loop to instruct your computer to print those 10,000 address labels. Because you don’t currently have an address file, however, let’s say you want to print your name on the screen ten times. Start a new Visual Basic project, and place a Label, TextBox, and CommandButton controls on the form. Position the controls as shown in this figure.

And add the program code. Private Sub Command1_Click() Dim i As Integer Dim Name As String Name = Text1.Text For i = 1 To 10 Form1.Print Name Next i End Sub Private Sub Form_Load() Label1.Caption = "Enter name" Text1.Text = "" Command1.Caption = "Display Name" End Sub

When you run the program, type a name into the text box, and then click the Display Name button. When you do, the program prints the name ten times in the form’s window. Any name you enter appears ten times in the window.

13-6


Using Variables in Loops Just as with most numerical values in a program, you can substitute variables for the literals you’ve used so far in your For/Next loops. To see how this works, add an extra textbox and label to the Visual Basic project Position the controls as shown in this figure.

And modify the program code. Private Sub Command1_Click() Dim i As Integer Dim HowOft As Integer Dim Name As String Name = Text1.Text HowOft = Val(Text2.Text) For i = 1 To HowOft Form1.Print Name Next i End Sub Private Sub Form_Load() Label1.Caption = "Enter name" Label2.Caption = "Enter #" Text1.Text = "" Text2.Text = "" Command1.Caption = "Display Name" End Sub

Using variables in For/Next loops makes your programs more flexible and produces a powerful programming construct. As you’ll soon see, you can use variables with other types of loops, too. In fact, you can use a numerical variable in a program in most places a numerical value is required.

13-7


The Do, While, and Until Loop Do While Loop Unlike a For/Next loop, which loops the number of times given in the loop limits, a While loop continues executing as long as its control expression is false. The control expression is a Boolean expression much like the Boolean expressions you used with If statements. In other words, any expression that evaluates to true or false can be used as a control expression for a Do While loop. To see a Do While loop in action, first start a new Visual Basic project, and then place two Label controls, one TextBox control, and one CommandButton control on the form. Position the controls as shown in this figure

. After placing the controls on the form, double-click the form to bring up the code window. Type the following program lines into the code window. Private Sub Command1_Click() Dim control As Long On Error Resume Next control = Text1.Text Form1.BackColor = vbWhite Do While control <> 0 control = Text1.Text Label2.Caption = "Current variable value: " & control If Form1.BackColor = vbRed Then Form1.BackColor = vbBlue Else Form1.BackColor = vbRed End If DoEvents Loop MsgBox "looping complete" End Sub Private Sub Form_Load() Label1.Caption = "Loop control variable value" Label2.Caption = "Current variable: " Text1.Text = "5" Command1.Caption = "Start Loop" End Sub

13-8

Hoofdstuk 13, Control Statements Then run the program. A value of 0 stops the loop and displays a message box.

Do Until Loop Visual Basic also features another type of loop that is very similar: the Do Until loop. Do Until control=0 … … Loop

13-9


What have you learned: Program flow is the order in which a program executes its statements. An If/Then statement compares the values of data and decides what statements to execute, based on that evaluation. The Else and ElseIf clause allow If/Then statements to handle many different outcomes. The EndIf keywords mark the end of a multi-line If/Then statement, including multiline statements with ElseIf and Else clauses. Relational operators, equal (=), not equal (<>), less than (<), greater than (>), less than or equal (<=), greater than or equal (>=), enable programs to compare data in various ways. Logical operators (And, Or, Xor, and Not) enable an If/Then statement to evaluate more than one comparison, and still resolve the expression in a single value. A Select Case statement can replace most If/Then statements. Repetitive operations in a computer program can be handled efficiently by program loops, including For/Next A For/Next loop instructs a program to execute a block of commands a given number of times. In the For/Next loop For x = num1 To num2, the variable a is the loop’s control variable. The loop limits are num1 and num2. A Do/While loop continues to run as long as its control expression is true. Because this type of loop checks the control expression before running the loop, a Do/While loop can run zero or more times.

13-10

Hoofdstuk 14

File Input / Output

As you have used your computer, you will have noticed that most applications save and load data to and from your hard disk. The applications you write with Visual Basic don’t have to be any different; they too, can save information to a disk file. If you’ve been trying to save data from your Visual Basic programs by photographing the screen, you are going to love this chapter! In this chapter: Open and close files, Save data to a file, Load data from a file, Add data to an existing file.

14-1

Hoofdstuk 14, File Input/Output

Steps in Accessing a File Simple file handling is actually an easy process. However, you need to perform three steps to be sure that your program’s data gets properly tucked away in that binary home called a file. Those steps are as follows: 1. Open the file 2. Send data to the file or read data from the file 3. Close the file In the following sections, you will cover each of these steps in detail.

Opening a File Probably the most complicated part of managing file I/O (input/output, remember?) is opening the file in the proper mode. You see, not only can files be used to save and load data, but they also can be used to save and load specific kinds of data in specific ways. For example, there is a big difference between opening a file to read a line of text and opening a file to read a database record, even though a file must be opened in both cases. Specifically, you can open a file in one of five different modes: • Append • Binary • Input • Output • Random First, because you are just starting out, you can forget about the Binary and Random modes. You will leave those puppies to a more advanced book that covers things like databases, records, and binary files. You can’t load data from a file until you’ve saved data to the file. Here is the Visual Basic statement that opens a file in the Output mode: Open ”c:\MyFile.dat” For Output As #1

The keyword Open tells Visual Basic that you are about to open a file. The string that follows the Open keyword is the path and name of the file you want to open. In this case, the file is called MyFile.dat and is located in the root directory of drive C. Now comes the part that determines the file mode. See the For Output? That tells Visual Basic you want to open the file in the Output mode. This mode enables a program to save data to the disk file. If the file doesn’t already exist, Visual Basic creates it. If the file does exist, Visual Basic gets the file ready to accept output from your program, which includes erasing the current contents of the file.

14-2


Saving Data to the File Your file is now open, sitting there patiently on your disk drive like a kitten waiting for a scratch behind the ears. The file, however, will sit there waiting patiently for attention long after the kitten has wandered away in boredom. I wouldn’t suggest that you try to scratch your file behind the ears, but it might be a good idea at this point to put some data into the file, something you can do with a Visual Basic command like this: Print #1, ”This is a test”

Visual Basic knows you are printing to a file rather than to the screen, thanks to the #1 after the Print keyword. The number is the same number, the program used to open the file. Remember the As #1 part of the Open statement? After the file number, you place a comma and follow it with the data you want to save to the file. After Visual Basic has performed this command, your file will contain the string.

Closing the File You finish the task by closing the door to the file’s data. After you place data into the file, you must close the file; otherwise, you might end up losing data. To close a file, you call upon the Close statement Close #1

You’ve probably already figured out that the number after the Close keyword is the same number the program gave the file when it opened it with the Open statement. Entering the Buffer Zone Closing files in a Visual Basic program (and most programs written in other languages, as well) is important because not all the data you’ve sent to the file has necessarily arrived there before you close the file. The reason for this anomaly is something called buffering. Because disk drives are so slow compared with computer memory, Visual Basic doesn’t actually send data directly to the disk file. Instead, it saves up the data in your computer’s memory until it has enough data to be worth taking the time to access the disk drive. The Close statement tells Visual Basic not only to close the file, but also to be sure to send all the data from the buffer first

Automatic File Closing Although it is important to close your files after accessing them, the truth is that if you don’t, Visual Basic will. However, Visual Basic closes all open files only when the program ends normally. Leaving file closing up to Visual Basic is dangerous. If something should happen so that the program doesn’t end normally, Visual Basic can’t close the file for you, and you might lose data.

14-3


Trying It Out It is time now to see all this file stuff put to work. To do this, start a new Visual Basic project (a Standard EXE), and place Label, Textbox, and Command Button controls on the form. Position your controls as shown in this figure.

Now, double-click the Command Button control to bring up the code window, and copy the following program lines Private Sub Command1_Click() Dim data As String data = Text1.Text Open "D:\temp\MyFile.dat" For Output As #1 Print #1, data Close #1 MsgBox "Text saved." End Sub

’Modify this path if the file has to be saved in ‘a different location!

Private Sub Command2_Click() End Sub Private Sub Command3_Click() End Sub Private Sub Form_Load() Label1.Caption = "Enter the text to file:" Command2.Caption = "Load Text" Text1.Text = "Default text" Command1.Caption = "Save Text" Command3.Caption = "Append Text" End Sub

After typing the lines, save your work, and run the program. Remember to change the file’s pathname to a location where data-files ought to be stored (generally not in the root folder). Save the following line to the file MyFile.dat. This application saves the contents of the text box to a file.

14-4

Type whatever text you want into the text box (or just leave the default text as is), and click the Save Text button. Visual Basic saves the contents of the text box to a file: named MyFile.dat. This happens in the Command1_Click procedure.


Loading Data from a File Your file now has data in it. What that data actually is depends on what you typed into the text box before clicking the Save Text button. Data in a file, however, is about as useful as a clock to a goldfish if you have no way of getting the data out again. That is where the Input statement comes in handy. Luckily, you are about to see how that works. Go back to the program you just worked on. Double-click the second command button in the code window. Visual Basic will start the Command2_Click procedure for you. Add the lines needed to make the procedure look as follows: Private Sub Command2_Click() Dim data As String Dim msg As String Open "D:\temp\MyFile.dat" For Input As #1 Do While Not EOF(1) Input #1, data msg = msg + vbCrLf + data Loop Close #1 MsgBox msg End Sub

You are now ready to try the program out again. Save your work and run the program. When the program’s window appears, clear all the text from the text box, and click The Load Text button. When you do, the program gets the text you saved to the file and displays it a msgbox. The while loop is added so that more than just the first line in the file can be loaded. The While loop runs while the end of the file is not reached. At that point EOF returns true and the loop stops.

14-5


Appending Data to a File Every time you click the Save Text button, and the program opens the MyFile.dat file for output, the previous contents of the file get erased like a teacher’s chalkboard at the end of the day. If you want to add something to the file, you must open the file in Append mode. To check this out, double-click the third command button to display the code window. Visual Basic will start the Command3_Click procedure for you. Add the lines needed to make the procedure. Private Sub Command3_Click() Dim data As String data = Text1.Text Open "D:\temp\MyFile.dat" For Append As #1 Print #1, data Close #1 End Sub

This procedure is almost exactly like Command1 Click, except it opens the file in Append mode, rather than in Output mode.

The program now displays text in a text box.

Now, save your work and run the program. When the main window appears, type some the text Don’t you think so ? into the text box, and then click the Append Text button. And repeat this for I even think it is cooler. Visual Basic saves the text immediately after the text that is already in the file. As you remember was the text This is cool already present in the Myfile.dat. When you click the Load Text button, the program loads all lines of text and displays it in a message box You can save as many text strings as you like by continuing to change the text in the text box and clicking the Append Text button.

What have you learned: Accessing a file requires three steps: Opening the file, saving or loading data to or from the file, and closing the file. The Open statement opens a file in one of five modes. Those modes are Append, Binary, Input, Output, and Random. Currently, you don’t need to know about Binar y and Random files; they are for more advanced programmers. The Print # statement stores data in an open file. The Input # statement loads data from an open file. When a program finishes with a file, it must close the file with the Close statement. Failure to close the file properly could result in lost data. The Output file mode creates the file if it doesn’t exist or opens and erases the file if it does exist. The Input file mode enables a program to read data from an existing file. The Append file mode enables a program to add data to an already existing file. The EOF function returns True when the program has reached the end of a file and returns False if the program has not reached the end of the file.

14-6

Hoofdstuk 15

Procedures and Functions

Until now, your programs have been pretty short; each designed to demonstrate a single programming technique. When you start writing real programs, however, you will quickly discover that they can grow to many pages of code. When programs become long, they also become harder to organise and read. To overcome this problem, professional programmers developed something called modular programming, the topic you will study in this chapter. In this chapter: Organise programs into small parts, Write your own procedures, Learn to write functions, Discover variable scope, Find out how to pass arguments to procedures and functions.

15-1

Hoofdstuk 15, Procedures and Functions

Top-Down Approach to Programming A full-length program might contain twenty or more pages of code, and trying to find a specific part of the program in all that code can be tough. To solve this problem, you can use modular programming techniques. Using these techniques, you break a long program into individual subprograms, each of which performs a specific task. To understand how modular programming works, consider how you might organise the cleaning of a house. The main task might be called CLEAN HOUSE. Thinking about cleaning an entire house, however, can be overwhelming. So, to make the task easier, you can break it down into a number of smaller steps. CLEAN LIVING ROOM CLEAN BEDROOM CLEAN KITCHEN CLEAN BATHROOM After breaking the housecleaning task down into room-by-room steps, you have a better idea of what to do. But cleaning a room is also a pretty big task. So why not break each room step down, too? PICK UP ROOM DUST AND POLISH CLEAN FURNITURE VACUUM RUG After breaking each room’s cleaning down into steps, your housecleaning job is organised much like a pyramid, with the general task on the top. As you work your way down the pyramid, from the main task to the room-by-room list, and finally to the tasks for each room, the tasks become more and more specific. Getting back to writing a program, though, which is a more conceptual type of task, you might not have a clear idea of exactly what needs to be done. This can lead you to your being overwhelmed by the project. Breaking programming tasks down into steps is called modular programming. When you break your program’s modules down into The length of a Subprogram even smaller subprograms you are using a You should break programs into small top-down approach to program design. By subprograms in order to make using top-down programming techniques, program code easier to understand. you can write any program as a series of To this end, each subprogram in a small, easy-to-handle tasks. Visual Basic program should perform only a single provides two types of subprograms you can main task, so it stays short and to the use when writing programs. The first type, point. When you try to cram too much procedures, is covered in the next section. functionality into a subprogram, it The second type, functions, is covered later loses its identity. If you can’t state a in this chapter. subprogram’s purpose in two or three words, it is probably doing too much.

15-2


Using Procedures One type of subprogram is a procedure. A procedure is like a small program within your main program. If you were writing a housecleaning program, the procedures in the main module might be called CleanLivingRoom, CleanBedroom, CleanKitchen and CleanBathroom. The CleanLivingRoom procedure would contain all the steps needed to clean the living room, the CleanBedroom procedure would contain all the steps needed to clean a bedroom, and so on. Suppose you want to write a program that draws a moving arrow onscreen. The following program shows how to do it. First, start a new Visual Basic project (a Standard EXE), and place Label and Command Button controls on the form, as shown in the following figure: Position your controls as shown here.

Now, double-click the Command Button control to bring up Visual Basic’s code window, and type the following program Option Explicit Private Sub Command1_Click() Dim x As Integer For x = 28 To 4888 Step 5 Call Arrow(x) Next x End Sub Sub Arrow(x As Integer) Dim delay As Integer Label1.Left = x For delay = 1 To 18888 Next delay End Sub Private Sub Form_Load() Label1.Caption = "» --->" Command1.Caption = "Fire Arrow" End Sub

Your new application fires an arrow.

After you complete the typing, save your work and run the program. When you do, you see this window: Click the Fire Arrow button and then duck! Your new program fires the arrow across the application’s window.

15-3


The program is divided into three procedures. Two of these procedures, Form Load and Command1_Click, are already good friends. The third procedure is named Arrow and is called by the Command1_Click procedure. The For /Next loop in the Command1_Click calls the Arrow procedure each time through the loop. When the Command1_Click calls Arrow, the program lines in Arrow execute. In other words, the program branches to the first line of Arrow and executes all the statements until it gets to the End Sub line. When it reaches the End Sub line, the program branches back to Command1 Click, to the next line following the procedure call. Because the line following the procedure call is the end of the For /Next loop, the program goes back to the top of the loop, increments x by 5, and calls Arrow yet again. This continues until the loop runs out, which is when x grows larger than 4,000. The following figure illustrates the process of calling the Arrow procedure in the For /Next loop: Program execution branches from the Command1 Click procedure to Arrow and back again.

Take a look at the call to the Arrow procedure, which looks like this: Call Arrow(x)

See the x in the parentheses? That is a procedure argument. Arguments in procedures work just like the arguments you used when calling Visual Basic’s built-in functions. You use arguments to pass into procedures the values those procedures need to do their job. The Number of Arguments For all practical purposes, a procedure can have as many arguments as you like. But you must be sure the arguments you specify in the procedure’s call exactly match the type and order of the arguments in the procedure’s Sub line. To use more than one argument in a procedure, separate the arguments with commas. For example, to add the argument y to the Arrow call, you would type Call Arrow(x, y). Then, so the arguments match, you must change the first line of Arrow to Sub Arrow (x As Integer, y As Integer). You can use different variable names in the Sub line, as long as they are the same type. In other words, using the arrow example, you can also type Sub Arrow (col As Integer, length As Integer). In the procedure, you would then use the variable names col and length, rather than the original x and y. Procedures don’t need to have arguments. To call a procedure that has no arguments, you wouldn’t need the parentheses. For example: Call Arrow.

15-4

The Order of Arguments You can pass one or more arguments to a procedure. However, keep in mind that the arguments are passed to the procedure in the order in which they appear in the procedure call. The procedure’s Sub line should list the arguments in the same order they are listed in the procedure call.


Variable Scope Now that you know a little about procedures, you should know how Visual Basic organises variables between procedures. You might wonder, for example, why x must be an argument in the call to Arrow. Why couldn’t you just use the variable x in the procedure? After all, they are part of the same program, right? You need arguments in your procedures because of something called variable scope, which determines whether program procedures can ”see” a specific variable. For example, if you were to change the program so Command1_Click did not pass x as an argument to Arrow, you would get a Variable Not Defined error when the program tried to execute Arrow. (This assumes that you have the line Option Explicit in the program.) Here is why: A variable in one procedure is not accessible in another. When you don’t explicitly pass x as an argument, the Arrow procedure can’t access it. When the procedure tries to access the variable anyway, Visual Basic doesn’t recognise it and generates an error. In Arrow’s case, the x is local to Arrow. Just as Command1_Click’s x cannot be seen in any other procedure (it is local to Command1_Click), Arrow’s x cannot be seen in any procedure except Arrow. This might seem at first like a crazy way to do things, but when you think about it, it makes a lot of sense. By not allowing a variable to be seen outside of the procedure in which it is declared, you never have to worry about some other procedure accidentally changing that variable’s value. Moreover, local variables make procedures self-contained, as if everything the procedure needs were put together in a little box. If the value of a variable used in a procedure is giving your program trouble, you know exactly which module to check. You don’t need to search your entire program to find the problem any more than you need to search your entire house to find a quart of milk. The following figure illustrates the concept of global and local variables: Global variables, represented here by GlobalA and GlobalB, are available in any procedure.

Subroutine1 LocalW LocalX

GlobalA GlocalB

Subroutine2 LocalY LocalZ

The opposite of a local variable is a global variable. You can use global variables in any procedure anywhere in your program.

15-5

Hoofdstuk 15, Procedures and Functions Here is a new version of your arrow program, which makes x a global variable. Because x is now a global variable, it need not be passed as an argument to the Arrow procedure. Option Explicit Dim x As Integer Private Sub Command1_Click() For x = 20 To 4000 Step 5 Call Arrow Next x End Sub Sub Arrow() Dim delay As Integer LabeL1.Left = x For delay = 1 To 10000 Next delay End Sub Private Sub Form Load() Label1.Caption=>>-- > Command1.Caption = ”Fire Arrow” End Sub

15-6

More About Undeclared Variables As you know, if you include the Option Explicit statement in your program, Visual Basic will present you with an error when it comes across a variable it doesn’t recognise. In the Arrow procedure, this keeps you from forgetting to pass x as an argument. However, if you left off the Option Explicit, Visual Basic will no longer insist on all variables being declared before they are used. So, when Visual Basic sees the undeclared x in Arrow, it will just assume that x is a new variable and will assign it the default value of 8. That will make your arrow label move to position 0 and stay there. Talk about a sluggish arrow!


Using Functions Functions are another way you can break up your programs into small parts. But unlike procedures, functions return a value to the procedure that calls them. You’ve used Visual A Big No-No Basic functions before in this book; the Len As a novice programmer, you might function, for example. The value it returns is think using global variables is a great the number of characters in a string. programming shortcut. After all, if you make all your variables global, You write functions much like procedures. you will never have to worry about However, function calls must assign the passing arguments to procedures. function’s return value to a variable. Suppose However, a program with a lot of you have a function named GetNum that gets global variables is a poorly designed a number from the user and returns it to your program hard to read and hard to program. A call to the function might look debug. You should write your something like programs to include as few global variables as possible. num = GetNum(). Position your controls as shown here.

To get some experience with functions, start a new Visual Basic project (a Standard EXE), and place Label, Textbox, and Command Button controls on the form, as shown in the following figure: Now, double-click the Command Button control to bring up Visual Basic’s code window, and type the following program Option Explicit Private Sub Command1_Click() Dim msg As String msg = GetResponse() MsgBox msg End Sub Function GetResponse() As String GetResponse = Text1.Text End Function Private Sub Form_Load() Label1.Caption = "Type a response:" Text1.Text = "Default response" Command1.Caption = "Get Response" End Sub

15-7

Hoofdstuk 15, Procedures and Functions Type something into the text box, and then click the Get Response button. The program displays a message box that contains the text from the text box. This wouldn’t be such a big deal all by itself, except for the fact that the program is using your own function GetResponse to get the text from the text box. This program calls a function when you click the button.

The first line of the function declares the function and its return-value type: Function GetResponse() As String

The keyword Function, of course, tells Visual Basic that you are declaring a function. The name of the function and a set of parentheses follow the Function keyword. If this function required arguments, you would have to declare them in the parentheses, just as you did with a procedure. The As String part of the line tells Visual Basic that this function returns a string value to the calling procedure. The next line of the function is the line that tells Visual Basic what value to return from the function: GetResponse = Text1.Text

In this case, the function returns the string the user entered into the Text1 textbox. Notice that to return a value from a function, you assign the function’s name a value, the same way you assign values to a variable. Finally, the function’s last line tells Visual Basic it has reached the end of the function:

What have you learned: Modular programming means breaking a program up into a series of simple tasks. Top-down programming means organising procedures in a hierarchy, with generalpurpose procedures at the top, that call specific-purpose procedures lower in the hierarchy. Procedures and functions are the two types of subprograms you can use when writing a Visual Basic program. Functions must return values, whereas procedures do not. A function declaration includes not only the keyword Function and the function name, but also the clause As type, which tells Visual Basic the type of value the function returns. In this case, type is a data type such as Integer or String. A program returns a value from a function by assigning a value to the function’s name. Procedures and functions might or might not receive values called arguments, which are sent to the subprogram by the calling procedure. Local variables are accessible only within the subprogram in which they appear. Global variables, which are declared outside of any subprogram, are accessible anywhere in a program.

15-8

Hoofdstuk 16

Objects and Controls

In this part we will explain what Objects are (you have used them for some time now), and how Methods and Events are related, so you will have a better understanding of it. You will not create your own objects, but in subsequent chapters you will be using them extensively. After that you will dig into the inner workings of Visual Basic’s many controls and learn how to use them in your own window applications. In this chapter: Learning about Objects, Methods, Properties and Events, Learning how to use a Check box, Learning how to use Option buttons, Learning how to use a Listbox.

16-1

Hoofdstuk 16, Objects and Controls

Objects, Methods, Properties and Events Although you may not have noticed, you have worked with several Visual Basic objects already. The Printer object is an object you used in chapter 11 to send output to the printer as in the following statement: Printer.Print ”Here’s some text output to a sheet of paper.”

In addition, you have seen the Form object when printing to a window like this: Form1.Print ”Here’s some text output to the screen.”

In these cases, the object represents an item outside your program’s scope. The Printer and the Form objects are system objects predefined by the Visual Basic system. But you can define and use your own objects as well. Unlike in traditional programming techniques, in which procedures and data are considered as separate items, Object-Oriented programming adopts the view that a single visible entity, an Object, should be used to encapsulate those data procedures. Visual Basic is not a pure Object-Oriented system (like e.g. Smalltalk), but a hybrid programming language that mixes traditional elements with the possibility to use objects. Other OO-languages use that same approach (C++ and Delphi). Using objects is a very elegant way to structure your program. With them you can hide the information that is not needed elsewhere: this increases your program’s readability and it prevents other parts of the program from (accidental) disturbance of your data. To make sure you get the picture, we will present a number of terms you will encounter when using objects and digging deeper in the Visual Basic documentation. Objects are encapsulated — that is, they contain both their code and their data, making them easier to maintain than traditional ways of writing code. Visual Basic objects have properties, methods, and events. Properties are data that describe an object. They are what you previously would call variables. Methods are things you can tell the object to do. A method is a synonym for procedure or function. Events are things that can happen. If you want your object to respond to a certain event, you will have to write code for it. This code is executed when events occur. Objects in Visual Basic are created from classes; thus an object is said to be an instance of a class. The class defines an object's interfaces, whether the object is public, and under what circumstances it can be created. Descriptions of classes are stored in type libraries, and can be viewed with object browsers. To use an object, you must keep a reference to it in an object variable. You first define this variable, initialise it and then make assignments or execute procedures as in this example. Dim myView as Object Set myView = swAp.ActiveDocument.ActiveView MyView.Scale = 1 / 20.0 MyView.InitializeShading

16-2


User defined types User-defined types are a powerful tool for grouping related items of data. They work similar to the Pascal record-type you are probably familiar with. Consider, for example, the user-defined type named udtAccount defined here: Public Type udtAccount Number As Long Type As Byte CustomerName As String Balance As Double End Type

You can declare a variable of type udtAccount, set the values of its fields individually, and then pass the whole record to procedures that print it, save it to a database, perform computations on it, validate its fields, and so on. Powerful as they are, user-defined types present the programmer with some problems. You may create a Withdrawal procedure that raises an error if a withdrawal exceeds the balance in the account, but there's nothing to prevent the Balance field from being reduced by other code in your program. In other words, the connection between procedures and user-defined types depends on the discipline, memory, and knowledge of the programmer maintaining the code. When the user-defined type udtAccount becomes the Account class, its data become private (invisible outside the class), and the procedures that access them move inside the class and become properties and methods. This is what's meant by the term encapsulation — that is, an object is a unit (a capsule, if you will) containing both code and data. When you create an Account object from the class, the only way you can access its data is through the properties and methods that make up its interface. The following code fragment shows how the procedures inside the Account class support encapsulation: ' The account balance is hidden from outside code. Private mdblBalance As Double ' The read-only Balance property allows outside code ' to find out the account balance. Public Property Get Balance() As Double Balance = mdblBalance End Property ' The Withdrawal method changes the account balance, ' but only if an overdraft error doesn't occur. Public Sub Withdrawal(ByVal Amount As Double) If Amount > Balance Then Err.Raise Number:=vbObjectError + 2081, _ Description:="Overdraft" End If mdblBalance = mdblBalance - Amount End Sub You can use the Object Browser to examine the objects that Visual Basic provides

Creating your own objects is beyond the scope of this course, but if you insist, you can find more information on it, in the online-help.

16-3


CheckBox Controls If you’ve been using Windows for any time at all, you’ve seen as many CheckBox controls as Command Button controls in windows, dialog boxes, and property sheets. CheckBox controls are usually used to represent program options. When you click the control, a check mark appears in its box, indicating that the associate option is active. A second click removes the check mark and turns off the option. The figure shows several CheckBox controls in a single window: CheckBox controls enable a user to select options.

CheckBox controls have 48 properties, seven methods, and respond to 18 events.

CheckBox Properties The CheckBox control has even more properties than the Command Button, 48 instead of only 43. Some of the more useful CheckBox control properties are listed below:

Alignment BackColor Caption Enabled ForeColor Height Left Picture

Style

Top Value Width

Represents whether the check box’s text is on the left or the right. Represents the check box’s background color. Represents the check box’s text. Represents whether the user can interact with the check box. Represents the color of the check box’s text. Represents the check box’s height. Represents the position of the check box’s left edge Represents the image that is displayed in the check box. For this property to have an effect, the button’s Style property must be set to Graphical. Represents whether the check box is standard or is a two-position, graphical push button. Represents the position of the check box’s top edge. Represents whether the check box is unchecked or checked. Represents the check box’s width.

The CheckBox properties that have the same name as Command Button properties work about the same way. A point of interest, however, is the difference between a standard check box and a graphical check box. Specifically, when you set a CheckBox control’s property to Graphical, it no longer looks like a check box, but more like a regular button. What is special about this button is that when it is clicked, the button stays pressed to indicate the checked state, rather than showing a check mark.

16-4


The CheckBox control doesn’t always look like a check box.

In this figure, the first control is a standard check box in its unchecked state. The second control is a standard check box in its checked state, the third control is a graphical check box in its unchecked state, and the fourth control is a graphical check box in its checked state. The following program demonstrates a few of the CheckBox control’s properties. To build the program, start a new Visual Basic project (a Standard EXE), and then place one Command Button and three CheckBox controls on the form. Position the buttons as shown in this figure.

Then, double-click the Command Button to display the code window, and type the following lines Option Explicit Private Sub Command1_Click() MsgBox "Yep, the button works." End Sub Private Sub Check1_Click() If Check1.Value = vbChecked Then Command1.Enabled = False Else Command1.Enabled = True End If End Sub Private Sub Check2_Click() If Check2.Value = vbUnchecked Then Command1.BackColor = RGB(192, 192, 192) Else Command1.BackColor = RGB(255, 0, 0) End If End Sub

16-5


Private Sub Check3_Click() If Check3.Value = vbUnchecked Then Command1.Move 728, 368, 3255, 1895 Else Command1.Move 188, 188, 4458, 1888 End If End Sub Private Sub Form_Load() Command1.Caption = "TEST BUTTON" Check1.Caption = "Disable Button" Check2.Caption = "Change Button Color" Check3.Caption = "Change Button Size" End Sub

When you are done typing, click the Commandl button to select it, and then, in the button’s Properties window, set the Style property to 1-Graphical. Now, save your work, and run the program. When you do, the main window appears. To prove that the Commandl button is working normally, give it a click. A message box appears. Dismiss the message box, and click the Disable Button check box. Visual Basic checks the box and disables the Commandl button; if you check the Commandl button, In a Check Box State of Mind nothing will happen. Notice in the source code how the program compares the value of a Next, click the Disable Button check box a CheckBox control’s Value property to second time to remove the check mark and to two values named vbChecked and re-enable the Commandl button. Click the vbUnchecked. Visual Basic provides Change Color check box to toggle the the vbChecked and vbUnchecked Commandl button’s background color between values to make it easier to manage red and grey. Click the Change Button Size check boxes. Thanks to these check box to toggle between two button sizes. predefined values (called constants), The figure shows the application when the you don’t have to remember that the Commandl button is disabled and set to its value of an unchecked check box is 8 large size: and the value of a checked check box is 1. The check boxes take over the task formally handled by regular Command Button controls.

CheckBox Methods and Events In the previous program, you can see that the Click event is every bit as important a CheckBox control as it is to a Command Button. The added bonus is that Visual Basic automatically shows or hides the control’s check mark for you. Send all thanks to Microsoft’s Visual Basic programming team.

16-6


OptionButton Controls Like CheckBoxes, you’ve undoubtedly seen plenty OptionButton controls before. OptionButton controls, again like CheckBoxes, are usually used to resent program options. However, OptionButton controls represent a set of options in which only can be selected simultaneously. When you click control, a dark circle appears in its box, indicating that the associated option is active. Unlike a check box, a second click does not remove the circle or turn off the option. To change the option, you must click another OptionButton control in the group. OptionButton controls also boast over 40 properties as well as seven methods, and they respond to 19 events. You are introduced to the most important these in the following sections.

OptionButton Properties The OptionButton control has about the same number of properties as a Command Button control, though for most you will have little need. Some of the more useful OptionButton control properties are listed below:

Alignment BackColor Caption Enabled ForeColor Height Left Picture

Style

Top Value Width

Represents whether the option button’s text is on the left or the right. Represents the option button’s background color. Represents the option button’s text. Represents whether the user can interact with the option button. Represents the color of the option button’s text. Represents the option button’s height. Represents the position of the option button’s left edge. Represents the image that is displayed in the option button. For this property to have an effect, the button’s Style property must be set to Graphical. Represents whether the option button is standard or is a two position, graphical push button. Represents the position of the option button’s top edge. Represents whether the option button is unselected or selected. Represents the option button’s width.

As you can see, the OptionButton control’s properties are much like the CheckBox control’s properties. The two controls are closely related. Like a check box, when you set an OptionButton control’s Style property to Graphical, it no longer looks like an option button, but more like a regular button. This button stays pressed to indicate the selected state. The following figure shows the CheckBox controls four different looks: The OptionButton control has four different looks, not counting its disabled look.

In this figure, the first control is a standard option button in its unselected state; the second control is a standard option button in its selected state. The third control is a graphical option button in its unselected state, and the fourth control is a graphical option button in its checked state. The following program demonstrates how to use OptionButton controls. To build the program, start a new Visual Basic project (a Standard .EXE), and then place one Command Button, one Frame, and three OptionButton controls on the form.

16-7


Position the controls as shown in this figure.

Double-click the Command Button to display the code window, and type the following lines (Visual Basic will have already started the Command1_Click event procedure for you): Option Explicit Private Sub Command1_Click() MsgBox "Yep, the button works." End Sub Private Sub Option1_Click() Command1.BackColor = RGB(192, 192, 192) End Sub Private Sub Option2_Click() Command1.BackColor = RGB(255, 0, 0) End Sub

Suitable for Framing As you’ve noticed in the sample program, Frame controls are great for grouping together controls that have similar functions. In the next chapter, you will use frames again to group sets of OptionButton controls that are being used as radio buttons.

Private Sub Option3_Click() Command1.BackColor = RGB(0, 255, 0) End Sub Private Sub Form_Load() Command1.Caption = "TEST BUTTON" Frame1.Caption = "Button Color" Option1.Caption = "Gray Button" Option2.Caption = "Red Button" Option3.Caption = "Green Button" Option1.Value = vbChecked End Sub

When you are done typing, click the Commandl button to select it, and then, in the button’s Properties window, set the Style property to 1-Graphical.

The option buttons enable the user to choose a color for the Commandl1 button.

16-8

Now, save your work, and run the program. When you do, the main window appears. To prove that the Commandl button is working normally, give it a click. A message box appears. Dismiss the message box, and click the Red Button option button. Visual Basic selects the button, deselects the previously selected button, and changes the Commandl button’s background color to red. Click the Green Button option button to change the Commandl control to green. As you can see, you can select only one color at a time.


List Controls Often in your Visual Basic programs, you need to enable the user to select an item from a list of possibilities. Although you can use check boxes and option buttons for presenting limited choices, ListBox and ComboBox controls can hold a list of many more choices that takes up little screen real estate. In this chapter, you will see how these handy controls work.

ListBox Controls A ListBox control is little more than a box that contains a list of selections. The user can use his mouse to select a choice from the list, and the program can respond to the choice through the control’s event procedures. You might use a ListBox control to present a list of choices that is too long to accommodate with check boxes or option buttons, but still short enough not to take up too much screen space.

ListBox Properties The ListBox control features more than 50 properties. The list presents the most useful:

BackColor Enabled ForeColor Height Left List ListCount ListIndex MultiSelect Sorted Text Top Width

Represents the list box’s background color Represents whether the user can interact with the list box Represents the color of the list box’s text Represents the list box’s height Represents the position of the list box’s left edge Represents a string array that contains the items in the control’s list Represents the number of items in the control’s list Represents the index of the currently selected item in the control Represents whether the control supports multiple selection of items Represents whether the items in the control’s list are sorted Represents the currently selected item in the list Represents the position of the control’s top edge Represents the control’s width

Later in this chapter, you will build a program that shows how many of these properties work. In the next section, however, you will first look over the control’s most important methods and events.

ListBox Methods and Events The ListBox control features 10 methods, several of which you might find especially useful. The most interesting ones are listed below:

AddItem Clear Move RemoveItem

Adds an item to the control’s list Clears all items from the control’s list Positions and sizes the control Removes a single item from the control’s list

Besides its properties and methods, the ListBox control responds to 21 events, two of which are particularly useful to you at this time. Those events are Click and DblClick, both of which you’ve run into before in this book. In case you’ve forgotten, the Click event occurs when the user clicks the control, and the DblClick event occurs when the user double-clicks the control. Because you’ve probably sensed a pattern to these chapters, you know that a sample program is next. If you don’t know that a sample program is next, consider yourself warned. To build the sample program, first, start a new Visual Basic project (a Standard EXE), and then position one ListBox control, one Label control, one Textbox control, and three Command Button controls as shown.

16-9


Position the controls as shown in this figure.

Now, double-click the form to display the code window, and type the following lines Private Sub Command1_Click() Dim newItem As String newItem = Text1.Text If newItem <> "" Then List1.AddItem newItem End Sub Private Sub Command2_Click() List1.Clear End Sub Private Sub Command3_Click() Dim selItemIndex As Integer selItemIndex = List1.ListIndex If selItemIndex = -1 Then MsgBox "No item selected." Else List1.RemoveItem selItemIndex End If End Sub Private Sub List1_DblClick() Dim selItem As String selItem = List1.Text MsgBox "You selected: " & selItem End Sub Private Sub Form_Load() List1.AddItem "Elephant" List1.AddItem "Cheetah" List1.AddItem "Lion" List1.AddItem "Giraffe" List1.AddItem "Monkey" List1.AddItem "Boa Constrictor" List1.AddItem "Antelope" List1.AddItem "Water Buffalo" List1.BackColor = RGB(255, 255, 8) List1.ForeColor = RGB(0, 0, 255) Label1.Caption = "Enter a new item:" Command1.Caption = "Add New Item" Command2.Caption = "Remove All Items" Command3.Caption = "Remove Selected Item" Text1.Text = “Default Item” End Sub

16-10

Hoofdstuk 16, Objects and Controls After typing the source code, select the list box in the form by clicking it with your mouse. In the Properties window, set the list box’s Sorted property to True. You have to set the Sorted property in the Properties window because this property is read-only at runtime.

Finally, save your work, and run the program. When you do, the main window appears. This program puts a ListBox control through its paces.

Double-click an item in the list box, and a message box appears showing the item you picked. You can add your own items to the list box by typing the item into the text box and clicking the Add New Item button. You can clear all items from the list box by clicking the Remove All Items button. Finally, you can remove any single item from the list box by selecting the item in the list and clicking the Remove Selected Item button. This program demonstrates how to use many ListBox properties, methods, and events. Let’s take a look. First, the Form_Load procedure calls the AddItem method to 1oad items into the list box:

16-11


List1.AddItem ”Elephant” List1.AddItem ”Cheetah” List1.AddItem ”Lion” List1.AddItem ”Giraffe” List1.AddItem ”Monkey” List1.AddItem ”Boa Constrictor” List1.AddItem ”Antelope” List1.AddItem ”Water Buffalo”

As you can see, the AddItem method’s single argument is the text of the item to add to the list. Next, Form_Load sets the list box’s BackColor and ForeColor properties to yellow and: blue, respectively. List1.BackColor = RGB(255,255,0) List1.ForeColor = RGB(0,0,255)

It is the DblClick event procedure that displays the user’s selection. Private Sub List1_DblClick() Dim selItem As String selItem = List1.Text MsgBox ”You selected: ” & selltem End Sub

In this procedure, the program gets the selected item from the list box’s Text property, which holds the text of the selected item. The program then displays the text in message box. The Command1_Click procedure adds new items to the list. Private Sub Command1_Click() Dim newltem As String newItem = Text1.Text If newItem <> ”” Then List1.AddItem newltem End Sub

First, this procedure gets the text from the text box. The If statement ensures that the text box actually contains text before it adds the item to the list box. If the text box contains no text, the Text property returns an empty string, which you represent in a program by two double quotes with nothing between them. The Command2_Click event procedure gets the job of combo box, which it does by calling the list box’s Clear method. Private Sub Command2_Click() List1.Clear End Sub

Finally, the Command3_Click event procedure removes the selected item from the list. Private Sub Command3_Click() Dim selItemIndex As Integer selItemIndex = List1.ListIndex If selItemIndex = -1 Then MsgBox ”No item selected.” Else List1.RemoveItem selItemIndex End If End Sub

This procedure gets the index of the selected item from the list box’s ListIndex property. If this index is -1, the list box has no selected item, and the procedure shows a message box that presents the user with an error message. Otherwise, the procedure calls the list box’s RemoveItem method to remove the selected item from the list. This method’s single argument is the index of the item to remove.

16-12

SolidWorks API Deze sectie behandelt het gebruik van de SolidWorks Application Program Interface (API). De API is de verbinding tussen uw programma en het SolidWorks systeem. Het wordt gevormd door een (groot) aantal data-types en proceduredefinities. Ieder hoofdstuk behandeld een aspect aan de hand van een opdracht. De hoofdstuknummers van deze sectie zijn 17 t/m 29. Bijvoorbeeld het werken met attributen, het verwerken van items die door de gebruiker zijn geselecteert of het doorlopen van de feature tree.

API Inleiding

De API is een gereedschapskist voor softwareontwikkelaars. Honderden procedures geven de programmeur directe toegang tot SolidWorks functionaliteit. Bijvoorbeeld voor het creëren van een lijn, het extruderen van een boss of het verifiëren van de parameters van een vlak. In dit deel van de handleiding wordt u vertrouwd gemaakt met het bouwen van programma’s die de API aanroepen. Aan de hand van een groot aantal voorbeelden zullen verschillende functies van de SolidWorks API worden uitgelegd. Hoewel het ook mogelijk is programma’s te bouwen in Visual C++, beperkt het vak applicatiebouw zich tot Visual Basic en Excel. De onderwerpen die in deze sectie behandeld worden zijn: • Gebruik van Design Tables in Excel, • Opnemen van Macro’s en gebruik van de API Help, • Sketching in een tekening, • Genereren van een parts family vanuit berekende afmetingen, • Selecties behandelen in een programma, • Uitvoeren van selecties door een programma, • Attributen creëren en opvragen, • Attributen verzamelen, • Creëren van een Assembly, • Configureren van een Assembly, • Het doorlopen van de assembly datastructuur (traversal), • Tekeningen creëren, • Topology traversal. De gehele training is opgebouwd volgens een vast stramien. Er wordt begonnen met een bijna leeg programma, waar de tekst in staat wat er moet worden geïmplementeerd. Daarna wordt stap voor stap toegewerkt naar de volledige implementatie van bepaalde aspecten. Niet alles zal worden behandeld, omdat er dan te veel overlap ontstaat. Er wordt naar gestreefd de hoofdcommando’s zoveel mogelijk naar voren te laten komen.

Let op! Voor de meeste onderwerpen zijn twee Visual Basic projecten beschikbaar. Eén versie die als uitgangspunt dient voor de oefening, en een versie die uitgewerkt is als referentie. Kopieër voor u begint al het oefenmateriaal naar uw eigen werkgebied (op een netwerk disk?) en voer alle opdrachten en wijzigingen uit in uw eigen kopie. Het oefenmateriaal is beschikbaar op de project-PC’s en op de CAD/CAM web pagina’s. De PC-versie wordt in de handleiding aangeduid met ..\install_dir\VBasic\.. , u moet zelf even zoeken naar de exacte locatie op de C: schijf. De web pagina’s zijn bereikbaar via >> http://www.opm.wb.utwente.nl/onderwijs kijk verder onder Cad/Cam.

Hoofdstuk 17

Design Tables

Alle afmetingen van onderdelen worden in SolidWorks bepaald door parameters. Een parameter ontstaat wanneer u een maat (dimension) toevoegt. De waarde van een parameter kan altijd worden gewijzigd. Design Tables geven de mogelijkheid verschillende configuraties te bouwen van onderdelen of assemblies door zogenaamde driving parameterwaarden in te lezen uit een Microsoft Excel spreadsheet. In deze oefening wordt u geleerd om te gaan met design tables. Daarbij worden vaardigheden geleerd als:

Dimensies hernoemen, Design Tables maken, Design Tables invoegen, Design Tables aanpassen, Configuraties gebruiken.

17-1

Hoofdstuk 17, Design Tables

Dimensies hernoemen 1. Voor de oefeningen zijn een aantal bestanden beschikbaar. Kopieer vooraf de VBasic folder naar uw eigen werkgebied en gebruik verder deze kopie.

2.

3.

4. 5.

17-2

Kopieer de folder ..\Install_dir\VBasic naar uw werkgebied en open uit de gekopieerde folder ..\VBasic\Design Tables het bestaande part Part_Design_Table.sldprt. Edit de sketch Pakking. De dimensies, zoals in nevenstaand figuur, komen in beeld. Tussen haakjes is weergegeven de naam van de desbetreffende dimensie. (zo niet: click Tools, Options, General en selecteer Show dimension names). Deze zullen worden gebruikt in de design tables. Verander de naam van de dimensie die de afstand tussen de twee gaten aangeeft (**) in AfstandCenters. Doe dit door de dimensie te selecteren en de properties te veranderen (via rechter muisknop menu).

Bij Full name is te zien wat de syntax is van de dimensienaam: [Name]@[naamsketch]. Save het aangepaste part onder de naam Pakking. Laat het programma SolidWorks met de Pakking actief en start Microsoft Excel op.


Design Tables aanmaken 1.

Open een nieuw werkblad in Excel en voer de informatie in, zoals hieronder is weergegeven. In de eerste rij moeten de dimensienamen van de SolidWorks part worden opgenomen, in de volgende rijen staan de variant-namen en de bijbehorende parameterwaarden.

2.

Zoek in de Pakking.sldprt de dimensienaam ‘D1@Dikte’ op. Hint: Kijk bij de Edit Dimension Access, zie figuur.

3.

Save de spreadsheet onder de naam ‘Pakking.xls’ in je werkdirectory en sluit Excel.

4.

Ga terug naar de part Pakking in SolidWorks.

De maten zijn in millimeters.

Invoegen Design Tables 1.

Click Insert, Design Table. De Design Table PropertyManager verschijnt.

2.

Selecteer de From file optie, click Browse en open de Pakking.xls spreadheet.

3.

Click OK

.

17-3

Hoofdstuk 17, Design Tables 4.

Het excelbestand wordt zichtbaar in je part. In dit excelbestand kan, net als in Excel zelf, gewoon gewerkt worden. Door in het part ergens te clicken zal het excel bestand weer verdwijnen. Op elk gewenst moment kan het ook weer worden opgeroepen, hetgene later aan de orde zal komen.

Wanneer alle dimensienamen uit de spreadsheet (kolom 1) herkend worden door SolidWorks, worden de drie configuraties aangemaakt.

17-4

5.

Behalve dat het excelbestand zichtbaar wordt, lijkt er weinig veranderd te zijn. Echter, naast de Default configuratie zijn de drie afmetingen nu ook als configuraties opgenomen. Dit is zichtbaar te maken door het Configuration-tablad te selecteren onderaan de window van de FeatureManager design tree.

6.

Double click op Variant 1 en kijk wat er gebeurt. Doe dit ook voor de andere configuraties.


Design tables aanpassen Eenmaal ingevoegde design tables kunnen altijd worden aangepast. 1. 2.

Click Edit, Design Table, Edit Table. Het excelbestand verschijnt weer zoals we het eerder hebben ingevoerd. Verander een aantal waarden en kijk wat het effect daarvan is. Om de nieuwe variant te activeren, moet je buiten de Excel sheet clicken.

Via een design table is het ook mogelijk modelfeatures, sketches en reference geometry te onderdrukken. Daartoe moet in een kolomhoofd de volgende syntax worden opgenomen: $STATE@feature. Waarbij feature de naam is van het feature dat al of niet onderdrukt moet worden. Voordat getoond kan worden hoe dit feature onderdrukken in zijn werk gaat, moet er eerst een feature gemaakt worden in ons part. Als voorbeeld creëren we een extra gat in de pakking. 3.

Selecteer het bovenvlak van de pakking en geef de positie aan waar het gat moet komen.

4.

Click Simple Hole , zoals voorgedaan in bovenstaande plaatje. Geef een diameter op van 10 mm. Laat het gat door de hele dikte van de pakking gaan (through all).

5.

Selecteer de Hole feature in de design tree met een rechtermuis click. Selecteer Edit Sketch. Positioneer het gat volgens onderstaand figuur en verander de dimensienamen zoals is weergegeven (via de properties).

6.

Save het part onder de naam ‘Pakking_met_feature’.

7.

Click op Edit, Design Table,

17-5

Hoofdstuk 17, Design Tables Edit Table.

8.

Vul de kolommen H,I en J in, zoals is weergegeven. In kolom J kan worden aangegeven of het feature Hole1 wel of niet onderdrukt moet worden in het part; suppressed (S) of unsuppressed (U).

9.

Bekijk de verschillende configuraties.

10. Verander (Edit, Design Table, Edit Table) de afronding van de zijkant van de pakking (AfrondingZij@Pakking) door in cel C2 de waarde 30 mm te veranderen naar 40. Het feature Hole1 blijkt niet meer netjes aan de rand te zitten. Om dit te voorkomen kunnen in de spreadsheet relaties tussen cellen onderling worden opgegeven. 11. Verander nu de dimensie in de Design Table die deze afstand bepaalt (Afstand@Sketch1) zó, dat deze waarde gekoppeld is aan de straal van desbetreffende afronding.

12. Probeer verschillende waarden voor de afronding (cel C2) en bekijk het effect. Doe hetzelfde voor de overige varianten. 13. Save en sluit het aangepaste part.

17-6

Hoofdstuk 18

Macro’s en API Help

In dit hoofdstuk wordt een inleiding gegeven over het gebruik van de SolidWorks macro faciliteiten. In een macro kunnen een aantal standaard handelingen worden vastgelegd. In plaats van steeds weer de zelfde reeks commando’s te geven, kan een gebruiker een opgenomen macro starten. De macro taal van SolidWorks is (niet toevallig) dezelfde als de API-programmeer taal: Visual Basic. Doormiddel van het opnemen van macro’s is dus een goed inzicht te krijgen in de programmastructuur van verschillende programma’s. Met behulp van een voorbeeld wordt uitgelegd hoe u macro’s kunt opnemen en afspelen. U maakt kennis met eenvoudige Basic programma’s die via API-aanroepen opdrachten aan Sworks geven. De volgende onderwerpen komen in dit hoofdstuk aan de orde:

Opnemen van Macro’s, Afspelen van Macro’s, Gebruik van de API Help.

U leert om te gaan met macro’s door ze zelf op te nemen en vervolgens de opgenomen code te bekijken en te veranderen.

18-1

Hoofdstuk 18, Marco’s an API Help

Opnemen en afspelen van Macro’s In deze paragraaf wordt het opnemen, het veranderen en afspelen van macro’s in SolidWorks behandeld. Ook wordt uitgelegd hoe informatie uit de API Help file gebruikt kan worden. 1. 2. 3. 4. 5.

6.

Open de API Help files van SolidWorks via de SolidWorks menubalk: Help, SolidWorks API Help Topics

18-2

Start SolidWorks en select Tools, Macro, Record. Open een nieuw part en teken in het vlak plane 1 een rechte lijn. Stop het opnemen van de macro door op de Stop button in de macrotoolbar te clicken. Save de macro in je eigen werkdirectory. Bekijk de zojuist opgenomen macro via Tools, Macro, Edit en kies de juiste file. Is te achterhalen wat hiervoor is opgenomen?

Open de SolidWorks API Help documentatie. Selecteer de Index-tab en type in “NewDocument”.


Iedere keer dat SolidWorks een nieuw part opent, krijgt het part een naam met een oplopend volgnummer.

7. Ga nu terug naar SolidWorks en sluit alle parts (maar niet het programma). Probeer nu de opgeslagen macro te runnen via Tools, Macro, Run. Merk op dat de macro een foutmelding geeft. Maak de macro meer algemeen toepasbaar door regel 19 te verwijderen (de geselecteerde regel in het plaatje bij punt 5): ‘Set Part = swApp.ActivateDoc ("Part1")’. Run de macro nu opnieuw en merk op dat er een nieuwe part-window wordt gecreëerd. Waarom lukt het nu wel? 8. Save the macro onder een andere naam in de werkdirectory. 9. Probeer nu de macro te runnen door, in plaats van de lijn 13 te verwijderen, in de code het eerst volgende Part-nummer op te nemen. Als het juiste nummer is opgenomen, doet de macro het wel. 10. Merk op dat de knoppen van de Macro toolbar dezelfde functie hebben als in het macro menu. 11. Creëer een meer complexe macro, waarbij meer handelingen worden verricht. Vergelijk de gecreëerde code met de code die over het betreffende onderdeel te vinden is in de help file. Plaats bijvoorbeeld een cirkel met als middelpunt het eindpunt van de eerste lijn.

18-3


API Documentatie De volledige API documentatie is te vinden onder ..\lang\apihelp.chm in de SolidWorks installatie directory. . 1. Lokaliseer de apihelp file en open het bestand door een double click op Wanneer je een specifieke functionaliteit zoekt, terwijl de functienaam niet bekend is, is het gebruik van de Index-tab van de API help documentatie en enkele kernwoorden de snelste manier om de functie te vinden. 2. Zoek de functie op om een lijn te creëren door in te typen “Create Line”.

De eerste keer dat een Find commando wordt gebruikt, wil het systeem een index creeren: dat mag.

3.

Als blijkt dat de Index-tab niet de gewenste informatie oplevert, kan de Find-tab geraadpleegd worden, deze zoekactie neemt echter meer tijd in beslag. Zoek via de Find-tab informatie op over het concentrisch maten in een assembly.

4.

Deze zoekfunctie lokaliseert de AssemblyDoc::AddMate functie. Click op Display en bekijk het informatie scherm. Via de Find-tab kunnen ook complete programmeer voorbeelden gevonden worden. Deze voorbeelden kunnen als basis dienen voor hetgeen dat geprogrammeerd moet worden.

18-4

5.

Zoek onder ‘Selectionmanager’ naar het voorbeeld (VB) over het creëren van een lijn en bekijk de code.

6.

Bekijk ook andere voorbeelden!

Hoofdstuk 19

Sketching

In dit hoofdstuk wordt er stap voor stap aangegeven hoe de toevoeging van tekst en geometrie aan een sketch of tekening in zijn werk gaat. Een en ander wordt uitgelegd aan de hand van het invoegen van een ruwheidsymbool in een SolidWorks tekening (drawing!) met behulp van een Visual Basic programma. De volgende stappen komen hierbij aan de orde:

Openen Visual Basic project, Uitleg Programma Structuur, Eerste Run Programma, Uitbreiden van het Programma.

U leert een programma te ontwikkelen waarmee verschillende ruwheidsymbolen in een SolidWorks drawing kunnen worden getekend. Door een click op de gewenste afbeelding en het aangeven van een locatie in een tekening in SolidWorks, komt er in de tekening een ruwheidsymbool te staan. In de volgende paragrafen wordt duidelijk hou het programma tot stand komt

19-1

Hoofdstuk 19, Sketching

Open a Visual Basic Project De manier van programmeren en de link naar SolidWorks wordt uitgelegd aan de hand van een reeds opgezet Visual Basic programma. Het is de bedoeling dat deze zogenaamde startcode stap voor stap wordt uitgebreid tot een goed werkende applicatie. Voor deze oefening zijn twee VB projecten beschikbaar. Eén versie in Sketching\Start en één in Sketching\Finish Kopieer vooraf de VBasic folder naar uw eigen werkgebied en gebruik verder deze kopie.

Kopieer de folder ..\Install_dir\VBasic naar uw werkgebied en start Visual Basic. Open het bestaand project RoughnessSymbols.VBP uit de gekopieerde directory ..\VBasic\Sketching\Start.. 1. Click File, Open project, RoughnessSymbols.VBP Als het onderstaand window niet zichtbaar is, open de project explorer.

2. Click View, Project Explorer Open het RoughnessSymbols.frm door erop te double clicken. De form van de bedieningsdialog verschijnt.

Het bestaande programma bevat al een basiscode. De code die bij de dialog hoort, kan in beeld gebracht worden door ergens op de form te double clicken. 3.

Double click op . De programma tekst die nu verschijnt is de code, waarmee verder gewerkt wordt.

Dit is het frame van het programma. Door het toevoegen van programmaregels (code) bouwt u het om tot een werkende applicatie. Allereerst volgt er een uitleg over de code die in het frame verwerkt is.

19-2


Uitleg Programma Structuur In deze paragraaf worden de belangrijkste programma structuren behandeld om een applicatie te gaan bouwen voor SolidWorks. Er kan namelijk pas begonnen worden met het programmeren als duidelijk is hoe de startcode is opgebouwd.

Variabele Declaratie Dim swApp As Object Dim Part As Object

Het Dim statement heeft als functie een variabele te definiëren: Dim [yourVariableName] As [Type] Voor ‘yourVariableName’ dien je een naam ter identificatie van een variabele in te vullen. Hier is gekozen voor swApp wat een afkorting is voor SolidWorks Application en Part omdat we een ruwheidsymbool aan een onderdeel van een tekening gaan toevoegen. Voor As[Type] kan ingevuld worden wat voor type aan de variabele moet worden toegekend. In onze applicatie kiezen we voor het type ‘Object’.

Constante Declaratie Dim swApp As Object Dim Part As Object Const swDocPART = 1 Const swDocASSEMBLY = 2 Const swDocDRAWING = 3

' Deze definities zijn volgens de typenamen zoals ' gedefinieerd in \SldWorks\samples\appComm\swconst.h

‘Const’ is een constante, een verwijzing naar een waarde die nooit verandert. Constanten worden meestal gebruikt om het programma duidelijker te maken. De volgende definities zijn hier van belang; deze en andere zijn te vinden in de directory \SldWorks\samples\appComm\swconst.h (te openen met Notepad). Document Types swDocNONE = 0 swDocPART = 1 swDocASSEMBLY = 2 swDocDRAWING = 3

// geen actief document // actieve document is een PART // actieve document is een ASSEMBLY // actieve document is een DRAWING

Privat Procedure Dim swApp As Object Dim Part As Object Const swDocPART = 1 Const swDocASSEMBLY = 2 Const swDocDRAWING = 3


Private Sub Picture1_Click()

Hier wordt een begin gemaakt met de code van de eerste picture, waarmee het ruwheidsymbool getekend wordt. Dit is een Private procedure, dat betekent dat de procedure alleen toegankelijk is vanuit deze module en niet van buitenaf.

19-3


Set-functie Dim swApp As Object Dim Part As Object Const swDocPART = 1 Const swDocASSEMBLY = 2 Const swDocDRAWING = 3


Private Sub Picture1_Click() Set swApp = CreateObject("SldWorks.Application") Set Part = swApp.ActiveDoc ' Gebruik een geopend document in SolidWorks.

Hier worden met behulp van de Set-functie de objecten geïnitialiseerd.

Messagebox Dim swApp As Object Dim Part As Object Const swDocPART = 1 Const swDocASSEMBLY = 2 Const swDocDRAWING = 3


Private Sub Picture1_Click() Set swApp = CreateObject("SldWorks.Application") Set Part = swApp.ActiveDoc ' Gebruik een geopend document in SolidWorks. MsgBox "Put your code here to generate the Picture1 item" End Sub

De ‘MsgBox’-functie heeft als resultaat een messagebox waarin de opgegeven tekst verschijnt. De gebruiker kan slechts op ‘OK’ drukken.

19-4


Eerste Run Programma Nu de programma structuur bekend is gaan we, zonder er iets aan te veranderen, kijken wat het programma doet. Dit kunt u controleren door de code te runnen. Dit doet u door het play-knopje boven in de taakbalk aan te klikken. (play). De onderstaande dialog verschijnt

1.

Click

2. 3.

Click op het eerste plaatje . De volgende messagebox verschijnt op het scherm. Vergelijk de tekst in de box met de code zoals in de vorige paragraaf is geprogrammeerd. Stop het programma door op de Stop knop in de taakbalk te klikken.

4.

In de volgende paragrafen wordt de begincode aangepast teneinde aan een bestaande tekening daadwerkelijk een oppervlakteruwheidsymbool toe te voegen door middel van een simpele muisclick.

19-5


Uitbreiden van het Programma Nu duidelijk is wat de basis-code betekent, kan er een begin gemaakt worden met de uitbreiding tot een goed werkende applicatie. Omdat de implementatie voor , het derde symbool, de meest uitgebreide van de drie is, wordt deze code stap voor stap gerealiseerd. De code voor de andere twee symbolen komen op vergelijkbare wijze tot stand. Omdat we uitgaan van het bestaande bestand, moet eerst het bestand opgeslagen worden onder een andere naam. 1.

Open het bestaande RoughnessSymbols.vbp en Save as RoughnessFINAL.vbp in je eigen werkdirectory.

Doel implementatie Het is de bedoeling dat dit symbool: na aanklikken van picture3, verschijnt op een geselecteerd punt in de drawing van SolidWorks. Er wordt begonnen met het dimensioneren van het symbool. Naast het geselecteerde punt is er nog een gegeven noodzakelijk voor de dimensionering van het ruwheidsymbool: de grootte van het symbool. De tekst die moet worden toegevoegd komt later aan de orde. Het teken zal worden geconstrueerd met behulp van 3 punten: het punt dat wordt geselecteerd en de twee eindpunten van de schuine lijnstukken. Het selectiepunt wordt gedimensioneerd als Variant omdat dit de meeste bewegingsvrijheid oplevert, m.a.w. er zijn geen restricties. Voor de horizontale lijn zijn geen extra punten nodig. Voor elk van de twee eindpunten zijn de x- en y- coördinaten benodigd, deze worden gedimensioneerd als Double. Het verschil tussen Single en Double is dat de laatste nauwkeuriger is (omvat een grotere deelverzameling) dan de eerste.

Implementatie 1. 2.

Ga naar de Private Sub Picture3_Click(). Dimensioneer daar de volgende variabelen. Dim PickPt As Variant Dim x2, y2, x3, y3 As Double Dim textX, textY As Double Dim TextHeight As Double

3.

‘Door de gebruiker geselecteerde punt ‘Eindpunten van de lijnen ‘Positie van de Tekst ‘De afmetingen van de tekst

Het is netjes de gebruiker te laten weten wanneer er geen SolidWorks document actief is. Dit is de volgende stap. Implementeer dit als volgt in VB: If Part Is Nothing Then Msg = "No document loaded or program attaching to different SolidWorks session!" Style = vbExclamation Title = "BOM" Call MsgBox(Msg, Style, Title) Exit Sub End If

4.

19-6

Save de tot dusver gecreëerde code en run het. Bekijk de MessageBox die in beeld verschijnt op het moment dat een ruwheidsymbool wordt aangeclickt. Probeer deze box te verklaren aan de hand van de zojuist geprogrammeerde code.

Hoofdstuk 19, Sketching 5.

Vervolgens moeten ervoor gezorgd worden, dat het geselecteerde lijnstuk (waar het ruwheidsymbool opgeplaatst moet worden) toegankelijk wordt. Hierbij wordt gebruik gemaakt van de SelectionManager. Set SelMgr = Part.SelectionManager

6.

Wanneer getracht wordt het symbool niet in een SolidWorks tekening te maken, dient een bericht in beeld te verschijnen waarin wordt duidelijk gemaakt, dat alleen tekst aan een ‘SW-tekening’ kan worden toegevoegd. If (Part.GetType <> swDocDRAWING) Then swApp.SendMsgToUser ("Can only add text to drawings") Exit Sub End If

7.

We gaan nu bekijken hoe we informatie rechtstreeks naar de SolidWorks database kunnen schrijven. Dit is noodzakelijk om het zogenaamde ‘entity & grid snapping’ te voorkomen. Een voorbeeld hiervan is dat een eindpunt van een getekende lijn naar een eindpunt van een andere lijn, of gridpoint, ‘snapt’. Door de SetAddToDB-functie te gebruiken wordt dit gedrag voorkomen. Part.SetAddToDB (True)

8.

De volgende stap is het bepalen van de coördinaten van het punt op de geselecteerde lijn waar het ruwheidsymbool moet komen. De SelectionManager kent daar een functie voor: PickPt = SelMgr.GetSelectionPointInSketchSpace (1)

9.

‘Get the user’s pickpoint coordinates

Het is uiteraard niet de bedoeling een ruwheidsymbool te plaatsen in een tekening zonder dat er een plek is geselecteerd. De bedoeling is dat er weer een boodschap in beeld verschijnt wanneer er geen lijn is geselecteerd. If (SelMgr.GetSelectedObjectCount = 0) Then swApp.SendMsgToUser ("Select a Location first...")

Het bericht dat de gebruiker krijgt ziet er dan als volgt uit:

10. Wanneer wel een locatie is geselecteerd (Let op: denk aan uitbreiding van het Ifstatement met een ‘Else’.), dan is het nu de bedoeling het symbool te gaan dimensioneren. Maak hierbij gebruik van de eerder gedefinieerde variabelen. De dimensionering (in mm) van het symbool is als volgt: Dit gaat als volgt te werk (waarbij u zelf de juiste waarden in dient te vullen): Let op: de API werkt in meters! Wanneer het runnen van de code vreemde afmetingen oplevert, kijk eens naar de gebruikte eenheden in SolidWorks.

Punt1: (x1,y1) = (0,0) Punt2: (x2,y2) = (5,10) Punt3: (x3,y3) = (-2.5,5) Else x2 = PickPt(0) + 0.005 y2 = PickPt(1) + 0.01 x3 = PickPt(0) - 0.0025 y3 = PickPt(1) + 0.005

11. De volgende, logische, stap is het tekenen van het symbool. De volgende standaard syntax wordt gebruikt:

19-7

Hoofdstuk 19, Sketching Part.CreateLineVB x1, y1, z1, x2, y2, z2 Part.CreateCircleVB x0, y0, z0, r (hier niet van toepassing) Hierbij geeft (x1, y1, z1) het startpunt van de lijn aan en (x2, y2, z2) het eindpunt. Bij de cirkel is het punt (x0,y0,z0) de oorsprong en r de straal. De variabelen van de lijn of cirkel moeten gedeclareerd zijn als Double. Hierbij dient u wel te bedenken dat (x1, y1, z1) in ons geval het PickPt is. Part.CreateLineVB PickPt(0), PickPt(1), 0#, x2, y2, 0# Part.CreateLineVB PickPt(0), PickPt(1), 0#, x3, y3, 0# Part.CreateLineVB x3, y3, 0#, (x3 + 0.005), y3, 0#

12. Sluit het If-Else-statement af met door onderaan de laatst gecreëerde code End If op te nemen. End If 13. Save en Run de tot nog toe gemaakte code.

Tekst toevoegen U heeft nu een code geschreven waarmee een ruwheidsymbool aan een actief SolidWorks document kan worden toegevoegd. Nu dienen we nog een tekst toe te voegen aan dit symbool. Eerste stap is het invoeren van een ‘text’-button in VisualBasic. Vervolgens definiëring van de drie benodigde variabelen ter dimensionering van de in te voegen tekst: Teksthoogte: Positie in x richting Positie in y richting 14. Voegen de volgende regels toe aan het laatste Else-statement om de tekst in te voegen: TextHeight = 0.0015 TextX = (x3 - 0.0005) TextY = (y3 + (3 * TextHeight))

15. Neem nu in het Else-statement de code op om de tekst te creëren. Part.CreateText NN, textX, textY, 0#, TextHeight, 0# U heeft nu een werkende SolidWorks applicatie geschreven in VisualBasic. Wanneer u echter gaat testen met dit programma is het mogelijk dat de tekst niet op de juiste plaats komt te staan. Dit probleem wordt veroorzaakt door de schaal van de actieve sheet in de drawing. Het probleem is, dat de commando’s PickPt en CreatelineVB wel rekening houden met de schaal van de drawing, maar Createtext hier geen rekening mee houdt. Dus wanneer u bijvoorbeeld een schaal hanteert van 1:2 zullen TextX en TextY twee keer te groot zijn. Om dit probleem op te lossen moeten ook de volgende drie regels worden ingevoegd. Op positie 2 en 3 in de Getproperties staan de waarden van de schaal van de drawing. Bijvoorbeeld bij een schaal van 12:45 heeft SheetProps(2) de waarde 12 en SheetProps(3) de waarde 45. Er is nu nog een stap nodig om de applicatie compleet te maken. 16. Neem onderstaande code op in de plaats van de code gecreëerd in stap 14 (in verband met de ‘Schaal’-factor). Set sheet = Part.GetCurrentSheet SheetProps = sheet.GetProperties Scaling = SheetProps(2) / SheetProps(3) TextHeight = 0.0015 textX = (x3 - 0.0005) * Scaling textY = (y3 + (3 * TextHeight)) * Scaling

19-8


Test van het Programma 17. Save de applicatie en run deze om de juiste werking te controleren. • SolidWorks moet actief zijn, • Het current document (gekleurde title bar) in SolidWorks moet een sketch zijn, • In de sketch moet een punt zijn geselecteerd (licht groen op), • Start uw programma met het Run commando in Visual Basic, • De dialoog komt op het scherm, • Click op het gewenste symbool. 18. Probeer nu zelf nog wat aanpassingen aan te brengen om goed thuis te raken in de Visual Basic en de interactie met SolidWorks.

19-9


Hieronder staat het totale programma voor Private Sub Picture3_Click() Private Sub Picture3_Click() Dim PickPt As Variant Dim x2, y2, x3, y3 As Double Dim textX, textY As Double Dim TextHeight As Double Set swApp = CreateObject("SldWorks.Application") Set Part = swApp.ActiveDoc If Part Is Nothing Then Msg = "No document loaded or program attaching to different SolidWorks session!" Style = vbExclamation Title = "BOM" Call MsgBox(Msg, Style, Title) Exit Sub End If Set SelMgr = Part.SelectionManager If (Part.GetType <> swDocDRAWING) Then swApp.SendMsgToUser ("Can only add text to drawings") Exit Sub End If Part.SetAddToDB (True) PickPt = SelMgr.GetSelectionPointInSketchSpace(1) If (SelMgr.GetSelectedObjectCount = 0) Then swApp.SendMsgToUser ("Select a Location first...") Else x2 = PickPt(0) + 0.005 y2 = PickPt(1) + 0.01 x3 = PickPt(0) - 0.0025 y3 = PickPt(1) + 0.005 Part.CreateLineVB PickPt(0), PickPt(1), 0#, x2, y2, 0# Part.CreateLineVB PickPt(0), PickPt(1), 0#, x3, y3, 0# Part.CreateLineVB x3, y3, 0#, (x3 + 0.005), y3, 0# Set sheet = Part.GetCurrentSheet SheetProps = sheet.GetProperties Scaling = SheetProps(2) / SheetProps(3) TextHeight = 0.0015 textX = (x3 - 0.0005) * Scaling textY = (y3 + (3 * TextHeight)) * Scaling NN = "N" + NValue.Text Part.CreateText NN, textX, textY, 0#, TextHeight, 0#

' Grab text from "Set Value" text box ‘ Create string Nx ‘ Put text on the symbol

End If End Sub

19. Probeer aan de hand van de geschreven code, de andere twee ruwheidsymbolen ook te implementeren. 20. Ter controle en als hulp is de juiste code opgenomen in ..\Vbasic\Sketching\Finish\..

19-10

Hoofdstuk 20

Besturing van Dimensies

In dit hoofdstuk wordt een voorbeeld behandeld van het werken met onderdelen familie’s. Het idee is dat slechts één tekening gemaakt wordt, waaruit een familie van parts kan worden gegenereerd met behulp van een tabel met parameter waarden. Het veranderen van de parametrische waarden van de dimensies is voldoende om een familie lid te wijzigen. In dit hoofdstuk komen de volgende stappen aan de orde:

Creëren van een Design Table, Aanpassen van een Design Table Opnemen van Excel Sheet in SolidWorks Part, Opnemen van SolidWorks Part in Excel Sheet.

U leert een programma te ontwikkelen in Excel om onderdelenfamilies te maken van het reeds bestaande Camera.prt. Door middel van een Excel sheet moeten dimensies van de camera part eenvoudig veranderd kunnen worden.

20-1

Hoofdstuk 20, Besturing van Dimensies

Openen Bestaande Documenten Het besturen van dimensies wordt in dit hoofdstuk uitgelegd aan de hand van een voorbeeld. Door een reeds bestaand project te gebruiken, kan er stap voor stap toegewerkt worden naar de gewenste applicatie. Het onderdeel dat gebruikt wordt, heet Camera.prt. De dimensies worden veranderd met behulp van een macro in de Excel sheet Body.xls Voor deze oefening zijn twee VB projecten beschikbaar. Eén versie in Camera\Start en één in Camera\Finish Kopieer vooraf de VBasic folder naar uw eigen werkgebied en gebruik verder deze kopie.

Allereerst een overzicht van de te gebruiken bestanden. Deze oefening is niet gericht op het zelf programmeren maar op het begrijpen van de software. Wanneer u het programma goed begrijpt, is het oplossen van de problemen die er in voorkomen relatief eenvoudig. 1. Kopieer de folder ..\Install_dir\VBasic naar uw eigen werkgebied wanneer u dat nog niet heeft gedaan, 2. Open in ..\Vbasic\Camera\Start de Excel sheet Body.xls 3. Camera.sldprt moet niet geopend worden, de tekening is hieronder al gegeven.

Uitleg Programma Structuur In deze paragraaf worden de belangrijkste programma structuren behandeld om een applicatie te gaan bouwen in Excel in samenwerking met SolidWorks.

Openen van de Programma Structuur 1. 2. 3.

20-2

Ga naar Excel. Click Tools, Macro, Macros…. Click daarna op de Edit knop in de Macro dialog.

Hoofdstuk 20, Besturing van Dimensies 4.

Het resultaat van de bovenstaande acties is de toegang tot de code die wordt gerund wanneer de Solve knop in het Excel bestand wordt gebruikt.

Variabelen en Constanten Declaratie De declaratie van variabelen en constanten is in het vorige hoofdstuk al besproken. Dit is de reden dat we de bespreking hier achterwege laten en slechts het lijstje laten zien. Dim App as Object Dim Part as Object Dim thedimension as Object.

Verbinding Excel & SolidWorks Dim App as Object Dim Part as Object Dim thedimension as Object. Set App = CreateObject("SldWorks.Application") App.Visible = True Set Part =App.ActiveDoc

‘Verbinding Excel & SolidWorks’ ‘Maakt dat het SolidWorks part, dat op dat moment actief is, het model wordt waarin we gaan werken.’

Het eerste commando creëert een link naar SolidWorks. In de derde regel wordt de variabele Part gelijk gesteld aan App.ActiveDoc. Dat wil zeggen dat de waarden die part krijgt gelijk is aan de waarden van het actieve part in SolidWorks. Er volgt een foutmelding als er geen part in SolidWorks is geopend. De tweede regel App.Visible = True zorgt ervoor dat het herbouwde part straks zichtbaar is. Als deze boolean de waarde False zou hebben, dan zal het nieuw gecreëerde part niet zichtbaar zijn na de rebuild.

20-3


Dimensies aanpassen In de volgende stap krijgen de variabelen, die de grootte van de dimensie representeren, de gewenste waarde. Dim App as Object Dim Part as Object Dim thedimension as Object. Set App =CreateObject("SldWorks.Application") Set Part =App.ActiveDoc

‘Verbinding Excel & SolidWorks ‘Maakt dat het SolidWorks part, dat op dat moment actief is, het model wordt waarin we gaan werken.

Set theDimension = Part.parameter(“D1@sketch1”) theDimension.SystemValue= Range(”C3”).Value / 1000 * 25.4 Set theDimension = Part.parameter(“D2sketch1”) theDimension.SystemValue= Range(”D4”).Value / 1000 * 25.4 Vergelijk de syntax van de dimensienaam met de eerder behandelde Design Tables.

‘Dimensie beheersing ‘Dimensie beheersing

Door theDimension gelijk te stellen aan Part.parameter(“D1@sketch1”) kan de waarde van deze dimensie, D1@sketch1 worden veranderd. In de volgende regel wordt dat dan ook gedaan. Hier krijgt theDimension.SystemValue de waarde van de cel C3 in de actieve Excel sheet Body.xls. Hetzelfde gebeurt in de twee volgende regels voor de waarde van de dimensie D2@sketch1. Het getal waardoor gedeeld wordt is de omrekenfactor van inches naar millimeters.

Herbouwen van de Part De waarden van de variabelen die de dimensies representeren zijn nu wel correct, maar moeten nu ook nog op het scherm en in de part file komen te staan. Met behulp van het onderstaande commando worden het plaatje op het scherm en de part file aangepast. Dim App as Object Dim Part as Object Dim thedimension as Object. Set App = CreateObject("SldWorks.Application") Set Part =App.ActiveDoc Set theDimension = Part.parameter(“D1@sketch1”) theDimension.SystemValue= Range(”C3”).Value / 1000 * 25.4 Set theDimension = Part.parameter(“D2sketch1”) theDimension.SystemValue= Range(”D4”).Value / 1000 * 25.4 Part.EditRebuild

‘Verbinding Excel & SolidWorks’ ‘Maakt dat het SolidWorks part, dat op dat moment actief is, het model wordt waarin we gaan werken.’ “Dimensie waarde toekenning” “Dimensie waarde toekenning” ‘Rebuild het onderdeel in SolidWork’

Runnen van het programma 2.

Om de macro te runnen kunt u op de play knop in VB clicken of u sluit VB af en klikt op de Solve knop in Excel, De volgende fout melding komt te voorschijn. Waarom ?

3. 4.

Click End en open Camera.prt in SolidWorks Run nu nogmaals de macro.

1.

20-4


Opnemen van Excel Sheet in SolidWorks Part In deze paragraaf wordt uitgelegd hoe een Excel sheet direct in SolidWorks kan worden opgenomen en geactiveerd door middel van design tables. 1. Sluit Body.xls in Excel. 2. Open camera.prt in Solidworks. 3. Click Insert, Design Table. 4. Selecteer From File en click Browse om Body.xls te open. 5. Click OK.

Om de Design Table te veranderen kunt u de volgende procedure hanteren: 6. Click Edit, Design Table, Edit Table. 7. Verander de waarden. 8. Click Solve.

Opnemen van Solidworks Part in Excel Sheet In de vorige paragraaf is uitgelegd hoe een Excel tabel opgenomen en veranderd kan worden in een SolidWorks part, maar het is ook andersom mogelijk: 1. Sluit Camera.prt in Sworks en SolidWorks nu af 2. Open Body.xls in Excel 3. Click Insert, Object, 4. Selecteer dan Create from file.

20-5

Hoofdstuk 20, Besturing van Dimensies 5. 6. 7.

Om Camera.prt te selecteren kunt u browsen. Verander een aantal waarden. Click op de Solve button. Dit gaat niet goed.

Wederom is er geen part actief binnen SolidWorks. Om het geïmporteerde part actief te maken in SolidWorks kunnen de volgende regels worden toegevoegd aan het programma. ActiveSheet.Shapes("Object 1").Select Set App = CreateObject("SldWorks.Application") App.Visible = True Selection.Activate Set Part = App.ActiveDoc

De eerste regel zorgt er voor dat het geïmporteerde part wordt geselecteerd. Dit is nodig om in de vierde regel de selectie te kunnen activeren. Hierdoor is camera.prt actief in SolidWorks en dat is precies wat we nodig hebben. Noot: In de eerste regel wordt object 1 geselecteerd. Dit is de naam van het geïmporteerde part. Wanneer het niet het eerste part is dat is geïmporteerd werkt de macro niet, ook al zijn de vorige objects verwijderd. Dit komt omdat de naam van het part dan object2 of object3 of ... is.

20-6

Hoofdstuk 21

Selecties behandelen

Het komt regelmatig voor, dat er een aantal handelingen moeten worden toegepast op een set onderdelen die door de gebruiker zijn geselecteerd. In dit hoofdstuk wordt stap voor stap aangegeven hoe u toegang krijgt tot een set geselecteerde vlakken en hoe de materiaaleigenschappen zoals kleur en transparantie van deze oppervlakken bestuurd kunnen worden. De volgende onderwerpen komen hierbij aan de orde:

Gebruik van Modules, Selectie Management, Opvragen Materiaal Eigenschappen, Definiëren Materiaal Eigenschappen.

U ontwikkelt een Visual Basic programma dat een functioneel Material Properties Window op het scherm laat zien. Wanneer u op de Get Properties button clickt moet het programma de huidige waarden van de gelecteerde oppervlakken in het actieve part in SolidWorks inlezen en de sliders op de juiste waarde zetten. De waarden van de sliders moeten veranderd kunnen worden, zodat andere gewenste materiaal eigenschappen geselecteerd kunnen worden. Deze instellingen moeten vervolgens weer eenvoudig kunnen worden toegepast op de geselecteerde oppervlakken van het SolidWorks part door op de Set Properties button te clicken.

21-1

Hoofdstuk 21, Selecties behandelen

Open Visual Basic Project Er wordt weer vanuit een basis code gewerkt naar het geïmplementeerde Visual Basic programma, waarbij stap voor stap de belangrijkste commando’s de revue zullen passeren. Voor deze oefening zijn twee VB projecten beschikbaar. Eén versie in Colors\Start en één in Colors\Finish. Kopieer vooraf de VBasic folder naar uw eigen werkgebied en gebruik verder deze kopie.

Start Visual Basic en open het bestaand project Colors.VBP onder uw werkdirectory te vinden in ..\VBasic\Colors\Start\.. 1. Click File, Open project, Colors.VBP 2. Click View, Project Explorer Zoals is te zien in het onderstaande window, bestaat het project uit een form en een Module. De functie van de form is niet anders dan in de voorgaande projecten, maar de module verdient wat extra aandacht.

Gebruik van Modules In het algemeen worden modules gebruikt om een groep functies en variabelen in te plaatsen. In dit geval is er een module opgenomen, waarin SolidWorks constanten zijn benoemd. Het voordeel is dat deze constanten niet meer in het hoofdprogramma gedeclareerd hoeven te worden. Zeker als er veel van dit soort constanten nodig zijn in het programma, is het declareren van de constanten op deze manier handiger. Hier onder is een deel van de module weergegeven, dat belangrijk is voor deze oefening.

21-2


Eerste Run Programma Open de form SliderBox.frm door erop te double clicken. De form van de te programmeren code verschijnt.

Omdat de implementatie van de beoogde functie veel programmeerwerk omvat, is er al een basiscode geschreven, die al voor een groot deel functioneert. De bedoeling is deze te doorgronden alvorens veranderingen erin aan te brengen. Daartoe moet er eerst een part geladen worden in SolidWorks, waarvan de kleureigenschappen kunnen worden aangepast. 3. 4.

Start SolidWorks en open Bakje.SLDPRT uit de …\VBasic\Colors folder. Click in het Visual Basic programma op de Play knop.

5. 6. 7. 8.

Zorg dat zowel het part als de form in beeld zijn. Click op de Get Properties button. Probeer een aantal kleuren te maken door de schuifjes te verplaatsen. Druk op de Get Properties button. Als het goed is veranderd de kleur in de form weer in de kleur van het part. 9. Creëer nu een andere kleur en click de Set Properties button. 10. Click de Exit button. Zoals blijkt, heeft het Visual Basic programma het gehele part een andere kleur gegeven. Wenselijk is, dat verschillende vlakken van kleur veranderd kunnen worden door middel van de schuifbalken. Daarvoor zal de code aangepast moeten worden. Voordat we hieraan beginnen, nemen we de basiscode onder de loep.

21-3


Uitleg Programma Structuur Het reeds aanwezige programma is opgebouwd uit een viertal hoofdfuncties: • • • •

Private Sub GetButton_Click(), Private Sub SetButton_Click(), Private Sub ExitButton_Click(), Private Sub UpdateColorBox().

We beginnen met de programmacode van de Get Properties. Het programma dat hierbij hoort, kan in beeld gebracht worden door te double clicken op de button. Bij de Set Properties –functie wordt volstaan met een uitleg over de wezenlijke verschillen ten opzichte van de Get Properties. Daarna worden de laatste twee functies toegelicht.

Get Properties 1.

Double click op de Get Properties button. De programma-code die nu verschijnt, wordt in deze paragraaf stap voor stap uitgelegd.

Variabele Declaratie Dim swApp As Object Dim Model As Object Dim vals As Variant

' Current Model ' Input array for MaterialPropertyValues

Een nieuwe variabele die we hier tegen komen is vals, (Values) gedeclareerd als Variant. Vals wordt gebruikt als array om de ingestelde waarden van de afzonderlijke sliders in op te slaan, waarbij iedere slider zijn eigen plek in de array heeft. In desbetreffende procedure komt dit aan de orde.

21-4


Verbinden met SolidWorks document Set swApp = CreateObject("SldWorks.Application")

' Attach to SolidWorks session

If swApp Is Nothing Then MsgBox "Could not connect to SolidWorks" Exit Sub End If swApp.Visible = True

' Just in case we started it

Set Model = swApp.ActiveDoc If Model Is Nothing Then MsgBox "There is no current Part in SolidWorks" Exit Sub End If

' Grab the currently active document

Bij het verbinden met SolidWorks vindt er niets nieuws plaats.

Ophalen materiaal eigenschappen vals = Model.MaterialPropertyValues RedSlider.Value = vals(0) * 100# GreenSlider.Value = vals(1) * 100# BlueSlider.Value = vals(2) * 100# AmbientSlider.Value = vals(3) * 100# DiffuseSlider.Value = vals(4) * 100# SpecularSlider.Value = vals(5) * 100# ShininessSlider.Value = vals(6) * 100# TransparencySlider.Value = vals(7) * 100# EmissionSlider.Value = vals(8) * 100#

' Get the properties ' Red

UpdateColorBox

' Green ' Blue ' Ambient ' Diffuse ' Specular ' Shininess ' Transparency ' Emission ' Show current color

Set Model = Nothing Set swApp = Nothing

De Model.MaterialPropertyValues haalt de waarden op van de materiaal eigenschappen van een model of onderdelen van een part. De materiaal ‘values’ bevatten de kleur (R,G,B waarden), reflectie eigenschappen (ambient, diffuse, specular, shininess), transparantie en emissie. Geldige waarden zijn van 0 tot 1 voor alle ‘values’. Er zijn dus negen getallen in te lezen van een geselecteerd voorwerp. Deze getallen worden opgeslagen in de array vals: [ R, G, B, Ambient, Diffuse, Specular, Shininess, Transparency, Emission ]. Deze waarden worden een voor een aan een slider toegekend, waarbij opgemerkt kan worden dat deze werken op een schaal van 0-100 (%). Via het commando UpdateColorBox worden de sliders op de zojuist ingestelde waarden gezet. Daarna wordt gebruikte geheugen van de sliders weer vrij gegeven.

Set Properties Bekijk ook de code voor de SetButton_Click() functie. …. vals(2) = BlueSlider.Value / 100# vals(3) = AmbientSlider.Value / 100# Model.MaterialPropertyValues = vals Model.WindowRedraw ….

' Blue ' Ambient ' set the properties ' Redraw the window

Een opvallend verschil met de Get Properties functie is het vullen van de array vals met de gewenste waarden die handmatig zijn ingesteld met behulp van de sliders. Let daarbij op

21-5

Hoofdstuk 21, Selecties behandelen de factor 100. Nadat de array gevuld is, moeten deze waarden nog worden toegekend aan de SolidWorks tekening; Model.MaterialPropertyValues = vals. Rest nog het opnieuw tekenen van het model met juiste materiaal eigenschappen.

Exit Private Sub ExitButton_Click() Unload Me End End Sub

Via het Unload Me statement wordt het door de arrays en forms gebruikte geheugen vrijgegeven.

UpdateColorBox Private Sub RedSlider_Change() UpdateColorBox End Sub

Omdat de kleur van de ColorBox wordt gemaakt door de mix van de drie basiskleurschuiven, moet voor alle drie de schuiven de procedure UpdateColorBox worden aangeroepen. Op het moment dat een schuif aan een verandering onderhevig is, wordt de procedure Private Sub [Kleur]Slider_Change() aangeroepen, waarin de ColorBox aangepast wordt. Private Sub UpdateColorBox() Dim Red As Integer Dim Green As Integer Dim Blue As Integer Red = RedSlider * 255 / 100 Green = GreenSlider * 255 / 100 Blue = BlueSlider * 255 / 100

' Scale to 0-255 ' Scale to 0-255 ' Scale to 0-255

ColorBox.BackColor = RGB(Red, Green, Blue) End Sub

Bij het maken van de kleur voor de ColorBox moet er ermee rekening worden gehouden, dat de kleuren rood, groen en blauw gedefinieerd zijn op een schaal van 0 tot 255. Ook hier wordt de schaalfactor van 100 gebruikt.

21-6


Aanpassen van de Basis Code De programmacode die in de vorige paragraaf stap voor stap is uitgelegd, functioneert al voor een groot deel. Wat nu nog geïmplementeerd moet worden is een routine die het mogelijk maakt faces verschillende materiaal eigenschappen toe te kennen. Dit geld voor zowel de Get Properties als voor de Set Properties functie. De overige procedures hoeven niet meer aangepast te worden. Na het stap voor stap uitbreiden van de functie Private Sub GetButton_Click() wordt u geacht de Private Sub SetButton_Click()-functie aan de hand van een aantal aanwijzingen, zelfstandig aan te passen. Dit omdat in desbetreffende procedure vrijwel identieke zaken moeten worden toegevoegd. Voor hulp kan altijd het voltooide programma geraadpleegd worden dat in de ..\VBasic\Colors\Finish\.. directory is te vinden.

Private Sub GetButton_Click() Variabele declaratie Voor de gewenste implementatie zullen een aantal extra variabelen nodig zijn. Dim swApp As Object Dim Model As Object Dim SelMgr As Object Dim Face As Object Dim SelCount As Integer Dim Index As Integer Dim FaceCount As Integer Dim BadCount As Integer Dim vals As Variant Dim Text As String

1.

' Object for Selection Manager ' Object for Face ' Number of selections ' Loop Counter ' Count of faces ' Bad selections counter ' Message Box text

Kopieer de gearceerde stukken in het basis programma en save het programma in uw werkdirectory.

Verbinding met SolidWorks In het stuk programma waarin er een verbinding wordt gemaakt met SolidWorks, zal niets hoeven worden aangepast. Set swApp = CreateObject("SldWorks.Application") If swApp Is Nothing Then MsgBox "Could not connect to SolidWorks" Exit Sub End If swApp.Visible = True ' Get the current model Set Model = swApp.ActiveDoc If Model Is Nothing Then MsgBox "There is no current Part in SolidWorks" Exit Sub End If

Selectie manager Omdat van bepaalde, door de gebruiker geselecteerde vlakken, de materiaaleigenschappen veranderd moeten kunnen worden, is het nodig de SelectionManager aan te roepen. Set SelMgr = Model.SelectionManager SelCount = SelMgr.GetSelectedObjectCount

2.

' This object handles user selections ' Get the number of items selected

Neem bovenstaande code over in het eigen programma, direct onder het verbinden met SolidWorks.

21-7


Doorlopen van de selectie Er moet een loop gecreëerd worden, zodat voor ieder geselecteerd vlak de materiaal eigenschappen aangepast kan worden. For Index = 1 To SelCount If Not SelMgr.GetSelectedObjectType(Index) = swSelFACES Then BadCount = BadCount + 1 Else FaceCount = FaceCount + 1 If FaceCount = 1 Then Set Face = SelMgr.GetSelectedObject(Index) vals = Face.MaterialPropertyValues End If End If Next Index

3. 4. 5.

' Check if item is a face ' Increment counter ' For the first face get the properties ' Get Face object ' Get the properties

Verwijder de oorspronkelijke regel waarin de array vals gevuld wordt met de ingelezen waarden (vals=Model.MaterialPropertyValues). Neem de bovenstaande tekst compleet over in het eigen programma, op de plek van de zojuist verwijderde regel. In de variabele BadCount wordt het aantal mislukte operaties bijgehouden om later aan de gebruiker een boodschap te geven. Evenzo komt het getal FaceCount later terug.

Default instelling Met Chr(13) wordt het ASCII character nr 13 gegenereert. Dit wordt ook wel aangeduid als Carrige Return: spring naar nieuwe regel.

Als er geen vlakken geselecteerd worden, moet het complete model worden geselecteerd om van materiaal eigenschap te veranderen. If VarType(vals) = vbEmpty Then vals = Model.MaterialPropertyValues ' Get the properties of the model MsgBox "No Faces selected using Model properties." ElseIf VarType(vals) = vbNull Then vals = Model.MaterialPropertyValues ' Get the properties of the model MsgBox "Face has no specific Material Properties" + Chr(13) + “Using part properties.”

6. 7. 8.

Neem ook de bovenstaande tekst compleet op in je eigen programma direct onder het voorgaande gekopieerde stuk. Let op het verschil in het voorgaande blok gebruikte FaceMaterialPropertyValues en de hier gebruikte ModelMaterialPropertyValues. Bekijk waarom / wanneer er een boodschap op het scherm verschijnt.

MessageBox Om de gebruiker informatie te geven over het al dan niet succesvol voltooien van de actie, moet er een MessageBox met informatie hierover gemaakt worden. ElseIf FaceCount > 1 Then MsgBox Str(FaceCount) + " Face(s) were selected" ElseIf BadCount > 0 Then MsgBox Str(BadCount) + " Selections were ignored," + Chr(13) + "Only Faces are valid." End If

9.

21-8

Voeg bovenstaande code toe, ter completering van het voorgaande If statement.


Tonen van de Eigenschappen Hierin hoeft niets te worden aangepast. RedSlider.Value = vals(0) * 100# GreenSlider.Value = vals(1) * 100# BlueSlider.Value = vals(2) * 100# AmbientSlider.Value = vals(3) * 100# DiffuseSlider.Value = vals(4) * 100# SpecularSlider.Value = vals(5) * 100# ShininessSlider.Value = vals(6) * 100# TransparencySlider.Value = vals(7) * 100# EmissionSlider.Value = vals(8) * 100# UpdateColorBox ' Free objects Set Model = Nothing Set swApp = Nothing End Sub

10. Save het programma in je eigen werkdirectory. Nu moet u alleen nog de Set functie aanpassen om het programma goed te laten functioneren. 11. Kopieer dezelfde nieuwe variabelen als in de vorige procedure en zet ze bij de andere variabelen van de Private Sub SetButton_Click()-functie. 12. Hetzelfde geldt voor de Selectie Manager. 13. Verwijder de regel waarin de array vals gevuld wordt. Waarom? 14. Kopieer hiervoor in de plaats dezelfde regels als bij Doorlopen van de selectie uit de vorige procedure (de Index-loop). Let echter op: De array vals wordt nu echter niet gevuld, maar uitgelezen. Desbetreffende regel moet dus worden aangepast! (Face.MaterialPropertyValues = vals). Omdat er hier geen spraken is van een Default-instelling blijft dat stuk achterwege. Deze procedure heeft zijn eigen feedback naar de gebruiker. Daarom wordt deze opnieuw gemaakt. Text = Str(FaceCount) + " Face(s) were Changed." If BadCount > 0 Then Text = Text + Chr(13) + Str(BadCount) + " Selections were ignored," + Chr(13) + "Only Faces are valid." ElseIf FaceCount < 1 Then Text = "Please select some faces" End If MsgBox Text

15. Neem bovenstaande code in zijn geheel over na de regel Model.WindowRedraw. 16. Save de code in uw werkdirectory

21-9


Testen van het Programma Op dit moment heeft u een werkende applicatie geschreven. Om het te testen moet SolidWorks actief zijn en de current document moet een part bevatten. Start uw programma, selecteer één of meer faces en click op Get Properties. Probeer daarna de kleur van de vlakken te wijzigen etc. 17. Test het programma en probeer zelf modificaties aan te brengen, bijvoorbeeld door de TextBox aan te passen.

21-10

Hoofdstuk 22

Uitvoeren van Selecties

Om delen van de tekening te kunnen herkennen en veranderen, zullen deze onderdelen moeten worden herkend en worden geselecteerd. In dit hoofdstuk wordt geleerd hoe bepaalde delen van een part kunnen worden bewerkt, door ze via een programma te selecteren en vervolgens te bewerken. De volgende onderwerpen komen aan de orde:

Feature Tree, Select by Name, Gebruik maken van een Visual Basic Listbox, Implementatie Suppress en UnSuppress Functies.

Deze oefening wordt uitgelegd aan de hand van het onderdrukken (suppressen) en weer zichtbaar maken (unsuppressen) van features. Een suppressed features is tijdelijk buiten werking gesteld. De beoogde werking van het programma is als volgt. U bedient het programma via een dialog window. Deze bevat alle feature types. Feature types die u in uw part wilt onderdrukken, kunnen hier worden geselecteerd. Wanneer u op de Clear selection button clickt, zullen in de dialog alle feature typen gedeselecteerd (unchecked) worden. Vervolgens kunnen de featuretypes worden geselecteerd, die onderdrukt moeten worden.

Door op de Suppress selected button te clicken, worden de features in de part onderdrukt. Het programma kan worden gestopt met de Exit button.

22-1

Hoofdstuk 22, Uitvoeren van Selecties

Openen Visual Basic Project Het programma om features te suppressen is voor een groot deel al aanwezig. Deze code zal eerst worden behandeld. Daarna kan worden begonnen aan de implementatie van de ontbrekende delen. Voor deze oefening zijn twee VB projecten beschikbaar. Eén versie in Uitvoere...\Start en één in Uitvoer...\Finish Kopieer vooraf de VBasic folder naar uw eigen werkgebied en gebruik verder deze kopie.

22-2

Start Visual Basic en open het project Lab5.vbp uit de directory ..\Vbasic\Uitvoeren van Selecties\Start\ in uw werkgebied. 1. Click File, Open Project, Lab5.vbp 2. Click View, Project Explorer.

In dit project is ook weer gebruik gemaakt van een module swconst.bas, waarin alle constanten worden gedefinieerd. Hier onder is een deel van de module weergegeven, dat belangrijk is voor deze oefening.


Eerste Run Programma Het is wel inzichtelijk om het programma te runnen alvorens de programma structuur te gaan bekijken. Hiervoor moet een part in SolidWorks zijn geopend, zodat daarvan de features kunnen worden suppressed. 1. 2. 3. 4. 5.

Open Camera.prt in SolidWorks. Ga naar Visual Basic en run het project. (Click op de Start knop). Click Clear Selection. Selecteer de Cut uit de Suppress all selected feature Types. Click Suppress Selected.

De volgende stap is het gaan bekijken en begrijpen van de programmastructuur, zodat achterhaald kan worden waarom de message box op het scherm verschijnt. Opgemerkt kan worden dat de Exit button al goed functioneert.

Uitleg Programma Structuur De programmastructuur van het programma, is als volgt onder te verdelen. • Private Sub Command1_Click() Hier staat de programma code om de features in de List1 te deselecteren. • Private Sub Command2_Click() Dit is het belangrijkste deel van het project. Hier moet het daadwerkelijke suppressen gebeuren. • Private Sub Command3_Click() Hiermee kan het programma worden gesloten • Private Sub Form_Load() De List1 moet worden geladen met de verschillende features. Deze functie is daarvoor verantwoordelijk. • Private Function IsBodyFeatureSelected (FeatureType As String) As Integer Binnen deze functie wordt bepaald of een feature een bodyfeature is en of dit type bodyfeature is geselecteerd in de List1. Deze functie wordt gebruikt binnen Private Sub Command2_Click()

22-3


Private Sub Command1_Click() Met behulp van deze programmacode kan er met een druk op de knop voor worden gezorgd dat er geen features meer zijn geselecteerd in het window. Private Sub Command1_Click() Dim i As Integer For i = 0 To List1.ListCount - 1 List1.Selected(i) = False Next i End Sub

' uncheck each item in the list

Wanneer feature i uit List1 wordt geselecteerd, krijgt de Boolean List1.Selected(i) de waarde True. Met behulp van bovenstaande programmacode wordt deze waarde false en op die manier is de feature niet meer geselecteerd.

Private Sub Command2_Click() Het doel van deze private sub is het selecteren van de juiste features in een SolidWorks part en deze vervolgens Suppressen. De overige BodyFeatures worden ook nog even UnSuppressed. Private Sub Command2_Click() Dim swApp As Object Dim Part As Object Set swApp = CreateObject("SldWorks.Application") Set Part = swApp.ActiveDoc

' attach to SolidWorks ' get the PartDoc for the current Part

swApp.Visible = True

' make Solidworks visible

If Part Is Nothing Then MsgBox "No Part loaded - nothing to traverse" Exit Sub End If

' no part loaded into SolidWorks

' TODO - add your code here to traverse the ' feature manager tree and get the type of each ' feature. Then, if that type is selected ' in the tree suppress the feature, else ' unsupress it MsgBox "add your own code here to traverse the feature manager" End Sub

Het eerste gedeelte is het standaard begin voor een programma dat samenwerkt met SolidWorks. Het gedeelte dat overblijft is de messagebox die nog vervangen moet worden. Dat gebeurt later in het paragraaf Implementatie Private Sub Command2_Click()

Private Sub Command3_Click() Deze Private Sub wordt gebruikt om het programma uit te zetten Private Sub Command3_Click() Unload Me End Sub

Het commando Unload Me laat het programma stoppen

22-4


Private Sub Form_Load() Zoals was te zien tijdens het runnen van het programma staan op de plaats van List1 een aantal BodyFeaturesTypes. De beneden genoemde programma code is daarvoor verantwoordelijk. Private Sub Form_Load() List1.AddItem "Chamfer" List1.AddItem "Fillet" List1.AddItem "Cavity" List1.AddItem "Draft" List1.AddItem "MirrorSolid" List1.AddItem "CirPattern" List1.AddItem "LPattern" ….. ….. ….. End Sub

De BodyFeatures die geselecteerd kunnen worden, worden door dit commando in List1 gezet (ze zijn hier niet allemaal opgenomen).

Private Function IsBodyFeatureSelected (FeatureType As String) As Integer In deze functie wordt gekeken of het aangeleverde featuretype de vlag swSELECT, swNOTSELECT of swNOTBODYFEATURE moet krijgen. swSELECT betekent dat het featuretype een bodyfeature is en suppressed moet worden. swNOTSELECT betekent dat het featuretype een bodyfeature is, maar niet suppressed moet worden. swNOTBODYFEATURE betekent dat de het featuretype geen bodyfeature is en derhalve niet suppressed moet/kan worden. Private Function IsBodyFeatureSelected(FeatureType As String) As Integer Dim i As Integer For i = 0 To List1.ListCount - 1 If StrComp(List1.List(i), FeatureType) = 0 Then If List1.Selected(i) Then IsBodyFeatureSelected = swSELECTED Else IsBodyFeatureSelected = swNOTSELECTED End If Exit Function End If Next i IsBodyFeatureSelected = swNOTBODYFEATURE End Function

' Is the feature type in the list ' If so, is it selected ' It is in the list, but not selected

' Not in the list, therefore not a bodyfeature

In de For-loop wordt i doorlopen van 0 tot het einde van List1. Het If-Statement bepaald of het FeatureType een Type is die in List1 voor komt. StrComp(List1.List(i), FeatureType) heeft als uitkomt 0 wanneer de twee strings gelijk zijn. Wanneer het FeatureType in de lijst staat, dan wordt in de volgende If-statement bepaald of de gebruiker het Type heeft geselecteerd voor suppression of niet. Na dit If-statement is het volgende commando Exit Function. Staat het FeatureType niet in de lijst dan krijgt IsBodyFeatureSelected de waarde swNOTBODYFEATURE.

22-5


Implementatie Private Sub Command2_Click() De mededeling in de messagebox is niet verwonderlijk, gezien de implementatie die op dit moment nog in de Private Sub staat. De implementatie wordt in deze paragraaf aangepast. Daarna is het programma al klaar om in gebruik genomen te worden. Private Sub Command2_Click() Dim swApp As Object Dim Part As Object Set swApp = CreateObject("SldWorks.Application") Set Part = swApp.ActiveDoc

' attach to SolidWorks ' get the PartDoc for the current Part

swApp.Visible = True


If Part Is Nothing Then MsgBox "No Part loaded - nothing to traverse" Exit Sub End If

' no part loaded into SolidWorks

' TODO - add your code here to traverse the ' feature manager tree and get the type of each ' feature. Then, if that type is selected ' in the tree suppress the feature, else ' unsupress it MsgBox "add your own code here to traverse the feature manager" End Sub

1.

Vervang de geselecteerde code door de aanroep van twee functies, die vervolgens ook worden geïmplementeerd in de volgende paragraaf, zie onderstaand kader.

UnSuppressFeatures Part SuppressFeatures Part

2.

Save het aangepaste Visual Basic bestand in je eigen werkdirectory.

Implementatie SuppressFeatures Part In deze paragraaf wordt de implementatie van het daadwerkelijke suppressen behandeld. De opbouw dan deze functie is als volgt: • Declaratie Variabelen, • Initialiseer de eerste feature van de part, • Een While lus waarin alle features worden bekeken en wanneer het type overeenkomt met een van de geselecteerde features in de List1, worden deze features geselecteerd, • Suppress de geselecteerde features en Rebuild. 3.

Ga helemaal naar de laatste geprogrammeerde code, onder aan.

We gaan nu stap voor stap nieuwe stukken code in het programma toevoegen. Uiteraard wordt er begonnen met het declareren van variabelen. Het is de bedoeling dat de hierna volgende stukken programmacode (aangegeven door een kader eromheen) in de gegeven volgorde aan het programma worden toegevoegd.

22-6


Declaratie Variabelen De uitleg is te vinden in voorgaande paragrafen. Maar er is wel een lijstje opgenomen Private Sub SuppressFeatures(Part As Object) Dim Feature As Object Dim FeatureType As String Dim FeatureName As String Dim NextSelection As Boolean

Initialiseer de eerste feature Een part heeft meerdere features. In dit gedeelte wordt de eerste daarvan opgehaald. Set Feature = Part.FirstFeature NextSelection = False

' initialise to the first feature

In deze regels wordt de variabele Feature gelijk gesteld aan de eerste feature van het part(Part.FirstFeature). Vervolgens wordt NextSelection gelijk gesteld aan false. Deze variabele wordt straks gebruikt in de While-lus.

Iteratie door de While-lus Dit is de lus, die een voor een alle features van het part langs loopt. Hierbinnen worden features geselecteerd die suppressed moet worden. Het kan dus een selectie zijn van meerdere features. While Not Feature Is Nothing FeatureType = Feature.GetTypeName FeatureName = Feature.Name If IsBodyFeatureSelected(FeatureType) = swSELECTED Then If NextSelection Then Part.AndSelectByID FeatureName, "BODYFEATURE", 0, 0, 0 Else Part.SelectByID FeatureName, "BODYFEATURE", 0, 0, 0 End If NextSelection = True End If Set Feature = Feature.GetNextFeature Wend

' get the generic type of the feature ' get the unique name of the feature ' this is a subsequent selection ' this is the first selection

' move onto the next feature

De While lus loopt zolang de variabele Feature niet leeg is. Dat duurt tot dat Feature.NextFeatures aan het eind is, dus als alle features aan de orde zijn geweest. Dit gebeurt door steeds de variabele Feature gelijk te stellen aan de volgende feature in de part (Feature.GetNextFeature) aan het eind van de lus. In de lus worden dan eerst de Feature Type en Feature Naam opgehaald. Het Eerste If-statement is bedoeld om te kijken of de FeatureType voor komt in List1 en of deze FeatureType is geselecteerd is. De functie IsBodyFeatureSelected wordt hiervoor gebruikt. IsBodyFeatureSelected(FeatureType) krijgt de waarde swSELECTED wanneer aan beide voorwaarden is voldaan (het staat in List1 en is geselecteerd in List1). Het binnenste If-statement wordt dus alleen geactiveerd wanneer het een in List1 geselecteerde FeatureType betreft. Deze If-lus is bedoeld om de eerste geselecteerde feature te onderscheiden van de volgenden. Dit is nodig, want de eerste feature aan een selectie toevoegen moet met Part.SelectByID FeatureName en de volgende features moeten worden toegevoegd met Part.AndSelectByID FeatureName. De selectievariabele die de If-lus gebruikt is de Boolean Nextselection. Zodra de eerste feature is geselecteerd wordt deze variabele op True gezet. Het commando Wend geeft de plaats aan waar de while lus terug keert.

22-7


Suppress de geselecteerde features en Rebuild Nu de juiste features zijn geselecteerd moeten ze nog worden suppressed. Dit is een betrekkelijk eenvoudige regel. De laatste stap is de part herbouwen en de sub-procedure afsluiten. Part.EditSuppress Part.EditRebuild End Sub

' Suppress the selected features

De implementatie van de SuppressFeature Part is nu af. 4. Save het project in je werkdirectory 5. Implementeer nu op dezelfde wijze de UnSuppressFeature Part onder SuppressFeature Part. De implementatie van UnSuppress is vrijwel gelijk aan die van Suppress. Het verschil zit in het feit, dat de selectie niet Suppressed maar UnSuppressed moet worden.(Part.EditUnSuppress in plaats van Part.EditSuppress). Het andere verschil zit in de selectie van de features. Deze selectie is de inverse van de selectie bij het Suppressen. (swNOTSELECT in plaats van swSELECT). Test het programma: zorg voor een active part in SolidWorks. Kies de feature die suppressed moet worden (in het voorbeeld de Cut-feature).

Het resultaat, nadat op de Suppress Selected button is geclicked.

22-8


Totale Programma In deze paragraaf is het totale programma nog eens opgenomen. Dit is hetzelfde programma als in de finish file, alleen het commentaar is verwijderd. Private Sub Command1_Click() Dim i As Integer For i = 0 To List1.ListCount - 1 List1.Selected(i) = False Next i End Sub Private Sub Command2_Click() Dim swApp As Object Dim Part As Object Set swApp = CreateObject("SldWorks.Application") Set Part = swApp.ActiveDoc swApp.Visible = True If Part Is Nothing Then MsgBox "No Part loaded - nothing to traverse" Exit Sub End If UnsuppressFeatures Part SuppressFeatures Part End Sub Private Sub Command3_Click() Unload Me End Sub Private Sub Form_Load() List1.AddItem "Chamfer" List1.AddItem "Fillet" List1.AddItem "Cavity" List1.AddItem "CirPattern" …. ….. End Sub Private Function IsBodyFeatureSelected(FeatureType As String) As Integer Dim i As Integer For i = 0 To List1.ListCount - 1 If StrComp(List1.List(i), FeatureType) = 0 Then If List1.Selected(i) Then IsBodyFeatureSelected = swSELECTED Else IsBodyFeatureSelected = swNOTSELECTED End If Exit Function End If Next i IsBodyFeatureSelected = swNOTBODYFEATURE End Function Private Sub SuppressFeatures(Part As Object) Dim Feature As Object Dim FeatureType As String Dim FeatureName As String Dim NextSelection As Boolean Set Feature = Part.FirstFeature NextSelection = False

22-9


While Not Feature Is Nothing FeatureType = Feature.GetTypeName FeatureName = Feature.Name If IsBodyFeatureSelected(FeatureType) = swSELECTED Then If NextSelection Then Part.AndSelectByID FeatureName, "BODYFEATURE", 0, 0, 0 Else Part.SelectByID FeatureName, "BODYFEATURE", 0, 0, 0 End If NextSelection = True End If Set Feature = Feature.GetNextFeature Wend Part.EditSuppress Part.EditRebuild End Sub Private Sub UnsuppressFeatures(Part As Object) Dim Feature As Object Dim FeatureType As String Dim FeatureName As String Dim NextSelection As Boolean Set Feature = Part.FirstFeature NextSelection = False While Not Feature Is Nothing FeatureType = Feature.GetTypeName FeatureName = Feature.Name If IsBodyFeatureSelected(FeatureType) = swNOTSELECTED Then If NextSelection Then Part.AndSelectByID FeatureName, "BODYFEATURE", 0, 0, 0 Else Part.SelectByID FeatureName, "BODYFEATURE", 0, 0, 0 End If NextSelection = True End If Set Feature = Feature.GetNextFeature Wend Part.EditUnsuppress Part.EditRebuild End Sub

22-10

Hoofdstuk 23

Attributen creëren en opvragen

In Solidworks kunnen gegevens worden toegevoegd aan het model. Dit wordt gedaan met attributen. Eerst wordt een attribuut type gedefinieerd (bijvoorbeeld snijdsnelheid), daarna wordt het aan een feature toegekend (in dit voorbeeld aan een vlak). Vervolgens kunnen er attribuut waarden in worden gezet (2.0 m/s). In dit hoofdstuk wordt uitgelegd hoe dat gedaan kan worden. In dit hoofstuk komen de volgende aspecten aan de orde: Het creëren van attributen, Attributen opvragen, Attribuut waarden opvragen, Omgaan met gebruikers selecties. Het voorbeeld dat gebruikt wordt laat zien hoe attributen, in dit geval Cutting Speed, Feed Rate en een Notes, aan een face kunnen worden gekoppeld.

23-1

Hoofdstuk 23, Attributen creëren en opvragen

Openen Bestaande Project Openen project Voor deze oefening zijn twee VB projecten beschikbaar. Eén versie in Attributes1\Start en één in Attributes1\ Finish.

De eerste stap is het openen van het bestaande project 1. Zorg dat u de VBasic folder met voorbeelden heeft gekopieerd naar uw eigen werkgebied. 2. Open Visual Basic, 3. Click File, Open Project…, en open in de folder ..\Attributes1 de file Attributes.vbp

Eerste Run Programma Zoals gezegd, er is al een groot deel aanwezig, zoveel zelfs dat het de moeite waard is om eerst een keer het programma te runnen alvorens de programma structuur te gaan bekijken. Maar eerst moet een part in SolidWorks worden geopend, zodat van dit part faces kunnen worden geselecteerd en aan deze faces attributen worden toegevoegd. 1. Open Machined part.SLDPRT in SolidWorks 2. Ga naar Visual Basic en run het project. (Click op de Play knop)

De volgende stap is het bekijken en begrijpen van de programma structuur, zodat achterhaald wordt waar de message box op het scherm wordt gezet.

23-2


Uitwerking Programma Frame Ook in dit project is weer de swconst.bas module opgenomen. Omdat er nu twee forms worden gehanteerd, staan de programma’s ook apart. Het betekend wel dat een aantal procedures niet meer Private Sub’s kunnen zijn maar Public Sub’s moet worden. In plaatje hieronder kunt u zien welke form bij welk venster hoort. Eerst worden een overzicht gegeven van de procedures die in beide programma’s worden gebruikt.

Form1 (AttribMainForm) Dit is het hoofdprogramma. Vanuit dit programma wordt ook het andere aangestuurd.

• • •

• • • •

Private Sub AttrBtn_Click() Hierin wordt Public Sub DisplayCurrentSelection aangeroepen, deze functie staat in AttrFrm.frm. Private Sub ExitBtn_Click() De code om het programma te sluiten Private Sub Form_Load() Deze code geeft toegang tot het aanwezige part, zodat de attributen kunnen worden toegevoegd of opgehaald. De twee volgende procedures kunnen daarbij worden gebruikt. Private Sub DefineFaceAttribute(swApp As Object). Definieert de attributen die moet worden toegevoegd. Private Sub DefineAttributeCount(swApp As Object, Part As Object) Definieert de attributen die moet worden toegevoegd. Public Function GetFaceAttributeDef() As Object Maakt de attributen toegankelijk voor andere forms. NextAvailableAttName(Part As Object) As String Deze functie voorkomt dat twee of meer attributen per face dezelfde naam krijgen.

AttrFrm

•

Public Sub DisplayCurrentSelection() In deze functie worden de waarden van de attributen opgehaald uit de tekening en op de juiste plaats in het scherm gezet.

23-3

Hoofdstuk 23, Attributen creëren en opvragen •

Private Sub CancelBtn_Click() Met deze functie kan men terug keren naar de Machining Attributes dialog. Private Sub OKBtn_Click() Door deze code worden de waarden in de Face Attribute dialog toegeschreven aan de face.

•

Form Form1 Private Sub AttrBtn_Click() Het doel van deze Private Sup is het opstarten van de volgende dialog Face Attributes. Dat wordt bereikt door Public Sub DisplayCurrentSelection aan te roepen, deze functie staat in AttrFrm.frm. Private Sub AttrBtn_Click() AttrFrm.DisplayCurrentSelection End Sub

Private Sub ExitBtn_Click() Code bedoeld om het programma te stoppen. Private Sub ExitBtn_Click() Unload Me End Sub

Private Sub Form_Load() Deze code definieert het FaceAttribuut. Het eerste gedeelte is een standaard begin van een SolidWorks applicatie, in het tweede, gearceerde, deel staat in woorden wat er nog in moet komen. De DefineAttributeCount (swApp As Object, Part As Object), de DefineFaceAttribute (swApp As Object) en de GetFaceAttributeDef() As Object functies moeten daarbij worden gebruikt en geïmplementeerd. Dit zal in de volgende paragraaf aan de orde komen. Private Sub Form_Load() Dim swApp As Object Dim Part As Object Set swApp = CreateObject("SldWorks.Application") Set Part = swApp.ActiveDoc swApp.Visible = True If Part Is Nothing Then swApp.SendMsgToUser ("No Part loaded") Exit Sub End If If (Part.GetType <> swDocPART) Then swApp.SendMsgToUser ("This is not a part") End If ' TODO - add your code here to define the ' face attribute. This attribute must contain ' 3 fields ' 1) feed rate (double) ' 2) cutting speed (double) ' 3) notes (string) ' The steps that are needed are ' 1) SldWorks::DefineAttribute ' 2) AttributeDef::AddParameter ' 3) AttributeDef::Register ' the attribute def must be available globally End Sub

23-4


Private Sub DefineFaceAttribute(swApp As Object) Deze functie moet een Face Attribute definiëren. Vanuit deze definitie kunnen de attributes voor de faces worden gemaakt. Private Sub DefineFaceAttribute(swApp As Object) End Sub

Private Sub DefineAttributeCount(swApp As Object, Part As Object) Deze functie moet de Count attribuut definiëren. Deze attribuut wordt op het hele document toegepast. Private Sub DefineAttributeCount(swApp As Object, Part As Object) End Sub

Public Function GetFaceAttributeDef() As Object Deze functie maakt de Face Attribuut Definitie toegankelijk voor andere forms. Public Function GetFaceAttributeDef() As Object Set GetFaceAttributeDef = FaceAttributeDef End Function

NextAvailableAttName(Part As Object) As String Deze public function zal worden gebruikt om te voorkomen dat een attribuut naam per entity (bijvoorbeeld document of face) meer dan een keer voorkomt. Op een andere entity mogen dezelfde namen wel weer terug komen. Public Function NextAvailableAttName(Part As Object) As String Dim AttInstance As Object Dim AttParameter As Object Dim Feature As Object Dim Count As Integer NextAvailableAttName = "" Set Feature = Part.FeatureByName("Face Attribute Count") If Not Feature Is Nothing Then Set AttInstance = Feature.GetSpecificFeature Set AttParameter = AttInstance.GetParameter("Counter") Count = CInt(AttParameter.GetDoubleValue) NextAvailableAttName = "Face Info " + CStr(Count) Count = Count + 1 AttParameter.SetDoubleValue Count End If End Function

Na de variabele declaratie wordt eerst de variabele NextAvailableAttName leeg gemaakt. De daarop volgende regels zijn bedoelt om de waarde van de attributen counter te krijgen. Met het commando NextAvailableAttName = "Face Info " + CStr(Count), wordt de volgende attributen naam gemaakt. De laatste stappen zijn bedoeld om de attributen counter met 1 op te hogen.

23-5


Form AttrFrm Public Sub DisplayCurrentSelection() In deze functie worden de waarden van de attributen gehaald en op de juiste plaats in het scherm gezet. Over deze programma code is op dit moment weinig te vertellen. Tijdens de implementatie fase wordt deze code uitvoerig besproken. Public Sub DisplayCurrentSelection() Dim SelMgr As Object Dim AttParameter As Object Set swApp = CreateObject("SldWorks.Application") ' attach to SolidWorks Set Part = swApp.ActiveDoc ' get the PartDoc for the current Part swApp.Visible = True


If Part Is Nothing Then ' no part loaded into SolidWorks swApp.SendMsgToUser ("No Part loaded") Exit Sub End If If (Part.GetType <> swDocPART) Then swApp.SendMsgToUser ("This is not a part") End If ' TODO - add your code here to retrieve the ' selected face attribute and update the text ' areas in the dialog. Only put the dialog on ' screen if a face is selected ' 1) get the selection manager ' 2) get the selected face ' 3) extract the attribute from the face ' 4) update the text fields MsgBox ("Put your code here") Show 1 End Sub

Private Sub CancelBtn_Click() Met deze functie kan men terug keren naar de Machining Attributes dialog. Private Sub CancelBtn_Click() Hide End Sub

Private Sub OKBtn_Click() Deze functie moet ervoor zorgen dat attributen de waarden krijgen die de gebruiker heeft ingevuld in de dialog. Op deze functie wordt uitgebreid terug gekomen in de implementatie fase. Private Sub OKBtn_Click() Dim AttParameter As Object Dim FaceAttributeDef As Object Dim Speed As Double Dim Rate As Double 'On Error GoTo ErrorHandler

' catch all the errors

' TODO - add your code here to set the values ' from the text fields into the attribute ' if the attribute instance does not yet exist ' then create it

23-6


Hide End Sub

Implementatie Form1 Aan beide Forms zal nu het een en ander moeten gebeuren. Om te beginnen wordt Form1 onderhanden genomen.

Private Sub Form_Load() De gearceerde tekst moet nog worden omgezet naar een correcte implementatie. Private Sub Form_Load() Dim swApp As Object Dim Part As Object Set swApp = CreateObject("SldWorks.Application") Set Part = swApp.ActiveDoc swApp.Visible = True If Part Is Nothing Then swApp.SendMsgToUser ("No Part loaded") Exit Sub End If If (Part.GetType <> swDocPART) Then swApp.SendMsgToUser ("This is not a part") End If ' TODO - add your code here to define the ' face attribute. This attribute must contain ' 3 fields ' 1) feed rate (double) ' 2) cutting speed (double) ' 3) notes (string) ' The steps that are needed are ' 1) SldWorks::DefineAttribute ' 2) AttributeDef::AddParameter ' 3) AttributeDef::Register ' the attribute def must be available globally End Sub

Om deze procedure niet te ingewikkeld te maken worden twee nieuwe procedures gemaakt en in deze procedure aangeroepen. DefineFaceAttribute swApp DefineAttributeCount swApp, Part

23-7


Private Sub DefineAttributeCount(swApp As Object, Part As Object) Met deze procedure wordt gezorgd dat nodige attributen worden gecreëerd voor het tellen en benoemen van instance attributes. De algemene stappen voor het creëren van attributes zijn: • Creëer een Attribute Definition (DefineAttribute), • Voeg parameters toe aan de Attribute Definition (AddParameter), • Registreer de Attribute Definition (Register), • Creer van de Attribute Definition een instance voor entity’s van het hele model. (CreateInstance2). Dit toegepast op de huidige situatie levert: Private Sub DefineAttributeCount(swApp As Object, Part As Object) Dim AttInstance As Object Dim Feature As Object Set AttributeCountDef = swApp.DefineAttribute("DocAttribute") If AttributeCountDef.AddParameter("Counter", swParamTypeDouble, 0#, 0) Then AttributeCountDef.Register End If Set Feature = Part.FeatureByName("Face Attribute Count") If Feature Is Nothing Then Set AttInstance = AttributeCountDef.CreateInstance2(Part, Nothing, "Face Attribute Count", 0) End If End Sub

Door voor de naam DocAttribute, in de DefineAttribute command, te kiezen, is deze definitie op alle entities in het document toepasbaar. AttributeCountDef.CreateInstance2, Creert een attribute gedefinieerd door AttributeCountDef op de het hele document toegepast, niet op een specifieke entity, vandaar Nothing in the command line. Wanneer een attribute eenmaal is toegevoegd aan een document worden de attribute en zijn informatie opgeslagen samen met het document.

Private Sub DefineFaceAttribute (swApp As Object) In deze Private Sub wordt een definitie gemaakt van een specifieke attribute voor een face. Dezelfde stappen worden weer gevolgd. De laatste stap uit het rijtje wordt nu niet gebruikt, in deze procedure wordt slechts een definitie gemaakt, deze definitie wordt later gebruikt bij het maken van de instances voor ieder aparte face. Private Sub DefineFaceAttribute(swApp As Object) Set FaceAttributeDef = swApp.DefineAttribute("FaceAttribute") If FaceAttributeDef.AddParameter("FeedRate", swParamTypeDouble, 0#, 0) And _ FaceAttributeDef.AddParameter("CuttingSpeed", swParamTypeDouble, 0#, 0) And _ FaceAttributeDef.AddParameter("FaceNote", swParamTypeString, 0#, 0) Then FaceAttributeDef.Register End If End Sub

23-8


Implementatie AttrFrm Public Sub DisplayCurrentSelection() In deze procedure wordt uitgezocht wat van een geselecteerde face de attributen zijn en welke waarde ze hebben. Vervolgens worden die waarden in de form gezet. Public Sub DisplayCurrentSelection() Dim SelMgr As Object Dim AttParameter As Object Set swApp = CreateObject("SldWorks.Application") Set Part = swApp.ActiveDoc swApp.Visible = True If Part Is Nothing Then swApp.SendMsgToUser ("No Part loaded") Exit Sub End If If (Part.GetType <> swDocPART) Then swApp.SendMsgToUser ("This is not a part") End If Set SelMgr = Part.SelectionManager Set Face = SelMgr.GetSelectedObject2(1) If (SelMgr.GetSelectedObjectType(1) = swSelFACES) Then Set AttInstance = Face.FindAttribute(Form1.GetFaceAttributeDef, 0) If Not AttInstance Is Nothing Then Set AttParameter = AttInstance.GetParameter("FeedRate") SpeedTxt.Text = AttParameter.GetDoubleValue Set AttParameter = AttInstance.GetParameter("CuttingSpeed") RateTxt.Text = AttParameter.GetDoubleValue Set AttParameter = AttInstance.GetParameter("FaceNote") NotesTxt.Text = AttParameter.GetStringValue Else SpeedTxt.Text = "Not Set" RateTxt.Text = "Not Set" NotesTxt.Text = "Enter a Note" End If Show 1 Else swApp.SendMsgToUser ("Please Select a Face for this operation.") End If End Sub

Alleen het geselecteerde deel wordt besproken. Het programma gaat alleen het eerste If statement in als de geselecteerde entity een face is. Vervolgens wordt er gezocht of er een face attribute op het geselecteerde face aanwezig is, deze wordt gelijk gesteld aan AttInstance. Afhankelijk van het feit of er wel of niet een Attribute is gevonden, wordt de waarde van de attribute in het scherm gezet of komt de tekst Not Set, in beeld. Wanneer een andere type entity dan een face is geselecteerd, komt een message op het scherm. Dit is ook het geval wanneer er helemaal niets is geselecteerd.

23-9


Private Sub OKBtn_Click() Nadat de attribute waarden zijn opgehaald, kunnen ze worden veranderd. Door op de OK knop te clicken, moeten deze waarden worden toegepast op het geselecteerde face. Private Sub OKBtn_Click() Dim AttParameter As Object Dim FaceAttributeDef As Object Dim Speed As Double Dim Rate As Double If AttInstance Is Nothing Then Set FaceAttributeDef = Form1.GetFaceAttributeDef Set AttInstance = FaceAttributeDef.CreateInstance2(Part, Face, Form1.NextAvailableAttName(Part), 0) End If Speed = CDbl(SpeedTxt.Text) Rate = CDbl(RateTxt.Text) Set AttParameter = AttInstance.GetParameter("FeedRate") AttParameter.SetDoubleValue Speed Set AttParameter = AttInstance.GetParameter("CuttingSpeed") AttParameter.SetDoubleValue Rate Set AttParameter = AttInstance.GetParameter("FaceNote") AttParameter.SetStringValue NotesTxt.Text Hide Exit Sub End Sub

Wanneer er nog geen instance aanwezig is moet er een worden gecreëerd. Dit wordt gedaan volgens de Face Attribute Definition. De naam van de attribute wordt bepaald door NextAvailebleAttName. Het volgende probleem is dat de waarden voor Speed en Rate nog text zijn. Om er een double van te maken kan het CDbl(SpeedTxt.Text) gebruikt worden. In de laatste regels worden de waarden uit de window toegepast op de attibute.

23-10

Hoofdstuk 24

Attributen verzamelen

Dit is een vervolg op het vorige hoofdstuk Attributen creëren en opvragen. Er wordt een extra commando toegevoegd waarmee een overzicht van de attribuut waarden van de verschillende vlakken te gecreëerd kan worden. In dit hoofdstuk komen de volgende aspecten aan de orde:

Body and Face Traversal, Attribute Retrieval, Attribute Value Retrieval.

24-1

Hoofdstuk 24, Attributen verzamelen

Openen Bestaande Project

Voor deze oefening zijn twee VB projecten beschikbaar. Eén versie in Attributes2\Start en één in Attributes2\ Finish.

Aan het bestaande programma wordt een optie toegevoegd. voor het creëren van een overzicht van aanwezige attributen. Dit wordt gerealiseerd door een extra command button in Form1 te plaatsen en daar wat programmacode aan te koppelen. U kunt starten met het programma dat u in de vorige opdracht heeft ontwikkeld of met de beschikbare voorbeeld code in ..\Attributes2.

Openen project De eerste stap is het openen van het bestaande project 1. Open Visual Basic 2. Open het Vbasic document waarmee u de vorige oefening bent geëindigd. 3. Ga dan naar form1.

Toevoegen extra Command button Het is de bedoeling dat in Form1 een extra command button komt. 1. Click op de Command button 2. Voeg nu een extra Command button toe aan form1

3.

Click View, Properties Window

In deze window worden de Name en de Caption van de command button aangepast. 4. 5. 6.

Verander de Name in SummaryBtn en de Caption in Summary zoals in de plaatjes is weer gegeven. Sluit de properties window Dubbel click op de Command1 Button, die nu Summary button heet. Zodat de programma code voor de Summary button tevoorschijn komt.

Hier moet de implementatie komen die ervoor zorgt dat er een msgbox op het scherm verschijnt met de waarden van de attributen.

24-2

Hoofdstuk 24, Attributen verzamelen

Implementatie Private Sub SummaryBtn_Click() In de voorgaande paragraaf is er een nieuwe button toegevoegd aan de dialog. De code voor deze button wordt in deze paragraaf uitgelegd. De code binnen de kaders moet in het Vbasic project worden gezet in de gegeven volgorde.

Standaard De procedure SummaryBtn_Click is al in de code van de start-versie aanwezig. Gebruikt u die, dan kan worden volstaan met het toevoegen van de tekst uit de volgende box. Private Sub SummaryBtn_Click() Dim swApp As Object Dim Part As Object Dim Body As Object Dim Msg As String Dim AttInstance As Object Set swApp = CreateObject("SldWorks.Application") ' attach to SolidWorks Set Part = swApp.ActiveDoc ' get the PartDoc for the current Part swApp.Visible = True ' make Solidworks visible If Part Is Nothing Then ' no part loaded into SolidWorks swApp.SendMsgToUser ("No Part loaded") Exit Sub End If If (Part.GetType <> swDocPART) Then swApp.SendMsgToUser ("This is not a part") End If

Ophalen van attribute waarden In dit stuk wordt de programma code uitgelegd dat er voor zorgt dat de juiste text in de msgbox komt te staan. Set Body = Part.Body Msg = "Summary of face information for :" + Part.GetTitle + Chr(13) Set Face = Body.GetFirstFace While Not Face Is Nothing Set AttInstance = Face.FindAttribute(Form1.GetFaceAttributeDef, 0) If Not AttInstance Is Nothing Then Set AttParameter = AttInstance.GetParameter("FeedRate") Msg = Msg + "Feed Rate : " + CStr(AttParameter.GetDoubleValue) Set AttParameter = AttInstance.GetParameter("CuttingSpeed") Msg = Msg + ", Cutting Speed : " + CStr(AttParameter.GetDoubleValue) Set AttParameter = AttInstance.GetParameter("FaceNote") Msg = Msg + ", Notes : " + CStr(AttParameter.GetStringValue) + Chr(13) End If Set Face = Face.GetNextFace ' get the next face Wend swApp.SendMsgToUser Msg End Sub

Er zijn meerdere manieren om toegang te krijgen tot objecten in SolidWorks. Om het face object te verkrijgen, kan de onderstaande middelen gebruikt worden. Om het Body object te verkrijgen, PartDoc::Body Om het eerste Face object te verkrijgen Body::GetFirstFace en voor de volgende faces Face::GetNextFace. Of om het Face object te verkrijgen uit een actieve set van geselecteerde items, kan de volgende optie worden gebruikt: SelectionMgr::GetSelectedObject2. Of wanneer de voorkeur uit gaat naar het verkrijgen op naam PartDoc::GetEntityByName.

24-3

Hoofdstuk 24, Attributen verzamelen In dit geval wordt gebruik gemaakt van de eerst optie. Eerst wordt het Face object gezet. Om vervolgens in de While loop de waarden van de attribute van de alle in het part aanwezige Faces om te zetten naar een message, msg. Deze msg wordt aan het eind op het scherm gezet. 1. Voeg deze code toe aan Private Sub SummaryBtn_Click(), 2. Run het programma om te controleren of alles werkt, 3. Voeg aan twee faces een willekeurige part attributes toe, 4. Click Summary button.

24-4

Hoofdstuk 25

Creëren van een Assembly

Het komt voor dat assemblies opgebouwd worden uit een variabel aantal standaard delen. Hier wordt een voorbeeld behandeld dat een nieuwe assembly aanmaakt vanuit configuratiegegevens in een Excel spreadsheet. In de spreadsheet staan gegevens waarmee hoeveelheden en/of groottes van verschillende parts worden berekend. Op deze manier kan er met bestaande delen op een eenvoudige mannier verschillende assemblies worden gemaakt. De volgende onderwerpen komen in dit hoofdstuk aan de orde:

Onderdelen toevoegen in een Assembly, Mates (plaats relaties) definiëren tussen Onderdelen, Vlakken en Referentielijnen selecteren via een verwijzing naar de naam.

U ontwikkelt een programma in Excel dat een assembly creëert die afhankelijk is van waarden die door de gebruiker worden opgegeven. De Excel worksheet zal een assembly creëren van een pakket koppelingsplaten, gebaseerd op het type plaat en de gewenste koppeldoorvoer. Wanneer de gebruiker waarden in de spreadsheet verandert, dient de worksheet-code te berekenen hoeveel platen er nodig zijn in de assembly. Op het moment dat de gebruiker tevreden is met de assembly, moet er door middel van een simpele mouse click op de Create Assembly button de juiste assembly gecreëerd worden in SolidWorks.

25-1

Hoofdstuk 25, Creëren van een Assembly

Open Visual Basic Project Er wordt weer vanuit een basis code gewerkt naar het geïmplementeerde Visual Basic programma, waarbij stap voor stap de belangrijkste commando’s de revue zullen passeren. Voor deze oefening zijn twee VB projecten beschikbaar. Eén versie in AssemblyCreation\Start en één in ..\Finish.

Start Microsoft Excel en open de bestaand spreadsheet Clutch.xls uit de directory ..\VBasic\AssemblyCreation\Start\. in je eigen werkgebied. NB zorg dat de subfolder...\Data\ daar ook een aanwezig is !! 1. Click File, Open..., Clutch.xls.

NB de Data folder wordt verwacht in de folder waar ook de spreadsheet staat.

Om de onderliggende programmeercode te bekijken, moet eerst de Control Toolbox geactiveerd worden. 2. Click View, Toolbars, Control Toolbox. 3. Click op het View Code symbool. Een Visual Basic window verschijnt. Ook hier zien we het gebruik van modules. 4. Bekijk de code van de Assembly module. En verklaar de messagebox die in Excel verschijnt bij het creëren van een assembly. Welke variabelen worden er aangeroepen?

25-2


Uitleg Programma Structuur De basiscode die al geprogrammeerd is, is zoals eerder opgemerkt, opgebouwd uit een aantal Modules. De Assembly module gaan we in een later stadium zelf verder implementeren. Ook hier is de bekende module swconst aanwezig. De UserInterface module bevat de procedures die aangeroepen worden bij de interactie met het Excel werkblad. In deze paragraaf wordt deze module stap voor stap toegelicht. De user interface is opgebouwd uit een drietal hoofdfuncties: • Sub Auto_Open() • Function Recalculate() • Sub CreateAssembly()

Sub Auto_Open() Sub Auto_Open() Sheets("Clutch").OnEntry = "Recalculate" End Sub

Deze procedure wordt direct aangeroepen op het moment dat het workbook geopend wordt.

Function Recalculate() Deze functie maakt een link met de Excel Spreadsheet, waarin de gebruiker waarden kan veranderen. Function Recalculate() Dim DiskType As String Dim Power As Double Dim DiskRow As Integer Dim nPairs As Integer DiskType = Sheets("Clutch").Cells(6, 2) Power = Sheets(1).Cells(5, 2).Value

‘Get the users selections

Omdat de gebruiker uit drie verschillende Disk Type kan kiezen om zijn assembly te creëren, moet er een verwijzing zijn naar de desbetreffende afmetingen. Dit gebeurt door middel van de volgende While- loop: Merk op dat cel (A,12) wordt aangeroepen door Cells(12,1), dus eerst de rij en daarna het kolom nummer. DiskRow = 12 Do While Not Sheets("Clutch").Cells(DiskRow, 1) = "" If Sheets("Clutch").Cells(DiskRow, 1) = DiskType Then Exit Do End If DiskRow = DiskRow + 1 Loop

‘Find the row for the disk type ‘Check all possibilities

Op dit moment heeft de DiskRow de juiste waarde gekregen om de afmetingen die in deze rij staan te gebruiken voor zijn berekening.

25-3


nPairs = Int((Power / Sheets(1).Cells(DiskRow, 2)) + 0.5) ‘Calculate the number of disk pairs required Sheets(1).Cells(7, 2) = nPairs Sheets(1).Cells(8, 2) = nPairs * (Sheets("Clutch").Cells(DiskRow, 3) + Sheets(“Clutch”).Cells(DiskRow, 4)) End Function

Alle benodigde gegevens zijn nu ingelezen om een assembly te creëren met behulp van de opgegeven afmetingen. Bij het clicken van de Create Assembly button, wordt de volgende procedure doorlopen. Sub CreateAssembly() Dim Folder As String Dim BasePart As String Dim MetalPart As String Dim FibrePart As String Folder = (Application.ActiveWorkbook.Path + “\Data\”

)

' Full Path to Data directory

Na het declareren van de variabelen worden de datafiles gelokaliseerd. Hier wordt het path gebruikt, waar het Excel bestand is opgeslagen en wordt het path uitgebreid met de data folder. note Voordat de assembly daadwerkelijk gemaakt kan wordt is het dus belangrijk de datafolder, met alle te gebruiken parts, eerst te copiëren naar je eigen werkgebied op dezelfde locatie als het Excel bestand. BasePart = "BaseDisk" MetalPart = Sheets("Clutch").Cells(6, 2) + "_Metal" FibrePart = Sheets("Clutch").Cells(6, 2) + "_Fibre" Call BuildAssembly(Sheets(“Clutch”).Cells(7, 2), BasePart, MetalPart, FibrePart, Folder) End Sub

Afhankelijk van de keuze van de gebruiker, moeten verschillende parts uit de data directory gebruikt worden. Dit verklaart de afhankelijkheid van de Cells(6,2), ga dit na. Alle benodigde informatie om de assembly daadwerkelijk te gaan creëren is nu bekend. Rest ons nog de procedure BuildAssembly te implementeren.

25-4


Macro Opnemen Voordat we beginnen met het aanpassen van de code, proberen we eerst inzicht te krijgen in de toe te passen programmeer code. Daartoe creëren we eerst een eenvoudige assembly in SolidWorks, terwijl een macro alle handelingen opneemt. Door de opgenomen code te bekijken, proberen we vertrouwd te geraken met de programmeer code. 1. 2. 3. 4.

5. 6. 7.

Start SolidWorks en begin met het opnemen van een Macro. Open BaseDisk.SLDPRT, High_Fibre.SLDPRT, en High_Metal.SLDPRT uit de folder: ..\VBasic\AssemblyCreation\Data\. Creëer een New Assembly. Tile de windows, en voeg de verschillende parts in de assembly door middel van drag and drop.

Sluit alle windows, behalve de assembly. Breng een aantal mates aan tussen de parts onderling. Stop de macro en bekijk de opgenomen code.

Wat is de code voor het creëren van mates? Creëer en bekijk ook een macro, waarbij er een aantal dezelfde parts in een assembly wordt gebracht. Breng hierbij verschillende soorten mates aan. 10. Sluit alle windows in SolidWorks en ga terug naar de Excel sheet. 8. 9.

25-5


Aanpassen van de Basis Code De programmacode die in de vorige paragraaf stap voor stap is uitgelegd, functioneert al voor een groot deel. Wat nu nog geïmplementeerd moet worden is de functie BuildAssembly in de module Assembly. Voor hulp kan altijd het voltooide programma geraadpleegd worden in de ..\VBasic\AssemblyCreation\Finish\ directory. 1. 2. 3. 4.

Ga naar de folder ..\VBasic\AssemblyCreation\Start in je werkgebied. Open het Clutch.xls bestand. Zorg dat de programma code toegankelijk wordt door de Control Toolbox te activeren. Ga naar de Assembly module.

We zijn nu op het punt aangekomen, waarop we stap voor stap de BuildAssembly functie gaan implementeren. Daartoe moet de bestaande procedure uitgebreid worden met: • • • • •

Declareren van variabelen; Verbinden met SolidWorks; De benodigde Parts openen; De parts toevoegen aan een assembly; Mates in assembly aanbrengen tussen de parts onderling.

Public Function BuildAssembly (nPairs As Integer, BottomDisk As String, MetalDisk As String, _ FibreDisk As String, Folder As String) As Boolean Dim swApp As Object Dim Assembly As Object Dim i As Integer Dim RefPlane1 As String Dim RefPlane2 As String Dim Axis1 As String Dim Axis2 As String MsgBox "Building assembly of " + Str(nPairs) + Chr(13) + _ "of " + MetalDisk + " and " + FibreDisk + Chr(13) + _ "and Base " + BottomDisk Set swApp = CreateObject("SldWorks.Application") Set Assembly = swApp.NewAssembly

5.

Neem bovenstaande code over op de juiste plek. Wat gebeurt hier?

Voordat de verschillende parts kunnen worden toegevoegd aan een assembly, moeten ze eerst geopend worden. Kopieer in het vervolg van deze paragraaf de code uit de box in je eigen programma op het moment dat duidelijk is wat er gebeurt.

25-6


If swApp.OpenDoc(Folder + BottomDisk + ".sldprt", swDocPART) Is Nothing Then MsgBox "Could not open " + BottomDisk Exit Function ElseIf swApp.OpenDoc(Folder + MetalDisk + ".sldprt", swDocPART) Is Nothing Then MsgBox "Could not open " + MetalDisk Exit Function ElseIf swApp.OpenDoc(Folder + FibreDisk + ".sldprt", swDocPART) Is Nothing Then MsgBox "Could not open " + FibreDisk Exit Function End If

De volgende stap is het toevoegen van de parts aan de assembly. De syntax hiervoor is AssemblyDoc.AddComponent (compName, x, y, z), waarbij compName de naam van het betreffende part is en x,y,z de plaatsingscoördinaten voorstellen.

Assembly.AddComponent BottomDisk, 0#, 0#, 0#

' Add the base plate

RefPlane2 = "RefPlane2@" + BottomDisk + "-1@" + Assembly.GetTitle Axis2 = "Axis1@" + BottomDisk + "-1@" + Assembly.GetTitle

Nadat de base_plate is toegevoegd aan de assembly, wordt een referentievlak en as gedefinieerd, die later gebruikt zullen worden om in het geheel relaties tussen parts onderling aan te geven. De volgende stap is het toevoegen van de benodigde aantal MetalDisks. Dit doen we in een For-lus net zolang tot er voldoende zijn toegevoegd. Iedere MetalDisk krijgt in deze lus zijn eigen nummer (Format(i)). Ook wordt er tijdelijk de RefPlane1 en Axis1 aan het betreffende part toegekend, zodat het part direct met een mate kan worden gepositioneerd ten opzichte van de BottomDisk.

' Add the metal/fibre pairs For i = 1 To nPairs Assembly.AddComponent MetalDisk, 0#, 0#, 0#

' Add the metal disks ' Add the mates

RefPlane1 = "RefPlane1@" + MetalDisk + "-" + Format(i) + "@" + Assembly.GetTitle Axis1 = "Axis1@" + MetalDisk + "-" + Format(i) + "@" + Assembly.GetTitle Assembly.SelectByID RefPlane2, "PLANE", 0, 0, 0 Assembly.AndSelectByID RefPlane1, "PLANE", 0, 0, 0 Assembly.AddMate swMateCOINCIDENT, swAlignSAME, 0, 0#, 0# Assembly.SelectByID Axis1, "AXIS", 0, 0, 0 Assembly.AndSelectByID Axis2, "AXIS", 0, 0, 0 Assembly.AddMate swMateCOINCIDENT, swAlignAGAINST, 0, 0#, 0# RefPlane2 = "RefPlane2@" + MetalDisk + "-" + Format(i) + "@" + Assembly.GetTitle Axis2 = "Axis1@" + MetalDisk + "-" + Format(i) + "@" + Assembly.GetTitle

De syntax voor de matecode is: Assembly.AddMate (mateType, align, flip, dist, angle). In dit geval wordt er niets geflipt of geroteerd en wordt er geen afstand of hoek voorgeschreven. Enkel het type mate en de manier van aligning wordt opgegeven. Voor de verschillende mogelijkheden om onderdelen ten opzichte van elkaar te positioneren (maten en alignen) wordt verwezen naar de Help-file: AssemblyDoc::AddMate.

25-7


Hetzefde moet gebeuren voor de FibreDisk. ' Add the fibre disk Assembly.AddComponent FibreDisk, 0#, 0#, 0# ' Add the mates RefPlane1 = "RefPlane1@" + FibreDisk + "-" + Format(i) + "@" + Assembly.GetTitle Axis1 = "Axis1@" + FibreDisk + "-" + Format(i) + "@" + Assembly.GetTitle Assembly.SelectByID RefPlane2, "PLANE", 0, 0, 0 Assembly.AndSelectByID RefPlane1, "PLANE", 0, 0, 0 Assembly.AddMate swMateCOINCIDENT, swAlignSAME, 0, 0#, 0# Assembly.SelectByID Axis1, "AXIS", 0, 0, 0 Assembly.AndSelectByID Axis2, "AXIS", 0, 0, 0 Assembly.AddMate swMateCOINCIDENT, swAlignAGAINST, 0, 0#, 0# RefPlane2 = "RefPlane2@" + FibreDisk + "-" + Format(i) + "@" + Assembly.GetTitle Axis2 = "Axis1@" + FibreDisk + "-" + Format(i) + "@" + Assembly.GetTitle Next i

Op deze mannier worden de Metal- en FibreDisks één voor één in de assembly gezet en direct voorzien de juiste mate. 11. Save je Clutch.xls en open SolidWorks. 12. Click de Create Assembly button en click OK en bekijk wat er gebeurt in SolidWorks. Verander een aantal waarden in je Excel sheet en run het programma. Zorg er wel voor dat bij het opnieuw uitvoeren van je programma, alle parts en assemblies in SolidWorks weer gesloten zijn. Dit heeft te maken met de aanroep van bestanden in je programma. Er kunnen geen kopieën van parts gebruikt worden, omdat deze dan een andere naam toebedeeld krijgen die niet overeen komen met de bestand namen in je programma! Ga maar na...

25-8

Hoofdstuk 26

Configureren van een Assembly

In deze oefening breiden we het programma uit het vorige hoofdstuk uit. In plaats van een groot aantal kopieën van onderdelen, wordt gebruik gemaakt van we design tables en configuraties. De volgende onderwerpen komen aan de orde:

Design Tables, Configuratie Display.

De oefening in dit hoofdstuk bouwt voort op de vorige oefening met de Clutch.xls. In plaats van het gebruik van meerdere kopieën van verschillende onderdelen moet dezelfde assembly als in het vorige hoofdstuk gecreëerd worden doormiddel van Design Tables. Op deze manier kan het project beperkt worden tot het gebruik van slechts drie part files.

26-1

Hoofdstuk 26, Configureren van een Assembly

Aanmaken Design Tables Zoals eerder vermeld, bevat een Design Table de geometrische informatie op basis waarvan parts kunnen worden gedimensioneerd en getekend. Voor elke uitvoering van de metal- en fibre-disk (zie vorige hoofdstuk), wordt afhankelijk van het type, de dikte van de schijf gedimensioneerd door middel van een Design Table. 1. 2.

Creëer onderstaande Excel sheet en Save het als Config_Metal.xls in je eigen werkdirectory. Doe hetzelfde voor Config_Fibre.xls.

Sluit Excel en open in SolidWorks de parts Config_Metal.sldprt en Config_Fibre.sldprt uit de folder ..\VBasic\AssemblyConfiguration\Start\. De zojuist geopende parts zijn dezelfde als die in het vorige hoofdstuk gebruikt, maar met een andere naam. 3.

4.

Insert in de betreffende parts de bijbehorende Design Table, aangemaakt in stappen 1 en 2.

Voor deze oefening zijn twee VB projecten beschikbaar. Eén versie in AssemblyConfiguration\Start en één in ..\ Finish.

Merk op dat drie configuraties in de Configuratie Manager zijn aangemaakt. 5.

Sluit de design table door er buiten te clicken en Save de twee aangepaste bestanden in je eigen werkdirectory. Sluit de parts af (close).

Het voordeel van het werken met de zojuist aangemaakte Design Tables is, dat er slechts 3 in plaats van 7 bestanden nodig zijn om alle koppelingsplaten te modeleren (vergelijk met de benodigde bestanden uit de data directory van het vorige hoofdstuk). Er moeten echter wel enkele aanpassingen worden aangebracht in de macro ten opzichte van vorig hoofdstuk.

26-2


Aanpassen BuildAssembly De BuildAssembly functie moet worden aangepast, zo dat de juiste configuraties voor de verschillende onderdelen gebruikt kunnen worden. Hiervoor moet de configuratienaam in de procedure worden opgenomen. Verder moet met de API functie ModelDoc.ShowConfiguration2 de configuratie van de verschillende onderdelen worden getoond, voordat deze met de functie AddComponent aan de assembly wordt toegevoegd. Voordat we beginnen met het aanpassen van de BuildAssembly code uit de Assemblymode, passen we eerst de Sub CreateAssembly in de UserInterface-mode aan. 1. 2.

Open de Excel sheet Clutch.xls uit ..\VBasic\AssemblyConfiguration\Start òf je eigen werkende bestand, die je in het vorige hoofdstuk hebt aangemaakt. Zorg dat de programmacode van de sheet aangepast kan worden en ga in de module UserInterface naar de functie Sub CreateAssembly().

Sub CreateAssembly() Dim Folder As String Dim BasePart As String Dim MetalPart As String Dim FibrePart As String Dim Config As String NB De regel Folder = (.. moet worden aangepast aan de nieuwe locatie van de part-files.

Folder = (Application.ActiveWorkbook.Path )

' Full Path to Data directory ' Generate the file names

Config = Sheets("Clutch").Cells(6, 2) BasePart = "BaseDisk" MetalPart = "Config_Metal" FibrePart = "Config_Fibre" Call BuildAssembly(Sheets(“Clutch”).Cells(7, 2), Config, BasePart, MetalPart, FibrePart, Folder) End Sub

3. 4. 5.

Pas de code zoals in bovenstaande box aan. Merk op dat de Metal- en FibrePart niet meer variabel zijn. Het onderscheid tussen een Turbo, High of Race koppelingsplaat wordt nu gemaakt in SolidWorks met de aangemaakte Design Tables. Vergeet niet de extra variabele Config bij de aanroep van de functie BuildAssembly te vermelden. Dit geldt ook voor de BuildAssembly functie zelf! Ga naar de module Assembly en vervang het stuk code, dat de parts opent, met onderstaande code.

' Open the part files (before they can be added) If swApp.OpenDoc(Folder + BottomDisk + ".sldprt", swDocPART) Is Nothing Then MsgBox "Could not open " + BottomDisk Exit Function End If Set Part = swApp.OpenDoc(Folder + MetalDisk + ".sldprt", swDocPART) If Part Is Nothing Then MsgBox "Could not open " + MetalDisk Exit Function Else Part.ShowConfiguration2 Config End If Set Part = swApp.OpenDoc(Folder + FibreDisk + ".sldprt", swDocPART) If Part Is Nothing Then

26-3


MsgBox "Could not open " + FibreDisk Exit Function Else Part.ShowConfiguration2 Config End If

Het belangrijkste verschil met vorige code is het aanroepen van Part.ShowConfiguration2 Config. De syntax hiervoor is: ModelDoc.ShowConfiguration2 (configurationName) Waarbij de input de betreffende configuratie is die zichtbaar moet worden gemaakt in SolidWorks. De output wordt True als de configuratie succesvol geactiveerd wordt. 6.

Als het nog niet gebeurd is, moet de extra input (Config as String) in de BuildAssembly functie nog worden opgenomen.

Public Function BuildAssembly(nPairs As Integer, Config As String, BottomDisk As String, _ MetalDisk As String, FibreDisk As String, _ Folder As String) As Boolean

7. 8.

Ga terug naar de Excel sheet en Save je bestand in je eigen werkdirectory. Test het programma.

Merk op dat de gekozen configuratie (hier High) in de geopende parts actief is.

26-4

Hoofdstuk 27

Assembly traversal

Traverse = dwarsverband Traversal (engels) is het langslopen van alle verbinden in de datastructuur.

Deze oefening is gericht op het vergaren van component informatie uit een assembly door traversal (het doorlopen) van de datastructuur. De oefening wordt uitgevoerd vanuit een Excel sheet. Het doel is het maken van een lijst met alle componenten en het aantal keer dat ze voorkomen in de Assembly. Aan de orde komen:

Assembly Component Traversal, Recursion, Assembly Component Queries.

27-1

Hoofdstuk 27, Assembly traversal

Open Bestaand Document Voor deze oefening zijn twee VB projecten beschikbaar. Eén versie in Assemblytraversal\Start en één in ..\Finish.

Zorg voor een copy van de Vbasic folder in je werkgebied. Start Microsoft Excel en open de bestaand spreadsheet Parser.xls uit de directory ..\VBasic\Assembly Traversal\Start. 1. Click File, Open.., Parser.xls 2. Click Tools, Macro, Macros 3. Edit Auto_open 4. Open in Vbasic de Project Explorer dialog

Onder sheet 1 (Assembly) is slechts de onderstaande code te vinden. Private Sub CommandButton1_Click() ParseAssembly End Sub

De code van de aangeroepen functie ParseAssembly, staat in module1. 5. Ga naar Module1

Structuur aanwezige module1 De structuur van deze module is betrekkelijk eenvoudig en kan als volgt worden samengevat. • Sub ParseAssembly In deze procedure wordt achtereenvolgens: De worksheet schoongeveegd, de titel van de actieve assembly in SolidWorks in de sheet gezet, de actieve assembly doorlopen op zoek naar parts en worden de namen en aantallen in de sheet gezet. Voor de eerste en de laatste actie zijn procuderes gemaakt. Deze worden in dezelfde form geïmplementeerd. • Private Sub TraverseComponent(Component As Object) Doorloopt de assembly voor parts. • Sub Auto_Open() Runt automatisch het programma bij openen • Private Sub AddNameToSheet(name As String) Zorgt ervoor dat de naam van een part toegevoegd wordt aan de Excel Sheet. • Private Sub WipeWorksheet() Veegt oude waarden van de Excel Sheet.

27-2


Sub ParseAssembly In deze procedure wordt achtereenvolgens: • de WorkSheet schoongeveegd, • de titel van de actieve assembly in SolidWorks in de sheet gezet, • de actieve assembly doorlopen op zoek naar parts en • de namen en aantallen in de sheet geplaatst. Sub ParseAssembly() Dim swApp As Object Dim Part As Object Dim Configuration As Object Dim RootComponent As Object Set swApp = CreateObject("SldWorks.Application") swApp.Visible = True Set Part = swApp.ActiveDoc If Part Is Nothing Then MsgBox "Solidworks does not have an Assembly loaded" Exit Sub End If If Part.Gettype <> 2 Then MsgBox "Solidworks does not have an Assembly loaded" Exit Sub End If WipeWorksheet Worksheets("assembly").Range("A1").Value = "Assembly : " + Part.GetTitle Set Configuration = Part.GetActiveConfiguration Set RootComponent = Configuration.GetRootComponent TraverseComponent RootComponent End Sub

In de eerste twee gearceerde regels wordt de WorkSheet leeg geveegd en wordt de naam van de assembly in cel A1 van de WorkSheet gezet. De standaard aanroepen voor het doorlopen van een assembly zijn: • ModelDoc.GetActiveConfiguration(slecht eenmaal) • Configuration.GetRootComponent (slechts eenmaal) • Component.GetChildren (recursieve aanroep) De eerste twee zijn erop gericht om in de root van de assembly te geraken. Daarna wordt deze root doorlopen. De aanroep GetChildren wordt uitvoering besproken in Private Sub TraverseComponent(Component As Object)

Sub Auto_Open() Deze Sub zorgt ervoor dat de complete macro automatisch gerund wordt bij het opstarten van het programma. Sub Auto_Open() Call ParseAssembly End Sub

27-3


Toevoegen extra code Private Sub TraverseComponent(Component As Object) In deze sub-paragraaf wordt stap voor stap de code van Private Sub TraverseComponent(Component As Object) getoond. Het is de bedoeling dat deze code wordt overgenomen. Stap 1 Met het commando Getchildren wordt de variabele Children gelijk gesteld aan de Children die zich in de root bevinden. Private Sub TraverseComponent(Component As Object) Dim Children As Variant Dim Child As Object Dim ChildCount, i As Integer Dim Model As Object Children = Component.GetChildren

Stap2 Deze code dient ter controle van het type van de Children. If VarType(Children) <> 8201 Then 'Check the Type, 8201 = (vbArray) 8192 + (vbObject) 9 MsgBox "Invalid Variant returned from GetChildren" Exit Sub End If

Stap 3 In deze stap wordt eerst het aantal Children aan de root geteld. Daarna wordt in de for-loop, voor ieder Child onderzocht of er nog meer Children (klein kinderen) zijn. Een Child dat als laatste in de rij staat, heeft de waarde 1, een Child dat ook Parent is heeft waarde 2. Alle takken van de Root component worden doorlopen totdat een Child met waarde 1 wordt gevonden. De naam van dat Child wordt in de tekening gezet met AddNameToSheet. De implementatie van deze procedure is het logische vervolg op Private Sub TraverseComponent(Component As Object) ChildCount = UBound(Children) ' get the upper bound of the children array For i = 0 To ChildCount Set Child = Children(i) Set Model = Child.GetModelDoc If Model.Gettype = 2 Then ' recurse into the sub assembly TraverseComponent Child ElseIf Model.Gettype = 1 Then ' part AddNameToSheet Model.GetTitle End If Next i End Sub

27-4


Private Sub AddNameToSheet(name As String) Stap 1 in het implementeren is het declareren van variabelen en het initialiseren van de waarde van Row en Found. Private Sub AddNameToSheet(name As String) Dim row As Integer Dim found As Integer Dim old_count As Integer row = 4 found = 0

Stap2 In deze lus wordt gechecked of de naam van het toe te voegen part al in de sheet staat. De waarde van Found is gelijk aan de rij waarin de naam staat of, wanneer er de naam nog niet in de sheet staat, gelijk aan 0. In het laatste geval wordt de loop verlaten en wijst row naar de eerste vrije rij. Do While (Worksheets("assembly").Cells(row, 1).Value <> "") If Worksheets("assembly").Cells(row, 1).Value = name Then found = row Exit Do End If row = row + 1 Loop

Stap 3 Het volgende if-statement zorgt voor het toevoegen van de naam op de juiste plaats. Wanneer de naam reeds bestaat wordt het aantal keer dat de part voorkomt opgehoogd. If found <> 0 Then old_count = Worksheets("assembly").Cells(found, 2).Value old_count = old_count + 1 Worksheets("assembly").Cells(found, 2).Value = old_count Else ' add the new row Worksheets("assembly").Cells(row, 1).Value = name Worksheets("assembly").Cells(row, 2).Value = 1 End If End Sub

Private Sub WipeWorksheet() Om te beginnen met een schone WorkSheet wordt deze procedure aangeroepen. In de While lus worden vanaf de 4de rij alle rijen leeg gemaakt totdat de lus bij een rij aankomt waar geen data meer in staat. Private Sub WipeWorksheet() Dim row As Integer row = 4 While (Worksheets("assembly").Cells(row, 1).Value <> "") Worksheets("assembly").Cells(row, 1).Value = "" Worksheets("assembly").Cells(row, 2).Value = "" row = row + 1 Wend End Sub

27-5


Test Run Om het programma te kunnen testen moet het active document in SolidWorks een assembly zijn. Bovendien is het nodig dat alle gegevens van de onderdelen beschikbaar zijn. De onderdelen mogen niet in lightweigth mode zijn geladen.

LightWeight vs Resolved Parts De performance van SolidWorks bij grote assemblies wordt flink verhoogd, wanneer gebruik wordt gemaakt van lightweight parts. Een assembly met lightweight parts is sneller te laden en bewerken dan de zelfde assembly met zogenaamde resolved parts. Van lightweight parts wordt namelijk alleen de visulele data van de eindtoestand geladen. Een feature toevoegen of een parameter wijzigen is in deze mode niet mogelijk. Wanneer een onderdeel wordt geselecteerd en gewijzigd, veranderd het in een resolved (opgelost) part. NB Runtime errors of andere fouten ontstaan wanneer de aanwijzing in deze note niet zijn opgevolgd!

note: Een lightweight component gaat niet altijd automatisch over naar resolved. Benadering via de API met een Visual Basic programma levert foutmeldingen op als “Unable to resolve Object”. Schakel voor het werken met assemblies de lightweight optie uit door onder Tools, Options, Performance, de optie Automatically Load Parts LightWeight uit te zetten.

Start Openen van een assembly. Start SolidWorks en laad de assembly ..\VBasic\Assembly Traversal\Crank\Crank-Assy

Ga naar de Excel worksheet en druk op de Refresh knop: de spreadsheet vult zich met de namen van de onderdelen en het aantal keren dat ze voorkomen.

27-6

Hoofdstuk 28

Tekeningen creëren

Het kan wenselijk zijn om van een onderdeel in een bepaalde view een tekening te hebben, waarin attributes van vlakken worden weergegeven als notes bij de betreffende vlakken. In dit hoofdstuk komen de volgende onderwerpen aan de orde:

Aanmaken van een nieuwe Drawing, Opvragen van Drawing Values, Opslaan van Model Views, Transformatie 3D naar 2D, Opvragen van Attributes.

U leert een drawing te creëren van een bestaand part met behulp van een Visual Basic programma. Daarvoor moeten allerlei values van de part worden ingelezen en moet het 3D model worden vertaald naar een 2D model in de stand waarin de part in de drawing moet worden opgenomen.

28-1

Hoofdstuk 28, Tekeningen creëren

Uitleg Programma Code Alvorens begonnen wordt met het programmeren, wordt eerst de programma code bekeken zoals die reeds in de start folder aanwezig is. Voor deze oefening zijn VB projecten beschikbaar. Kopieer VBasic uit ..\install_dir\ naar je eigen werkgebied.

1. 2.

Start Visual Basic, en open DrawingCreatie.vbp uit de directory: ..\VBasic\DrawingCreation\Start\. Click View, Project Explorer en open de Form1(DrawingCreatie.frm).

Ook in dit project is gebruik gemaakt van de swconst.bas (Module1). 3.

Bekijk de code van de form1 door op de form te double clicken.

De code blijkt gereed op de implementatie van de DrawingBtn_Click() functie na. De start programma code is opgebouwd uit een tweetal functies (de twee buttons): • Private Sub DrawingBtn_Click(), • Private Sub ExitBtn_Click(),

Sub DrawingBtn_Click() Private Sub DrawingBtn_Click() Dim FaceAttributeDef As Object Dim swApp As Object Dim Part As Object Dim Drawing As Object ' Attach to solidworks and check that a part is loaded Set swApp = CreateObject("SldWorks.Application") ' attach to SolidWorks Set Part = swApp.ActiveDoc ' get the PartDoc for the current Part swApp.Visible = True


If Part Is Nothing Then ' no part loaded into SolidWorks swApp.SendMsgToUser ("No Part loaded") Unload Me Exit Sub End If If (Part.GetType <> swDocPART) Then swApp.SendMsgToUser ("This is not a part") Unload Me Exit Sub End If

De procedure wordt gestart met het declareren van variabelen. Verder wordt er een verbinding gemaakt met SolidWorks en een eventuele foutmelding gegenereerd. Daarna worden de face attributes ingelezen die de machine-informatie bevat, zoals de feed rate, cutting speed en de notes parameters.

28-2


De underscore ( _ ) aan het eind van de regel betekent, dat de volgende regel er bij hoort.

Set FaceAttributeDef = swApp.DefineAttribute("FaceAttribute") ' Define the attribute If FaceAttributeDef.AddParameter("FeedRate", swParamTypeDouble, 0#, 0) And _ FaceAttributeDef.AddParameter("CuttingSpeed", swParamTypeDouble, 0#, 0) And _ FaceAttributeDef.AddParameter("FaceNote", swParamTypeString, 0#, 0) Then ' Add the parameters FaceAttributeDef.Register ' And finally register it End If End Sub

De rest van deze procedure gaan we in de volgende paragraaf stap voor stap implementeren. Dit is dan ook het belangrijkste gedeelte van dit hoofdstuk. Hier moet het drawing proces in gang worden gezet. Als er bepaalde attributes aanwezig zijn op de vlakken, dienen deze ingelezen te worden en te worden weergegeven als notes in de tekening met een pijltje in de richting van het betreffende vlak waar de note bij hoort. ' TODO - add your code here to complete the exercise, this code must do the following: ' 1) create a named view of the active part ' 2) create a new drawing ' 3) get the sheet object from the drawing and get its size ' 4) create a drawing view from the named model view, centered in the drawing ' 5) select the drawing view and use the selection manager to retrieve the view object ' 6) get the transform of the view - to be used to add notes to the correct corresponding position in the view ' 7) traverse all the faces in the part and check each one for an attribute of the correct type ' 8) if an attribute is found on a face then we need to get a point in the model space on that face and ' transform it to to the view. To do this get the edges from the face and find the first face that ' has a vertex (an enclosed circle will not have one for example)then get the coords of the vertex ' 9) transform the coords ' 10) place a note at the transformed location containing the attribute details End Sub

De volgorde waarin we straks te werk zullen gaan is al aangegeven.

Private Sub ExitBtn_Click() Private Sub ExitBtn_Click() Unload Me End Sub

Het Unload Me statement moet intussen bekend zijn. Save het bestand in je eigen werkdirectory.

28-3


Aanpassen van de Basis Code Zoals is vermeld in de vorige paragraaf, zijn de punten 1 tot en met 10 de belangrijkste zaken die nog geïmplementeerd moeten worden om een werkende applicatie te maken. In deze paragraaf zal de implementatie stap voor stap worden uitgevoerd. De belangrijkste en/of nieuwste commando’s zullen hierbij de revue passeren. Voor de complete programma code wordt u verwezen naar het Visual Basic bestand, dat te vinden is in ..\Finish\ directory behorend bij dit hoofdstuk.

Private Sub DrawingBtn_Click() Dim FaceAttributeDef As Object Dim swApp As Object Dim Part As Object Dim Drawing As Object Dim SelMgr As Object Dim View As Object Dim ViewXForm As Variant Dim Body As Object Dim NoteTxt As String Dim NoteTxt2 As String Dim AttInstance As Object Dim FacePoint As Variant Dim Edges As Variant Dim Edge As Object Dim Vertex As Object Dim Sheet As Object Dim SheetProperties As Variant Dim X As Double Dim Y As Double Dim Z As Double

1.

Zorg dat bovenstaande variabelen ook in jouw programma gedeclareerd worden.

De volgende code in de tekstboxen moet worden opgenomen op de plaats waar puntsgewijs is opgesomd wat er allemaal nog geïmplementeerd moet worden.

Stap 1 Het maken van een named view van de active part. Part.DeleteNamedView "MyView" Part.NameView "MyView"

' remove any named view that is already defined ' add a new named view, of the current view

Stap 2 Het creëren van een nieuwe drawing. Set Drawing = swApp.NewDrawing2(13, """", 0, 0, 0)

' create a new drawing with no template

Set Sheet = Drawing.GetCurrentSheet

' get the sheet object of the drawing

Met de functie SldWorks.NewDrawing2 ( templateToUse, templateName, paperSize, width, height) wordt een nieuwe drawing gecreëerd. In de Module1 (swconst.bas) is een overzicht te vinden van de templates waaruit gekozen kan worden. 2.

28-4

Zoek met behulp van de Edit, Find… functie in de Module1 in VisualBasic de verschillende mogelijkheden op en zoek uit wat de 13 betekent.


Stap 3 Het ophalen van de sheet properties, om de grootte te bepalen. SheetProperties = Sheet.GetProperties

Via de Sheet.GetProperties functie worden zes doubles opgehaald: [templateIn, scale1, scale2, firstAngle, width, height ] Waarbij: templateIn scale1 scale2 firstAngle width height

= template index. Zie Module1(swconst.bas) swDwgTemplates_e, = the scale numerator = the scale denominator = First Angle Projection is TRUE and FALSE otherwise, = the paper width, = the paper height.

Stap 4 Het creëren van een drawing view van het part, waarbij de grootte van de sheet wordt gebruikt om het te centreren. Drawing.CreateDrawViewFromModelView Part.GetPathName, "MyView", SheetProperties(5) / 2, SheetProperties(6) / 2, 0 Drawing.SelectByID "Drawing View1", "DRAWINGVIEW", 0, 0, 0 ' select the drawing view

De functie DrawingDoc.CreateDrawViewFromModelView ( modelName, viewName, locX, locY, locZ) creëert een drawing view in de huidige drawing sheet, gebruik makend van de gespecificeerde view, “My View”. Het centrum van de view wordt geplaatst op de locatie (x,y,z). In dit geval wordt er gecentreerd door de helft te nemen van de hoogte en breedte van de sheet. Ga dit na.

Stap 5 Selectie van de drawing view en het gebruik van de selectie manager om het view object terug te vinden. Set SelMgr = Drawing.SelectionManager() ' use the selection manager to get the view object If Not SelMgr.GetSelectedObjectCount = 1 Then MsgBox "Please Select the view to annotate" Exit Sub End If If Not SelMgr.GetSelectedObjectType(1) = swSelDRAWINGVIEWS Then MsgBox "Please Select the view to Annotate" Exit Sub End If Set View = SelMgr.GetSelectedObject(1)

' Get the first item in the selection list, this will be the drawing view

Het gebruik van de selectiemanager is reeds eerder behandeld.

Stap 6 Bepaal de transformatie van de view, om de notes te positioneren. ViewXForm = View.GetViewXForm

' get the transform from the model to the drawing view

Set Body = Part.Body

' get the body from the part

De GetViewXForm methode wordt gebruikt om de transformatie gegevens van model space origin naar the drawing space origin op te slaan. De data wordt opgeslagen in een array van 13 doubles: [0-8] is a 3x3 transformatie van de view rotatie, [9-11] is a 1x3 transformatie van translatie, [12] is de schaling van de transformatie. Later in ons programma, zal deze transformatie-data gebruikt worden om eventuele notes op de juiste plek in de drawing te laten verschijnen.

Stap 7 Controleren of de faces in het part een attribute hebben van het juiste type. 28-5


Set Face = Body.GetFirstFace While Not Face Is Nothing Set AttInstance = Face.FindAttribute(FaceAttributeDef, 0) 'attempt to get the attribute If Not AttInstance Is Nothing Then 'is there an attribute on the face ? Set AttParameter = AttInstance.GetParameter("FeedRate") NoteTxt = "Feed Rate : " + CStr(AttParameter.GetDoubleValue) + Chr(13) Set AttParameter = AttInstance.GetParameter("CuttingSpeed") NoteTxt = NoteTxt + ", Cutting Speed : " + CStr(AttParameter.GetDoubleValue) + Chr(13) Set AttParameter = AttInstance.GetParameter("FaceNote") NoteTxt = NoteTxt + ", Notes : " + CStr(AttParameter.GetStringValue)

Ieder vlak moet worden gecontroleerd of er attributes aan zijn toegevoegd. Wanneer dat het geval is, wordt er een note gecreëerd. In de volgende stap worden de coördinaten van de te plaatsen note bepaald.

Stap 8 Als een attribute is gevonden, dan moet er een punt op dat vlak verkregen worden en getransformeerd worden naar de view. Daartoe moet een edge van de face gebruikt worden om een hoek (vertex) te localiseren. Hiervan moeten de coördinaten worden ingelezen. Edges = Face.GetEdges For i = 0 To Face.GetEdgeCount - 1 Set Edge = Edges(i) Set Vertex = Edge.GetStartVertex If Not Vertex Is Nothing Then Exit For End If Next i FacePoint = Vertex.GetPoint

' get the edges from the face ' get each face in turn ' get the start vertex of the edge ' check that the edge has a vertex

' get the coords of the vertex, these will be a point on the face

Stap 9 Transformeer de coördinaten, zodat de notes bij de juiste vlakken in de drawing view komen te staan. Let X = (ViewXForm(0) * FacePoint(0) + ViewXForm(3) * FacePoint(1) + ViewXForm(6) * FacePoint(2)) * ViewXForm(12) + ViewXForm(9) Let Y = (ViewXForm(1) * FacePoint(0) + ViewXForm(4) * FacePoint(1) + ViewXForm(7) * FacePoint(2)) * ViewXForm(12) + ViewXForm(10) Let Z = (ViewXForm(2) * FacePoint(0) + ViewXForm(5) * FacePoint(1) + ViewXForm(8) * FacePoint(2)) * ViewXForm(12) + ViewXForm(11)

Hier wordt de transformatie-data-array van 13 doubles ViewXForm(0-12), uit stap 6, gebruikt om de juiste coördinaten te verkrijgen voor de te creëren notes.

28-6


Stap10 Het invoegen van de note op de berekende positie Drawing.SelectByID "Drawing View1", "DRAWINGVIEW", X, Y, Z Drawing.InsertNewNote2 NoteTxt, "", False, True, swCLOSED_ARROWHEAD, swLS_SMART, 0#, 4, 0, 0, 0 End If Set Face = Face.GetNextFace Wend

Met de functie Drawing.InsertNewNote2 ( upperText, Unused1, noLeader, bentLeader, arrowStyle, leaderSide, angle, balloonStyle, balloonFit, Unused2, Unused3) wordt er een nieuwe note gecreëerd. De functievariabelen zijn: UpperText: Unused1: NoLeader: BentLeader: ArrowStyle: LeaderSide: Angle: BalloonStyle: BalloonFit: Unused2: Unused2:

dit is de te creëren tekst string voor in de note, voor dit argument moet een empty string worden opgenomen, TRUE voor geen leaderline, anders FALSE, TRUE for a bent leaderline, FALSE otherwise, pijlpunt type, zie swArrowStyle_e uit de bekende Module1, kant van de Leaderline, zie swLeaderSide_e, de tekst hoek, Balloon style type, zie swBalloonStyle_e, Balloon fit type, see swBalloonFit_e, deze waarde wordt niet gebruikt, gezet op 0. deze waarde wordt niet gebruikt, gezet op 0.

Nadat de note is gecreëerd, worden de stappen 7, 8, 9 en 10 opnieuw doorlopen voor een volgend vlak. De procedure stopt op het moment dat alle vlakken zijn gecontroleerd op attributes. 3.

Save je programma in je eigen werkdirectory, nadat je bovenstaande code hebt overgenomen.

28-7


The proof of the pudding is in the eating Start SolidWorks en Open het bestand api.SLDPRT uit de start directory behorende bij dit hoofdstuk. Test je programma voor verschillende views.

28-8

Hoofdstuk 29

Topology traversal

3D topologie beschrijft de samenhang van de stukken geometrie. Een volume wordt gevormd door begrenzende vlakken. Vlakken (faces) worden gevormd door een serie (loop) aaneensluitende randen (edges). Randen worden opgespannen tussen punten (vertices).

In het programma van hoofdstuk 24, Attributen verzamelen, is duidelijk geworden hoe alle faces van een part kunnen worden benaderd. In deze opdracht benaderen we ook andere geometrie. De complete topologie wordt gescand (traversal) om de verschillende loops en edges van faces te beoordelen. In deze oefening wordt het aantal holes (gaten) in een face geteld. In dit geval is een hole gedefinieerd als een loop die slechts bestaat uit één complete cirkel. Hierbij worden de volgende onderwerpen behandeld: Selection Management, Loop Traversal, Loop Queries, Edge Traversal, Edge Queries.

29-1

Hoofdstuk 29, Topology traversal

Open Bestaand Document Voor deze oefening zijn VB projecten beschikbaar. Kopieer VBasic uit ..\install_dir\ naar je eigen werkgebied.

Start SolidWorks en open het bestaande document HolesPlate.sldprt in je werkdirectory onder ..\VBasic\TopologyTraversal 1. Click File, Open…, HolesPlate.sldprt Start VBasic en open ..\Start\GeomTraversal.vbp 2. Click Open Project…, GeomTraversal.vbp 3. Bekijk de programma code.

De beoogde werking is om het aantal holes op een oppervlak in de dialog te krijgen.

Aanwezige Programma Code De aanwezige programma code is in te delen in de volgende procedures: • Private Sub ExitBtn_Click() Stopt het programma wanneer op de exit button wordt gedrukt. • Private Function GetFaceHoleCount(Face As Object) As Integer In deze procedure worden alle loops in het geselecteerde face doorlopen en gecontroleerd op holes. Het tellen van de holes gebeurt in Private Function CheckLoopForHoles(swLoop As Object) As Integer. Het aantal holes per loop wordt bij het totaal aantal loops van het oppervlak opgeteld. • Private Function CheckLoopForHoles(swLoop As Object) As Integer Deze functie telt het aantal holes in een loop. • Private Sub UpdateBtn_Click() De code die hier staat wordt gerund wanneer op de Update knop wordt geclickt. Het beoogde doel van deze private sub, is de tekst in de dialog HoleCountTxt.Text de correcte waarde te geven. Daarvoor worden de twee bovenstaande procedures gebruikt.

Private Sub ExitBtn_Click() Private Sub ExitBtn_Click() Unload Me End Sub

Private Function GetFaceHoleCount(Face As Object) As Integer & Private Function Private Function GetFaceHoleCount(Face As Object) As Integer End Function

CheckLoopForHoles(swLoop As Object) As Integer Private Function CheckLoopForHoles(swLoop As Object) As Integer

29-2


End Function

Private Sub UpdateBtn_Click() Private Sub UpdateBtn_Click() Dim swApp As Object Dim Part As Object Dim DocType As Integer Set swApp = CreateObject("SldWorks.Application") ' attach to SolidWorks Set Part = swApp.ActiveDoc ' get the PartDoc for the current Part swApp.Visible = True


If Part Is Nothing Then ' no part loaded into SolidWorks swApp.SendMsgToUser ("No Part loaded") Exit Sub End If If Part.GetType <> swDocPART Then swApp.SendMsgToUser ("The current document is not a part") Exit Sub End If ' TODO - add your code here to get the selection manager ' and retrieve the selected face from it. You then ' need to write code to do the following: ' 1) traverse the loops on the face ' 2) for each loop, if not an outer loop, get the edges ' 3) for each edge, get the curve ' 4) if the curve is a circle then ' 5) get the curve params and check if the start ' x,y,z is the same as the finish x,y,z. If it is then ' the edge represents a hole End Sub

29-3


Aanvulling Programma Code In deze paragraaf wordt de programma code uitgelegd die het programma tot een werkend geheel maakt. Het is de bedoeling dat de code wordt overgenomen en dat het op de daarvoor bestemde plaats in het programma wordt gezet.

Private Sub UpdateBtn_Click() De aanwezige code wordt eerst herhaald. Er worden twee variabelen toegevoegd. Private Sub UpdateBtn_Click() Dim swApp As Object Dim Part As Object Dim DocType As Integer Dim SelMgr As Object Dim SelObj As Object Set swApp = CreateObject("SldWorks.Application") Set Part = swApp.ActiveDoc swApp.Visible = True If Part Is Nothing Then swApp.SendMsgToUser ("No Part loaded") Exit Sub End If If Part.GetType <> swDocPART Then swApp.SendMsgToUser ("The current document is not a part") Exit Sub End If

Hierachter komt de volgende code. De eerste stap na het ophalen van de user-selectie, is de controlere of er een face is geselecteerd. Wanneer daaraan is voldaan, wordt van SelObj het aantal holes geteld met behulp van de functie GetFaceHoleCount. Wordt niet de voorwaarden voldaan, dan komt er een waarschuwing op het scherm. Set SelMgr = Part.SelectionManager If (SelMgr.GetSelectedObjectCount <> 0) Then Set SelObj = SelMgr.GetSelectedObject2(1) If (SelMgr.GetSelectedObjectType(1) = swSelFACES) Then ' If selected object is a face HoleCountTxt.Text = CStr(GetFaceHoleCount(SelObj)) Else ' If selected object was not a face swApp.SendMsgToUser ("Please Select a Face for this operation.") End If End If End Sub

Private Function GetFaceHoleCount(Face As Object) As Integer Op een face kunnen zich meerdere loops bevinden. Van al deze loops moet het aantal holes worden bepaald. Met Face.GetFirstLoop wordt swloop gelijkgesteld aan de eerste loop. Aan het eind van de While lus wordt swloop, met behulp van swLoop.Getnext gelijkgesteld aan de volgende loop op de face. Het If-statement is bedoeld om outerloops niet mee te nemen in de telling voor het aantal holes. Wanneer ook aan de eis van het If Statement is voldaan, kan het totaal aantal holes op de face worden verhoogd met het aantal holes in de loop. De functie CheckLoopForHoles(swLoop) retourneert het aantal holes in de loop als integer. Private Function GetFaceHoleCount(Face As Object) As Integer

29-4


Dim swLoop As Object GetFaceHoleCount = 0 Set swLoop = Face.GetFirstLoop

' get the first loop

While Not swLoop Is Nothing ' while the loop is valid If Not swLoop.IsOuter Then ' ignore outer loops GetFaceHoleCount = GetFaceHoleCount + CheckLoopForHoles(swLoop) End If Set swLoop = swLoop.GetNext ' move onto the next loop Wend End Function

Private Function CheckLoopForHoles(swLoop As Object) As Integer Het begin is zo duidelijk dat het geen verdere uitleg behoeft. Private Function CheckLoopForHoles(swLoop As Object) As Integer Dim Edge As Object Dim Edges As Variant Dim Curve As Object Dim CurveParams As Variant Dim i As Integer CheckLoopForHoles = 0 Edges = swLoop.GetEdges If VarType(Edges) = vbNull Then Exit Function End If

Een loop bestaat uit een aantal edges. Deze edges kunnen van een verschillend Curvetype zijn. Voor iedere edge moet worden onderzocht of het Curvetype een circle is, want dat is het gezochte type. Wanneer een edge een circle is, dan en slecht dan is het een hole wanneer het begin en endpoint dezelfde waarden hebben. Het commando EdgeGetParams heeft de volgende retour waarden: [StartPtX, StartPtY, StartPtZ, EndPtX, EndPtY, EndPtZ, StartUParam, EndUParam, PackDouble1, PackDouble2]

Dus parameters 0 en 3, 1 en 4, 2 en 5 moeten dezelfde waarde hebben. Indien dit het geval is dan kan gesproken worden over een hole en moet de waarde van CheckLoopForHoles verhoogd worden met 1 For i = 0 To swLoop.GetEdgeCount - 1 Set Edge = Edges(i) Set Curve = Edge.GetCurve If Curve.IsCircle Then CurveParams = Edge.GetCurveParams If CurveParams(0) = CurveParams(3) And _ CurveParams(1) = CurveParams(4) And _ CurveParams(2) = CurveParams(5) Then CheckLoopForHoles = CheckLoopForHoles + 1 End If End If Next i End Function

29-5


Test het Programma Test je programma bijvoorbeeld op dit onderdeel (met slechts 3 cilindrische gaten). Hier is het voorvlak geselecteerd.

29-6

Hoofdstuk 30

Applicatie integratie

Wanneer een werkende applicatie is geschreven in Visual Basic, dan is het wenselijk dat deze applicatie gestart kan worden, zonder dat Visual Basic zelf actief moet zijn. Dit kan gedaan worden met zogenaamde Executables. In dit hoofdstuk komen de volgende onderwerpen aan de orde:

Aanmaken van Visual Basic Executables, Aanpassen van SolidWorks Menu’s.

U leert de laatste stap in het ontwikkelen van een API applicatie, het creëren van een executable. Hiermee wordt de geschreven applicatie geïntegreerd met SolidWorks, omdat de applicatie dan direct via de menu hierarchy kan worden gerund.

30-1

Hoofdstuk 30, Applicatie integratie

30-2

Appendices

Appendix A

Visual Basic Syntax

Variable types Data Type Boolean Byte Currency (scaled integer)

Storage 2 bytes 1 byte 8 bytes

Double (double-precision floatingpoint)

8 bytes

Integer Long (long integer) Single (single-precision floatingpoint)

2 bytes 4 bytes 4 bytes

String (variable-length) String (fixed-length) Date Object Variant (with numbers)

10 bytes + string length Length of string 8 bytes 4 bytes 16 bytes

Variant (with characters)

22 bytes + string length Can reference any datatype Number of required elements

User defined (using type)

Range True or False 0 to 255 – 922,337,203,685,477.5808 to 922,337,203,685,477.5807 -1.79769313486232E308 to – 4.94065645841247E-324 for negative values; 4.94065645841247E-324 to 1.79769313486232E308 for positive values – 32,768 to 32,767 – 2,147,483,648 to 2, l 47,483,647 – 3.402823E38 to – 1.401298E-45 for negative values; 1.401298E-45 to 3.402823E38 for positive values 0 to approximately 2 billion characters 1 to approximately 65,400 characters January 1, 100 to December 31, 9999 Any Object reference Any numeric value up to the range of a Double Same range as for variable-length String User-defined (using Type) Number required by elements The range of each element is the same as the range of its data type.

Variable declaration Syntax: Dim variable_name variable_type Example: Dim count As Integer Dim myString As String Dim myCountArray(10) As Integer

A-1

Appendix A, Visual Basic Syntax

Math Operators Operator + * / \ ^ MOD

Name Addition Subtraction Multiplication Division div

Exponentiation Modulus

Does Sum values Subtract values Multiply values Divide values Integer division Raise a value to a power Determine the remainder of a division

Mathematical Order of Operations Order 1 2 3

Operator ^ * / \ MOD +-

Name Exponentiation Multiply, divide and modulus Addition and subtraction

Relational Operators Operator = <> < >= <=

Meaning Example Equals 3 = (4-1), “basic” = basic” Not equal 5 <> 10 Less then Greater than Less than or equal

Logical Operators Operator And Not Or Xor

A-2

Meaning True if both expressions are true Not true if expression is true True if one of the expressions is true True if both expressions are true or if both are false

Appendix A, Visual Basic Syntax

Command Syntax [ ] Indicate optional components Command If condition Then statement

Description If condition evaluates to true, the statement is executed.

If condition Then [statement block] End If

If condition evaluates to true, the statement block is executed.

If condition1 Then [statement block1] [ElseIf condition2 Then [statement block2] Else [statement block3] End If

If condition1 evaluates to true, the statement block1 is executed. If condition2 evaluates to true, the statement block2 is executed.

Select Case testexpression [Case expressionlist1 [statement block1]] [Case expressionlist2 [statement block2]] [Case Else [statement block3]] End Select

The result of the evaluation of testexpression is tested against each Case clause. If a Clause matches, the statement block is executed.

If all conditions fail, block 3 is executed.

. If all Cases fail, the Else block is executed. .

Do While condition [statement block] Loop

The While Loop executes the statement block, as long as condition is true.

Do

The Loop Until executes the statement block, until the condition is true. The statement block is always executed once.

[statement block] Loop Until condition For counter = start To end [statement block] Loop

The statement block is executed a fixed number of times, depending on the start and end values.

A-3

CAM handleiding SolidWorks deel IV

Recommend Documents