Het einde van het schooljaar nadert met rasse schreden. Ik zit nu in het 5 de jaar industri?le wetenschappen. Dat wil zeggen dat, indien alles goed gaat, ik volgend jaar in het 6 de jaar industri?le wetenschappen (IW) zit.
In het zesde jaar TSO, BSO en KSO moeten alle leerlingen een GeIntegreerde Proef (GIP) afleggen. Dat is een eindwerk waarin alle aspecten van je richting aan bod komen. Je GIP is een belangrijk deel van je eindexamen van het middelbaar onderwijs.
In Elektromechanica, een richting die sterk verwant is aan Industri?le Wetenschappen, maar meer praktischer gericht dan IW, moeten de leerlingen zowel iets theoretisch bestuderen, maar ook een praktisch gedeelte kunnen voorleggen. Dat kan een sorteermachine zijn waarvan zowel de werking elektrisch, als mechanisch bestudeert wordt, om daarna de machine te bouwen.
In Industri?le wetenschappen is het praktische aspect niet verplicht, maar wel toegelaten.
Omdat de technische leerkracten vroegen om al eens aan 'volgend jaar' te denken, heb ik een lijstje gemaakt met mogelijk te bestuderen onderwerpen. Daaruit heb ik uitendelijk het automatische schaduwstation zonder wissels gekozen, omdat dat onderwerp het meest veelzijdige is, en ook aansluit bij mijn hobby. Ik heb ondertussen al toestemming om dit als onderwerp te nemen. Een volgende stap is dus brainstormen.
http://www.youtube.com/watch?v=dxRJ9rdyX4c (http://www.youtube.com/watch?v=dxRJ9rdyX4c)
Het grootste probleem waar ik nu tegen aanloop is de aansturing van de treinen op de fiddleyard. Ik rij digitaal met multimaus. Eenmaal de trein op de fiddleyard is aangekomen, moet die automatisch door het systeem naar een leeg spoor begeleid worden. Dat kan op meerdere manieren. Van de gemakkelijkheidshalve oplossing tot uitdaging?:
Analoog? De sturing kan elk spoor van een analoge spanning voorzien en de trein op tijd op het lege spoor stilzetten. Met behulp van knoppen (een per spoor) kan de trein van het desbetreffende spoor weer de yard verlaten en zet zijn reis voort over het digitale baanvak. Dit is de gemakkelijkste oplossing, maar er zit weinig uitdaging aan. Mijn vraag aan deze methode mag je met je trein zomaar van de yard (DC) naar de baan rijden (DCC)? Dat zal vonken geven zeker?
De sturing acteert als vertaler:De sturing kan elk spoor van een analoge spanning voorzien en de trein op tijd op het lege spoor stilzetten. De trein moet de yard verlaten van zodra de snelheid van de loc verandert wordt met de maus. De sturing werkt dus als vertaler van digitaal naar analoog. De sturing moet dus de adressen van de locomotieven kennen (uitlezen op het toegansspoor tot de yard terwijl die zich verplaatst naar een vrij spoor) . (is het protocol van Railcom vrij, er bestaan wel modules die het adres op een display kunnen weergeven, maar daar ben ik weinig mee. Ik moet die informatie kunnen verwerken.
Ook hier is mijn vraag mag je met je trein zomaar van de yard (DC) naar de baan rijden (DCC)? Dat zal vonken geven zeker? Moet hier geen samenwerking zijn tussen de sturing en de centrale?
De sturing is een DCC rijregelaar: Idem zoals hier boven, maar de treinen worden digitaal aangestuurd. Mag ik zomaar treinen de overgang laten maken tussen het multimaus dcc signaal en de sturing? Neen zeker? Moet er een communicatie zijn tussen de multimaus en de sturing? Waar kan ik duidelijke info vinden over DCC?
De sturing be?nvloedt de centrale zelf: De sturing stuurt op gepaste momenten signalen om de loc te doen vertragen, optrekken of stoppen. Alle sporen op de yard zijn rechtstreeks verbonden met de sporen op het baanvak. Is dit uberhaupt wel mogelijk? Hoe ga je voorkomen dat de loc's niet voortijdig de yard verlaten? Als je aan de regelaar draait dat ze niet te vroeg vertrekken? Terug grijpen naar de knoppen per spoor zoals bij de complete analoge bediening?
Andere? De leerkracht Mechanica vroeg of ik Visual Basic wou leren om het boeltje aan te sturen???
Ik weet het gelijk niet echt goed?
Rian,
Je komt in mijn 'vaarwater'. Jij wil weliswaar DCC en ik MM maar het principe is hetzelfde.
Misschien moet jij mij maar eens een rondleiding geven in Blankenberge en dan kunnen we misschien eens brainstormen? Deinze is ook leuk om eens een rondleiding te geven en het station is op 5 minuten te voet van mijn deur...
Je hebt nog 'een jaar' maar denk eraan dat een jaar 'kort' is [;)]
Als je dit wil verwezenlijken, sta je voor een grote enorme uitdaging...
Maar eerlijk gezegd vind ik wat het 'hooggegrepen' voor een eindwerk... Ik twijfel niet aan je capaciteiten en wil je niet ontmoedigen maar aan al het (ontwerp)werk...
Het idee is bij mij oktober 2011 komen aanzetten en nu heb ik nog steeds maar twee gelagerde schuifsystemen van 500mm... De rest zit 'ergens' in mijn achterhoofd... ...en zo ook de 'problemen'...
...
Investeer je tijd niet in VB waar je nadien tot de conclusie komt dat je 'beperkt' bent... Er zijn andere/betere talen [;)]
Al die stormen in mijn hoofd, niet echt gezond[:D]
Het ondertussen welbekende filmpje heeft mij ge?nspireerd om dat ooit eens te maken. Dan ben jij daarmee afgekomen, en dat gaf mij een impuls om ook te beginnen. Voor mijn gip dan dit gekozen...., ik besef zelf ook dat het een groot werk is. Ik heb dan ook enkele honderden uren gepland om daaraan te werken (uren gaan in vanaf 1/09/2012).
citaat:
Geplaatst door conducteur
...uren gaan in vanaf 1/09/2012)...
Ik denk dat je best nu al enkele 'uurtjes' begint te slijten...
Uitstellen... Niet doen!
Nu beginnen en zien of het haalbaar is... Indien niet heb je vanaf september nog tijd genoeg voor een alternatief!
Pa heeft geproken [;)][;)][;)]
Uitstellen doen we zeker niet, maar heb niet echt een strak plan opgesteld tot begin september. Voorlopig gaat het maar om brainstormen brainhurricanes enzo...[:)]
Rian,
Mijn deur staat open (via PM dan). Meer kan ik je niet aanbieden...
Een simpele rekensom:
Je trekt 500 uren uit voor dit project en werkt er 2 uren per dag aan (!) is 250 dagen. Je wil af en toe toch eens met vrienden/vriendinnen op stap en dan werk je nog 5 dagen per week. Kom ik toch aan zo'n 12 maanden...
Rian het zou moedig zijn moest je eraan beginnen.
Maar bezint heel goed voor ge begint !
Het kan snel klaar zijn, maar het risico dat het faalt is enorm groot.
Ik weet niet wat uw kunnen is, maar ooit maakte ik ook een eindwerk.
Ik zie dit project meer iets voor de ingenieurs richting en niet geschikt voor een secundair niveau.
Moest je verder studeren voor ingenieur dan zou ik zeker dit project nemen.
Soit ik volg met belangstelling uw idee?n.
Moesten we kunnen helpen dan doen we dat uiteraard graag he Rian.
Het grootste probleem lijkt mij de mechanische constructie.
Het aansturing van het geheel is volgens mij niet zo een groot probleem.
Met een oudere computer waar nog isa printen in passen,of met een kleine moderner industrie computer ook met isa printen is al veel te beginnen.
Zelfs zonder extra printen kan een computer met printer uitgang (geen usb)al veel helpen.
Een computer taal die voor dit doel nog perfect werkt is quick basic.
Toegegeven niet meer echt fris maar uitstekend geschikt (veel beter dan de moderner talen)en simpel te leren .
Groot voordeel is dat je niet telkens een exe file moet maken maar gewoon elk idee even kunt testen (run en het werkt,of niet natuurlijk)
Is het eenmaal goed dan kun je als nog een exe file maken.
Snelheid is in jou geval geen enkel probleem.
Bedenk dat wij nu wel allemaal op elke straathoek mobiel staan te bellen maar dat gewoon bellen thuis met en telefoon uit 1980 ook nog prima werkt.
MENING GEEN ABSOLUTE WAARHEID
Soms heb ik het idee dat de huidige moderner computer talen uitsluitend (of bijna)zijn uitgevonden of bedacht om het IT vak te beschermen.
Want als het simpel kan ,dan kan iedereen het,en is het afgelopen met veel verdienen in de IT.
Ik praat dus niet over simulatie programmas ,foto en film bewerking,supersnel rekenwerk e.d.
Nee gewoon het eenvoudiger besturings werk.
Oke.
maak eerst de mechanica zou ik zeggen besturen(zelfs analoog lijkt mij best mee te vallen)
succes
wim
Hoe ga je de aankomende locomotieven hun adres uitlezen op het toegangsspoor? Dit is al een uitdaging op zich?
Een mogelijke denkpiste is de volgende:
-je stuurt digitaal je lok naar het toegansspoor en je stopt zelf daar deze lok.
-een ?C leest mee het DCC signaal en weet nu ook welk het adres is van de lok, nl. deze die net gestopt is op het toegangsspoor. Dit houd in dat je moet detecteren dat er een lok op het toegangsspoor staat (bv. lichtsluis, stroomdetectie enz?)
-nu neemt de ?C met een ??nvoudige zelfbouwbooster het zaakje over. Het toegangsspoor wordt gescheiden van de rest. De ?C stuurt de lok via DCC verder naar de fiddleyard die al klaar staat met een vrij spoor.
-Een lichtsluis detecteert de positie van de lok op de fiddleyard zodat de ?C de lok laat stoppen. Je hebt maar ??n lichtsluis nodig voor alle opstelsporen! Immers deze staat altijd vast op het spoor waar de lok oprijd. Het beste kan je een sterke lichtbron boven dit spoor plaatsen. In het midden tussen de sporen boor je een gaatje. Onder de fiddleyard plaats je een vaste lichtdetector, dit kan van alles zijn een LDR, fototransistor enz?
-Als je nu met je multimaus een lok aanstuurt die in op de fiddleyard staat, dan schiet de ?C weer in actie. De ?C weet dat deze lok op de fiddleyard staat en stuurt de fiddleyard aan zodat de geselecteerde lok eraf kan rijden. De ?C stuurt zelf weer een DCC signaal naar de lok totdat deze op een uitrijspoor terecht komt het DCC signaal komt overeen met deze van de multimaus (snelheid, functies enz?).
-Op het moment dat de volledige trein op het uitrijspoor rijd, dan komt het signaal van de multimaus op de sporen te staan. Dat schakelen kan het best met een relais met wisselcontacten.
Dit houd in dat je wel moet verdiepen in DCC, dit is niet moeilijk en zelfs zeer interessant om weten.
Een ?C aanleren is al iets moeilijker, maar we zijn er om te helpen nietwaar. Dit kan in assembler maar ook in een hogere taal C of JAL.
Een booster zelf maken is ook helemaal niet moeilijk. In de manual van MR-direct staat er ??ntje in die eenvoudig zelf te bouwen is. Ik heb dat ook gedaan en werkt perfect.
Het elektromechanische deel van de fiddleyard is weer een ander verhaal. Probeer niet het inrijspoor en het uitrijspoor op ??n lijn te krijgen zodat de lok als het ware kan passeren via de fiddleyard. Door mechanische speling lukt dat nooit. De positie van de fiddleyard t.o.v . inrijspoor en uitrijspoor moeten afzonderlijk geregeld worden. Ook daar heb ik idee?n over, maar verwerk eerst deze info al.
Geert
citaat:
Geplaatst door Geert
...Probeer niet het inrijspoor en het uitrijspoor op ??n lijn te krijgen zodat de lok als het ware kan passeren via de fiddleyard. Door mechanische speling lukt dat nooit. De positie van de fiddleyard t.o.v . inrijspoor en uitrijspoor moeten afzonderlijk geregeld worden...
Ik denk net dat wanneer er voldoende speling op de tafel zit dit wel zou lukken door langs beide kanten de tafel te vergrendelen met centreerstiften. Voor je je sporen legt, positioneer je de tafel, vergrendel ze met (automatische - via een servo?) centreerstiften en leg dan de rails. Ook de positionering steekt hem dan niet zou nauw...
Die servo die de centrering voor zich neemt, kan ook dienen om een brugje op en neer te laten om de zijkant van de tafel vrij te hebben tijdens het verplaatsen van die tafel.
Ik heb dat filmke met die brug ook al eens gezien.
De methode die ik voorstel is de fiddleyard via een bocht te benaderen- te verlaten. Het begin van de bocht stel je vast op, maar enigszins scharnierend (we spreken hier over een verplaatsing, in hoek, van enkel tienden van een graad) Het uiteinde van de bocht kan nu naar alle kanten bewegen op/neer, links/rechts, en van voor/naar achter, en dit over enkele mm.
Nu bevestig je op de kop van de fiddleyard horizontaal een U-profiel in staal. E?n been schroef je tegen de fiddleyard, de ander staat vrij omhoog. Deze moet perfect uitgelijnd staan met de hoogte van je sporen. Voor degene die ooit met mekano hebben gespeeld weten dat er van die wieltjes zijn met een groef rondom. Zulke twee wieltjes met hun groef bollen over de vrijstaande been van het U-profiel. De assen van deze wieltjes staan vast in verbinding met het uiteinde van de bocht.
Wat hebben we nu al bereikt: de hoogte van het inrijspoor staat altijd even hoog ten opzichte van de sporen van de fiddleyard. De afstand is ook altijd even ver t.o.v. de sporen van de fiddleyard. Enkel de positie is nog niet uitgelijnd.
Nu zijn er van die optocouplers in de vorm van een U. Tussen die U is er vrije ruimte die mee over het U-profiel geplaats wordt. Nu boor je een klein gaatje in de U-profiel daar waar de aandrijving van de fiddleyard moet stoppen. De optocoupler detecteert dit gaatje.
Nu zet je er ook een elektromagneet bij die je aanstuurt als de fiddleyard uitgelijnd is. Deze magneet zet zichzelf en heel het uiteinde van de bocht vast op het stalen U-profiel.
Ik denk dat een tekeningske veel duidelijk maakt, maar ik kan dit nu niet waar ik mij nu bevind?
Hetzelfde verhaal voor het uitrijspoor.
Geert
Boor in twee metalen strips even veel gaten als er sporen zijn.
strips op zijkant beweegbaar deel
Zet op de vaste wal twee servos met puntvormige stift.
een op uitrij en een op de inrijkant.
Servo in de midden van de heen en weer afstand.(rechts = links)
draai de pin in de gaten.
Leg middelste rail op beweegbaar deel.
zet stiften in volgende gaten.
monteer de rail die er bij hoort
Enz tot al rail ligt.
onnauwkeurig geboord is nu geen probleem
Idee naar ideeen van vorige schrijvers en wat eigen stuff
wim
Dat achteraf uitlijnen voor dat gaatje kan je doen met een stalen hoekprofieltje. E?n deel dat net tussen de sporen past. Het ander deel dat omlaag tegen de metalen strip geduwd wordt. In dit deel is in het midden al een gaatje geboord dat als mal dient om een gaatje te boren in de strip.
Geert
Leuk project, waar inderdaad veel technieken bij komen kijken.
Ik zou je aanraden om de verschillende aspecten op te splitsen:
- mechanische constructie: stabiel, zo min mogelijk wrijving, ...
- aandrijving en positionering: (ketting-)tandwielen, (stappen-)motor, ...
- meten en vergrendelen van positie: lichtsluizen, electromagnetische pennen, ...
- veiligheid: stopsecties, noodprocedures, ...
- automatisering: leeg-vak-detectie, FIFO, ...
Hier staan interessante dingen tussen. Waar kan ik duidelijke info vinden ivm dcc? Geert zijn idee spreekt mij wel aan...
oa http://nl.wikipedia.org/wiki/Digital_Command_Control
http://en.wikipedia.org/wiki/Digital_Command_Control
DCC is opgebouwd volgens een standaard van NMRA, het spreekt vanzelf dat je daar veel info terugvind http://www.nmra.org/
Geert
citaat:
Geplaatst door Geert
DCC is opgebouwd volgens een standaard van NMRA, het spreekt vanzelf dat je daar veel info terugvind http://www.nmra.org/
Geert
Net andersom NMRA heeft DCC (van lenz)als standaard gekozen.
wim
Klopt Wim,
ik ga hier wel geen les in geschiedenis geven h?. NMRA beheert nu dit protocol en heeft daar al tal van uitbreidingen aan toegevoegd.
Geert
Ik heb dit project eens rustig laten bezinken en er nu nog eens goed over nagedacht Rian. Je begint wel aan een enorme uitdaging hoor. Ik schuif dit voor mezelf al enkel jaren voor mij uit omdat er zoveel bij komt kijken. En ik kan al ?C programmeren, ik ken iets van trein protocollen en motoraansturingen. Beroepsmatig zit ik in de meet- regel en automatisatie wereldje en weet dus waar ik het over heb...
Ik ken je capaciteiten natuurlijk niet, maar je zal heel veel tijd nodig hebben om dit tot een goed einde te brengen. Mogelijk toch verder zoeken naar een iets eenvoudigere methode?
Maar ik wil je graag helpen hoor, zo help ik mezelf ook verder en komt er eindelijk iets van mijn fiddleyard[;)]
Geert
Waarschijnlijk dom van mij maar waar zit nu het probleem.
Volgens mij voor 80% in de mechanica,het precies vlak laten schuiven van zo groot vlak ,zonder wringen e.d,is geen simpele zaak.
Electronische problemmen zijn er natuurlijk wel zeker als je alles met microcomputers en techniek uit 2020 wil gaan maken.
Gaat er echter om dat de zaak betrouwbaar werkt en grijp je terug op bestaande of zelfs wat bejaarde principes dan valt het best mee.
Als je absoluut wil weten welk adres op welk spoor staat zul je decoders moeten gebruiken die uitleesbaar zijn.
Zo niet dan is echte kennis van DCC niet nodig.stoppen en starten zijn simpel aan een computer op te dragen (serieel interface).
Over het laten schuiven (electrisch)en het stoppen,vergrendelen,spanning op het spoor enz.enz zou ik me niet druk maken en zeker niet het wiel opnieuw uitvinden.
De bestaande techniek is mooi genoeg.
Goed heren waar zie ik het fout,vertel het mij.
wim
Ik denk dat er op school al ingewikkeldere gips zijn gemaakt, in de afgelopen jaren. Toch ben ik er mij van bewust dat dit daarom g??n makkelijk onderwerp is.
Ik denk ook dat die plaat mooi recht laten bewegen, de moeilijkste opgave zal zijn. De sturing zelf kan ik zo ingewikkeld maken als ik dat wil, daar kan je namelijk kiezen tussen de boel digitaal aansturen, of analoog.
Programmeren hebben we al gedaan in flowcode vorig jaar, volgend jaar komt daar c bij.
Bewegen van de plaat : ga te rade bij een keukenbouwer. Zij gebruiken "schuifgeleiders" op kogellagers : zeer lichtlopend, heel nauwkeurig en vrij goedkoop. Te koop in bvb Brico...
Erik
Gebruik voor de aandrijving een draadstang-stappenmotor combinatie : zeer sterk, nauwkeurig en zelf-remmend (geen gekl.... met pinnen en gaten).
(http://img585.imageshack.us/img585/2097/lineaireaandrijvingklei.jpg)
Erik en Mark
citaat:
Geplaatst door eve
Gebruik voor de aandrijving een draadstang-stappenmotor combinatie : zeer sterk, nauwkeurig en zelf-remmend (geen gekl.... met pinnen en gaten).
(http://img585.imageshack.us/img585/2097/lineaireaandrijvingklei.jpg)
Erik en Mark
Prijs [:(!][:(!][:(!][:(!][:(!][:(!][:(!][:(!][:(!][:(!][:(!][:(!][:(!]
wim
citaat:
Geplaatst door eve
Gebruik voor de aandrijving een draadstang-stappenmotor combinatie : zeer sterk, nauwkeurig en zelf-remmend (geen gekl.... met pinnen en gaten).
Of ineens de tafel van een CNC freesmachine; alles direct ingebouwd en heel nauwkeurig [:p]...
Juist die nauwkeurigheid bij zelfbouw is een struikelblok. De tafel gaat toch wel redelijke afmetingen hebben (bij mij zou die 1200 * 500 mm zijn) en wordt uit 'minderwaardig' materiaal gebouwd (hout + alu?) dat leeft en trekt. Met een stappenmotor/draadstang/IR combinatie moet je in alle gevallen juist kunnen positioneren (een paar tienden uitlijningsverschillen in je rails en ...).
Juist daarom zou ik opteren voor een aandrijving met wat 'rek' (aandrijving eventueel met visdraad) en sterke centreer/vergrendelingspinnen die de rails altijd juist uitlijnen en volgens mij is dat veel minder gekl.. dan stappenmotoren/draadstangen/sturing [}:)].
Een poging om eens op papier te zetten wat ik voor dergelijk project reeds (in mijn achterhoofd) heb uitgedacht...
Tafel met rek (zie hierboven) geleidingen met kogellagers voor schuiven (inderdaad Brico - niet zo goedkoop) 500mm lang. Vier voorzien voor 1200mm tafellengte. Exact parallel uitlijnen (mogelijk al een struikelblok)... E?n centrale aandrijving van de tafel met al dan niet een stappenmotor (of andere traagloper met vermogen). Positionering via IR en opgekleefde strook voorzien van een Gray-code. Volledig die sturing door een PIC die via I2C zijn 'opdrachten' krijgt. Tafel vergrendelen en uitlijnen met centreerstiften via een (sterke) servo. Servo dient ook om de toegangsbruggen op en neer te laten om de tafel vrij te laten lopen.
Een 'sniffer' die de lokcommando's (en ook wisselcommando's) op de baan 'snift' en bijhoudt welke lok met welke functies actief is op de baan. Bij het 'sniffen' van een wisselcommando om de virtuele wisselstraat die de tafel eigenlijk is, aan te sturen, geeft die via I2C opdracht aan de 'tafeldraaier' om in actie te schieten. De 'sniffer' houdt ook een stuk rail in de gaten (toegang tot de tafel). Wanneer daar een lok op komt (massadetectie in mijn geval), schakelt hij dat stuk los van de rest van de baan en doet een greep naar de macht door de loks die als actief in zijn geheugen zitten ??n voor ??n te proberen. Komt de lok in beweging (stroomdetectie) heeft hij het juiste adres en verplaatst hij hem naar het klaargelegen spoor. Via terugmelders wordt aan de besturingssoft (Koploper) gemeld dat de lok op zijn plaats staat. De besturingssoft zet de snelheid op 0 (op de rest van de baan). De sniffer ziet dit en kan de lok uit zijn lijst wissen. In een andere lijst houdt hij wel bij dat hij nu over die lok beschikt op dat spoor.
De 'sniffer' ziet dat de besturingssoft ??n van zijn loks terug wil laten rijden. De 'tafeldraaier' krijgt de opdracht om de tafel juist te zetten en de sniffer zet al de functies van de lok aan (die aan stonden voor hij die lok 'over nam') en laat die vertrekken. Via een sleperwig of een ge?soleerd stuk komt de lok terug op de werkelijke baan.
Met die 'sniffer' ben ik daadwerkelijk al begonnen (PIC 16F88 - 8MHz - programma in JAL) en ik kan reeds alle loks en hun functies bijhouden. Ook de 10 (virtuele) wisseladressen kan ik al filteren. De code zal ik eens op mijn JAL pagina zetten.
Voila mijn idee in een notedop...
ik zou voorkeur geven aan stappenmotor, draadstang...
En dat hoeft niet duur te zijn. Stappenmotoren vind je vlug tweedehands. Ook hoeft de tafel niet spelingvrij te bewegen maar hoeft ze enkel "in te klikken" op de juiste posities. Ook daar zijn goedkope oplossingen voor te vinden...
ik volg het hier wel Rian en grijp in waar ik denk te kunnen helpen...
citaat:
Geplaatst door PeterC
de loks die als actief in zijn geheugen zitten ??n voor ??n te proberen. Komt de lok in beweging (stroomdetectie) heeft hij het juiste adres en verplaatst hij hem naar het klaargelegen spoor.
Voila mijn idee in een notedop...
Samen met mijn zoon die digitaal rijdt dit uit geprobeerd
Snel een rij van adressen geven ,en wachten of een lok reageert.
Leuk idee,maar het werkt in de praktijk niet met stroomdetectie.
Zeker niet als er ook wagens met verlichting op de baan staan (praktijk).
Dat was de rede om voortijdig te stoppen.
Maar zelfs met alleen de lok met de lichten uit neem de decoder nog stroom (uiteraard)niet veel maar te onbetrouwbaar om een goede melding te maken.
Daarna geprobeerd om na elk adres de lampjes te laten knipperen.
Dat werkt maar het vraagt wel op elk spoor een fotocel om dat knipperen op te vangen.
Detectie (stroom) lampen aan lampen uit geeft ondanks het vrij grote stroom verschil geen echt betrouwbaar signaal.
De proef daarna gestopt,wellicht gaat het dus toch wel maar .........
wim
Wim, ik zou niet weten waarom het niet zou werken; je moet het wel wat doordacht aanpakken en dan heb je geen last van decoderstromen en lampen en andere verbruikers:
Zet in je aansluitdraad een kleine weerstand en daarop een preciciegelijkrichter (door de weerstand gaat wisselstroom). Bij een stilstaande lok ga je nu spanning meten over die weerstand (door de eventuele verbruikers), elke lok/sleep een andere spanning. Die spanning die je meet is je referentiewaarde. Begin nu de adressen te doorlopen en meet een spanningsstijging (eventueel alleen maar door de verlichting aan te steken). Bij een spanningsstijging heb je de lok 'gevonden'. De controller die ik gebruik heeft een ADC met een resolutie van 10 bits. Met wat foefelen kan je stroomstijgingen van 1mA meten. Geen probleem toch?
Ik wens je veel succes.
Maar ik zie het niet zitten(na mijn ervaring)maar ja wie ben ik[:I][:I]
wim
citaat:
Geplaatst door ysbeer
citaat:
Geplaatst door eve
Gebruik voor de aandrijving een draadstang-stappenmotor combinatie : zeer sterk, nauwkeurig en zelf-remmend (geen gekl.... met pinnen en gaten).
(http://img585.imageshack.us/img585/2097/lineaireaandrijvingklei.jpg)
Erik en Mark
Prijs [:(!][:(!][:(!][:(!][:(!][:(!][:(!][:(!][:(!][:(!][:(!][:(!][:(!]
wim
Aan het intikken van [:(!] zal het niet liggen...
Ik vind bij Conrad (niet bepaald de goedkoopste) 5 motoren van ca. 50? en minder.
Motiveer tenminste "Prijs"...
Erik en Mark
citaat:
Geplaatst door PeterC
citaat:
Geplaatst door eve
Gebruik voor de aandrijving een draadstang-stappenmotor combinatie : zeer sterk, nauwkeurig en zelf-remmend (geen gekl.... met pinnen en gaten).
Of ineens de tafel van een CNC freesmachine; alles direct ingebouwd en heel nauwkeurig [:p]...
Juist die nauwkeurigheid bij zelfbouw is een struikelblok. De tafel gaat toch wel redelijke afmetingen hebben (bij mij zou die 1200 * 500 mm zijn) en wordt uit 'minderwaardig' materiaal gebouwd (hout + alu?) dat leeft en trekt. Met een stappenmotor/draadstang/IR combinatie moet je in alle gevallen juist kunnen positioneren (een paar tienden uitlijningsverschillen in je rails en ...).
Juist daarom zou ik opteren voor een aandrijving met wat 'rek' (aandrijving eventueel met visdraad) en sterke centreer/vergrendelingspinnen die de rails altijd juist uitlijnen en volgens mij is dat veel minder gekl.. dan stappenmotoren/draadstangen/sturing [}:)].
Wij gebruiken onze zelfbouw machine voor het frezen van koperprintjes. We halen een nauwkeurigheid en reproduceerbaarheid van 0,1 mm.
Erik en Mark
De lineaire beweging zal met een stappenmotor en trapeziumschroefdraad zijn. Dat is al zeker. Hoe de bevestiging zal zijn tussen moer en tafel is nog niet helemaal zeker.
De geleding wordt waarschijnlijk een ronde staaf uit blank getrokken staal. De plaat zal dan op drie punten rusten: de moer, en op twee blokken op de staaf staal. Die twee blokken uit PA omdat dat zelfsmerend is. Dat is toch wat we samen hebben gebrainstormd met de leerkracht. Ik betwijfel dat dat gaat werken, omdat de draadstang dan niet in het midden staat. Het gewicht van een volledige plaat vol met treinen mag zeker niet onderschat worden... (12 kg ong). Ik ben bang dat het zaakje gaat kromtrekken... Maandag nog eens vragen...
Twee schroefstangen gebruiken, en die via een ketting en drie tandwielen met ??n stappenmotor aandrijven [;)]
Nog eens MSM 78 p. 64 doorlezen?
Geen high-tech, wel werkend... [;)]
Dat is ook een oplossing... Ik dacht aan twee staven blank getrokken staal en een schroefdraadas.
Edit: MSM 78 heb ik ook al doorgenomen. Nogal veel gefoefel met dat relais. Ik denk wel dat het werkt, maar er zijn elegantere methode's om dat te bereiken. Toch zijn er enkele elementen die mogelijk bruikbaar zijn.
Zelf zou ik kiezen voor 2 geleiders in staal (minstens 16mm doormeter, indien mogelijk zilverstaal of stubstaal, die kan je zo in h6 of h7 vinden). Ofwel met nylon geleiders op de tafel, ofwel met blokjes met kogellagers als de wrijving te hoog is. Plaatsing van de geleiders om doorzakking te beperken.
Aandrijving met 2 stappers en draadstangen dichtbij de geleiders. Gewone draadstangen zullen wel ok zijn. Voor die moer ga je wel even werk hebben om er eentje spellingsvrij te maken. Maar daar bestaan truckjes voor. (je moet zelf ook nog iets doen [8D])
Sturing in open loop met 1 home positie. Bij het begin zoekt de controller voor de 2 stappers de home (het nulpunt). Je laat ze samen in de goeie richting gaan, als er 1 home komt stop je die en laat de andere naar home gaan. (error conditie trappen) Daarna open loop. Een M6 draadstang heeft een pas van 1mm, simpele steppers 200 posities. Dus positioneren op 0.1mm is mogelijk.
Als je sturing in closed loop wil moet je een rotary encoder op je as zetten en je controller de stappen laten tellen. Dan kan je "verloren" stappen recupereren. Een home positie ga je ook nodig hebben.
Vraag: ik weet niks van DCC of hoe je je besturing doet, maar is het wel nodig dat je schaduwstation het adres van de decoder kent? Zoals ik het zie stuurt je programma een loc naar een plaats op het schaduwstation. Dus je programma kent het locnummer en plaats. Als jij ervoor zorgt dat als je programma een plaats selecteert, dat die plaats correct geselecteerd wordt, dan is het toch genoeg? (want je programma weet welke loc daar staat)
Maw ik zie het mees als een vervanging van een wisselstraat dan een onafhankelijk item: je leest een wisselselectie die je dcc systeem doet in je controller en vertaalt dat naar de positionering van een spoor. Je bijkomend probleem is dat je niet tegelijk kan inrijden en uitrijden, dat ga je aan je dcc systeem moeten wijsmaken.
Er liggen al veel eieren van colombus op mijn tafel, hier nog een.
Het enige wat de trein op en voor de yard moet doen is stoppen en aanzetten. Zou dat niet te regelen zijn met een remgenerator? Er bestaan toch verschillende manieren? ABC,...
Als je er nu voor zorgt in het programma, dat de yard zich automatisch verplaatst naar een leeg spoor nadat er een trein op de yard is gereden, dan moeten we zelf niet stoppen voor de yard. Als beveiliging kunnen we ook met een relais de retourdraad van de sporen onderbreken zodat de treinen niet kunnen wegrijden. Een noodstop knop zou dat zelfde relais kunnen aansturen.
Rian, voorzie dan lange sporen of een Gottwaldkraan [;)]
[?]
citaat:
Geplaatst door conducteur
[?]
Rian, mij lijkt het toch veiliger om voor je tafel (of yard) een stopsectie te voorzien waar je sleep toch (eventueel) volledig tot stilstand kan komen (indien de 'brugdraaier' nog niet klaar is) en met terugmelders naar je besturingssoft.
Die Gottwaldkraan kan tussenkomen indien je 'remsectie' niet genoeg 'remt' en de tafel nog niet klaar staat [;)]
Je kan natuurlijk ook een bareel over de sporen zetten als de tafel nog niet klaarstaan.
Als ik het zo zie, dan denk ik dat de mechanica nog het minste probleem gaat zijn. Grootste probleem is het opvangen van alle mogelijke fouten en daar correct op reageren: zonder brokken!
Ik denk dat beide problemen (zowel mechanisch als besturingsmatig) niet te onderschatten zijn, vandaar dat het zo'n interessant onderwerp is.
Eve
Een werkelijk betrouwbare stappen motor met draadstang en electronica kost veel meer dan 50 Euro.
Kijk wat ik bedoel is als je de geld pot open zet is het geen kunst om
iets moois te maken.
Maar oke de reactie was wel kort door de bocht.
Wat ik niet begrijp is de grote angst voor nauwkeurigheid
Het enige wat goed moet zijn is de aansluiting aan beide zijde op het spoor.
Met punt stiften, een stevig electromagneet of motor is dat simpel te maken.
Of het hele bord tijdens het rijden nu wel precies recht loopt is onbelanrijk.
Zolang je hem niet al te scheef of vast trekt is het oke.
Krom trekken is te voorkomen door een metalen frame
links en rechts een ketting en plasic rijwielen moet kunnen.
ik zou nooit de positie laten bepalen door aantal stappen
Volgens mij onnodig duur en ingewikkeld,en minder betrouwbaar dan stiften. (een stift aan elke zijde)
Niet voor niets gebruikt men nu in 2012 nog steeds dit soort stiften bij treinbruggen en geen stappen motoren e.d
wim
Wim, oef, ik dacht dat ik de enige was die overtuigd was van zo'n systeem [;)]
Wel, een treinbrug in 1:1 is wel iets anders dan een schuiftafel met enkele modeltreinen.
Als ik zie dat die hobby CNC frezen ook in open loop draaien, over vergelijkbare lengtes en dan zonder problemen 0.1mm herhaalbaarheid halen denk ik niet dat dit in deze toepassing problemen gaat geven.
Zelf heb ik electronica voor een toestel gemaakt dat een veel hogere naukeurigheid moest halen en daar was dit ook geen probleem. Goed, het was maar 30cm maar de nauwkeurigheid was enkele hondersten.
Kosten vergelijken is moeilijk zonder beide systemen verder uit te werken. Maar een ik denk dat beide systemen niet ver uit elkaar liggen. Grofweg (ebay prijzen):
- stepper: 15 euro
- L293 driver: 5 euro
- 16mm stang tolerantie h6: 2 euro/10 cm
- draadstang M6: enkele euro in de brico
Ik denk dat diegenen die aan centreerpennen denken niet al de mogelijke problemen beschouwen die aan dat systeem vastzitten:
- Als je de onnauwkeurigheid van de tafel wil "rechttrekken" met pennen dat heb je behoorlijk wat kracht nodig.
- Ook hangt het dan af van het maken van die "lat met gaten". Die is enkel bruikbaar als elk gat perfect op positie staat in 2 dimensies, en de pen dan ook nog eens in de as van het spoor staat en haaks.
- Vermits de uitlijning enkel goed is als de pen er is, moet je dat nog eens detecteren. En als het wat wringt moet je ook nog eens detecteren of de pen er wel uit is voor je de tafel verzet.
- Dit langs beide kanten van de tafel.
- kost lijkt me niet veel lager: kettingen, tandwielen zijn niet goedkoop en een (stappen)motor met zijn sturing heb je ook nodig, evenals geleiders. De pennen komen er nog bij.
Ik beweer niet dat het ene nu simpelder/beter is dan het andere. Veel hangt af van wat voor materiaal beschikbaar is en of je je beter voelt in mechanica of sturen. Die beslissing moet conducteur maar maken, tenslotte is het zijn eindwerk en systemen vergelijken op voor- en nadelen maakt daar deel van uit.
Ergens gelezen hier : "...je haalt nooit die nauwkeurigheid...".
Even bekijken : De meeste motoren zijn 200 stappen voor een omwenteling in "full step mode" of 400 stappen per omwenteling in "half step mode".
Een draadstang van 6 mm diameter heeft een spoed van 1mm per omwenteling, dus een resolutie van 1/400 ste van een mm is teoretisch mogelijk.
Het is een kwestie om zo weinig mogelijk speling te hebben.
Erik en Mark
citaat:
Geplaatst door PeterC
Wim, oef, ik dacht dat ik de enige was die overtuigd was van zo'n systeem [;)]
Sory waarschijnlijk iemand zijn idee gejat.
Geen kwade bedoeling hoor.
wim
citaat:
Geplaatst door eve
Ergens gelezen hier : "...je haalt nooit die nauwkeurigheid...".
Het is een kwestie om zo weinig mogelijk speling te hebben.
Erik en Mark
Daar zit juist het probleem voor de amateur.
Iemand met een machine park van 5 ton en 20 jaar ervaring maakt het in een avond.
wim
citaat:
Iemand met een machine park van 5 ton en 20 jaar ervaring maakt het in een avond.
Speling wegwerken doe je met het hoofd. Veel meer dan een blok materiaal, zaag, vijl, boren en tappen hab je niet nodig. Als machine is een kolomboor van de Gamma voldoende.
Om het systeem met de pen te maken heb je minstens een frees nodig met een tafel langer dan de strip die je wil maken. Tenminste als je wil dat de positioneergaten +/- 0.1mm liggen. En het mechanisme met de pen is ook niet simpel, zeker als je de tafel wil rechtwringen. Een geleiding voor die pin is dan minstens enkele cm lang en geruimd.
Trouwens ik denk dat conducteur via de school de nodige machines beschikbaar heeft.
Op school machines genoeg, maar ben niet 100% zeker dat ik dingen kan (laten) doen.
Mijn metabo kgs254M (verstekzaag) kan alles zagen behalve staal. Ook kunststoffen en non-ferro metalen. Deze zomer komt daar nog een kolomboor/freesmachientje bij. Daarmee kom ik al een heel eind denk ik.
Je hebt helemaal geen machinepark van "5 ton" nodig...
Goed nadenken zoals Havoc schrijft. Speling elimineren moet je vooral doen daar waar de draadstang de schuivende tafel aandrijft...
Bestudeer dat eens.
Erik en Mark
De schroefdraadstang zal trapziumdraad zijn. Dat heeft weinig speling. Het idee van de leerkracht was om in de moer gaten te boren, waarin schroefdraad getapt wordt voor bevestiging met de tafel. Ik ben op zoek naar zgn blinde moeren, omdat dat volgens mij beter zal gaan. De schroefdraadstang zal op een of andere manier met lagers bevestigd worden. Dat laatste moet ook nog nader worden bestudeerd.
Rian, ik heb hier overschot staan van enkele afbraken van XY-tafels. Als je een basis-schets met afmetingen klaar hebt zie ik wel of ik iets kan invullen...
Dan nog volgende opmerking op enkele van de aanmerkingen hier:
Als je werk met ?ets" dat vergrendelt op de opeenvolgende posities moet je een beetje aan "Thinking out of the box" doen. De nauwkeurigheid waarvan hier sprake is hoeft helemaal niet (de lat met gaatjes waarvan sprake).
Op het bewegend tafelgedeelte wacht je gewoon van sporen leggen tot de positie-grendeltjes gemonteerd zijn en je lijnt je sporen uit op die posities. Het maakt helemaal niets uit als er sporen eens op 50mm van elkaar liggen en daarbaast op 51mm....
Die grendeltjes kunnen heel eenvoudige ouderwetse meubel deursluitertjes zijn (kogeltje met veer)... want, als je de sporen richt op de vergrendelde positie moeten ook die niet nauwkeurig zijn. Ze moeten gewoon steeds op dezelfde positie komen te staan...
Ik ben er alvast van overtuigd dat het "goedkoop" kan en toch feilloos loopt...
Ik ben het helemaal eens met de bedenkingen van Dirky.
Maar ik wil dat er nog stap verder gedacht wordt.
Stel dat je na de complete realisatie van het geheel TOCH een spoor iets moet opschuiven, of dat het zich onder invloed van "het is eender wat" toch verplaatst, dan is een stappenmotor-?C combinatie met enkele toetsenbord tikken veel en veel sneller en eenvoudiger in te stellen dan de pin-gat-combinatie...
Trouwens waarom op de hier platgetreden paden blijven? Is een automatische optische plaatsbepaling niet te overwegen cq. te realiseren ?
Erik
Ik denk ook dat optisch makkelijker zal zijn. Ik zie niet direct hoe je dat dan weer dat mechanische vergrendelsysteem laat loskomen. Een mechanische verbinding tussen de bewegende tafel en de rest van de treinbaan kan voor problemen zorgen... Als die er dus niet zijn is dat al een zorg minder.
Hoeft niet persee met een stappenmotor.
De draaibrug hier wordt bestuurt met een gewone elektromotor.
Op de as van het aandrijfwiel is een rondje gemonteert met gaatjes in. Hoe meer gaatjes des te nauwkeuriger u kan werken. Een IR sluis registreert hoeveel omwentelingen de as gedaan heeft. ?C telt de pulsen van de IR sluis en regelt gans de boel. makkelijk eigenlijk.
Voordeel is dat u geen stappenmotorsturing moet maken !
Het is makkelijk uit een oude muis met bal te halen zo een systeem.
Rian, vergrendelen hoeft niet, gewoon "positioneren". Positioneren kan d.m.v. veerkracht...
Voorbeeld: als je met de fiets traag op een rechte lijn rijdt, en er is ergens een put, dan blijft je fiets daar staan. Met weinig kracht geraak je er ook weer uit. De volgende keer dat je - in eender welke richting - op diezelfde lijn rijdt zal je wiel weer op exact dezelfde plaats blijven staan.
Voor je tafel hetzelfde principe: wat in bovenstaand voorbeeld zwaartekracht is, vervang je nu door een kogel (wiel) met een veertje en monteer je plat of omgekeerd of... maakt niet uit.
Die positionering vangt eenvoudig de speling van je aandrijfsysteem op!
Als je project doorgaat kan je alvast van mij een trapezium-spindel met bronzen moer en lagers krijgen... enige voorwaarde: "Project tot een goed einde brengen!" [:)][;)]
Ik zit op dit moment in 6 industri?le wetenschappen en m'n gip is net af. Ik heb hieruit vanalles geleerd, vooral dat als je optijd begint en je je er echt voor inzet je veel kan realiseren. Mijn onderwerp was het aansturen van een baan met het MM formaat. Als ik je kan helpen met je scriptie of iets dergelijks kan je me altijd mailen.
citaat:
Geplaatst door ysbeer
Boor in twee metalen strips even veel gaten als er sporen zijn.
strips op zijkant beweegbaar deel
Zet op de vaste wal twee servos met puntvormige stift.
een op uitrij en een op de inrijkant.
Servo in de midden van de heen en weer afstand.(rechts = links)
draai de pin in de gaten.
Leg middelste rail op beweegbaar deel.
zet stiften in volgende gaten.
monteer de rail die er bij hoort
Enz tot al rail ligt.
onnauwkeurig geboord is nu geen probleem
Toch leuk om je ideen bij andere terug te zien.[:0][:0][:D]
Dirky
Dan nog volgende opmerking op enkele van de aanmerkingen hier:
Als je werk met ?ets" dat vergrendelt op de opeenvolgende posities moet je een beetje aan "Thinking out of the box" doen. De nauwkeurigheid waarvan hier sprake is hoeft helemaal niet (de lat met gaatjes waarvan sprake).
Op het bewegend tafelgedeelte wacht je gewoon van sporen leggen tot de positie-grendeltjes gemonteerd zijn en je lijnt je sporen uit op die posities. Het maakt helemaal niets uit als er sporen eens op 50mm van elkaar liggen en daarbaast op 51mm....
Die grendeltjes kunnen heel eenvoudige ouderwetse meubel deursluitertjes zijn (kogeltje met veer)... want, als je de sporen richt op de vergrendelde positie moeten ook die niet nauwkeurig zijn. Ze moeten gewoon steeds op dezelfde positie komen te staan...
Ik ben er alvast van overtuigd dat het "goedkoop" kan en toch feilloos loopt..
Mechanische of optische 'vergrendeling'? Beide hebben toch een probleem?
Hoe detecteert de sturing dat het mechanische systeem 'vergrendelt' is?
Plaatsbepaling met IR led en fototransistor? Zal dat exact tov van elkaar stoppen, die ledjes stralen toch onder een zekere hoek? Of zou dat in het programma op te lossen zijn?
@Dirk(y): You have mail.
Het moet me toch even van het hart dat het hier om een studieproject gaat om 'modeltreinen' te besturen... Ik heb hier al oplossingen gelezen die er toch ver over zijn... Twee stappenmotoren en de nodige rotary encoders om uitlijningsverschillen te compenseren... Waarom dan geen glazen meetlat die op CNC machines gebruikt wordt? Kost ook maar de prijs van een Mfx-lok (wel nog BTW bijrekenen)...
Keep it simple!
citaat:
Geplaatst door conducteur
Mechanische of optische 'vergrendeling'? Beide hebben toch een probleem?
Gebruik beiden! Optische detectie dat je op je plek bent (3 IR reflectoren en je kan 8 sporen leggen, 4 reflectoren en je bent al goed voor 16 sporen - Gray-code stip onderaan/zijkant van de tafel - slechts ??n bit wijzigt).
Mechanische vergrendeling: een stukje taps gedraaid staal (H9) in een bronzen of messing (H7 geruimd) busje laten glijden en uitlijning is verzekerd.
citaat:
Geplaatst door conducteur
...Hoe detecteert de sturing dat het mechanische systeem 'vergrendelt' is?...
Isoleer beiden van elkaar en bij contact weet je dat de vergendeling geslaagd is...
Zelfs de kleinste (onnozele) servootjes (5 Euro) hebben al genoeg kracht om eventuele uitlijningsverschillen van een 12 kg tafel uit te lijnen.
Zoals reeds gezegd: maak je mechanisch gedeelte met optische plaatsbepaling. Bij elke overgang markeer je je positie voor de vergrendeling en boor die achteraf (horizontaal moeten die wel vrij juist zitten - met een eenvoudige aanslag op een kolomboormachine is dit een fluitje van een cent...).
Met een laser en goede lens voor de fotocel is veel te bereiken.
Niet in de laser kijken.
Maar mechanisch houdt mij voorkeur
Ik kijk met een laser en spiegels over beide wissel gebieden van mijn opstelsporen of er niets op de wissels is blijven staan.
Is 6 meter.
wim
@ Wim, sorry... niet alles gelezen en idd leuk achteraf te zien dat we "gelijk-denkend" zijn!
citaat:
Ik ben op zoek naar zgn blinde moeren, omdat dat volgens mij beter zal gaan.
Zou kunnen, maar als ik google naar "blinde moer" dan geven de eerste 3 resultaten telkens een verschillende moer te zien. Dat wordt spannend.
Laat je door al de idee?n die hier voorbijkomen niet het hoofd op hol zetten. Lees het allemaal eens door, maak van elk idee een lijst met voor- en nadelen. En neem zelf je beslissing. Begin niet met iets omdat iemand het hier als eenvoudig en ?zo voor mekaar" voorstelt. Het is tenslotte jouw project en je moet je er zeker bij voelen dat je het tot een goed einde kan brengen.
Dat had ik al lang door. Toch heb ik hier al veel bijgeleerd.
Ik heb het dus ook zitten h?, ben nu ook bezig met het verder ontwerpen van mijn fiddleyard. Vorige week vrijdagmiddag een multimeter op Ohm gezet en zeer voorzichtig tegen de Al- folie rondom mijn bokes gedrukt (bokes= boterhammen) Ik wilde de oxidelaag niet be?nvloeden. En weerstand zo goed als nul. S?avonds nog eens hetzelfde thuis gedaan tegen een Al- profiel dan al een jaar alle weersomstandigheden heeft ondergaan (als test op mijn toekomstige fiddleyard). En jawel weerstand = nul Ohm.
Kunt ge volgen? Binnenkort enkele testen en foto op dit forum.
Geert
citaat:
Geplaatst door Geert
Ik heb het dus ook zitten h?, ben nu ook bezig met het verder ontwerpen van mijn fiddleyard. Vorige week vrijdagmiddag een multimeter op Ohm gezet en zeer voorzichtig tegen de Al- folie rondom mijn bokes gedrukt (bokes= boterhammen) Ik wilde de oxidelaag niet be?nvloeden. En weerstand zo goed als nul. S?avonds nog eens hetzelfde thuis gedaan tegen een Al- profiel dan al een jaar alle weersomstandigheden heeft ondergaan (als test op mijn toekomstige fiddleyard). En jawel weerstand = nul Ohm.
Kunt ge volgen? Binnenkort enkele testen en foto op dit forum.
Geert
Ja ge wilt weten of alu oxide geleid.
Vind ge dat niet terug met google ?
Al oxide geleid niet maar deze oxide laag is zo dun...
Geert
citaat:
Geplaatst door Geert
Al oxide geleid niet maar deze oxide laag is zo dun...
Geert
En dat alu folie is niet geoxideerd,het glimt je tegemoet.aluminum met oxide is dof
Ik denk dat die folie behandeld is met..?????????
Ook na weken is het niet dof.
wim
Om eens in herhaling te vallen: Aluminium reageert onmiddellijk met de zuurstof uit de lucht. Dit vormt een laagje oxide van 10 nanometer dikte en schermt zo de rest van het Al af voor verdere corrosie.
Als je met een multimeter de weerstand probeert te meten druk je met die meetpennen door het laagje heen en meet zo terug het Al.
Die "kras" herstelt zich.
Echt aluminiumoxide kan je terugvinden in zeer fijne polijstmiddelen (Korund)
Sterke zuren en basen kunnen aluminium wel sterk aantasten. De oxidelaag wordt dan opgelost. Kijk maar eens rond als je nog eens aan de kust komt.
Getekend:
Gust, de kleine chemicust[:o)]
Praktijktesten zullen uitwijzen of het gewicht van een lok voldoende is om elektrich contact te maken en behouden tussen Al en wielen...
Geert
citaat:
Geplaatst door Huugooke
Echt aluminiumoxide kan je terugvinden in zeer fijne polijstmiddelen
Gust, de kleine chemicust[:o)]
En vergeet de condensatoren (electrolyte)niet.
wim ,de kleine cynicust.[:0]
citaat:
Geplaatst door conducteur
MSM 78 heb ik ook al doorgenomen. Nogal veel gefoefel met dat relais. Ik denk wel dat het werkt, maar er zijn elegantere methode's om dat te bereiken. Toch zijn er enkele elementen die mogelijk bruikbaar zijn.
Het belangrijkste is het plateau perfect vlak tegenover de fixe gedeelten te hebben en dat alle rails op het plateau perfect voor de ingang-uigang stopppen.
Gelageerde schuifsyst?mes, als er een overhangend gedeelte is, gaan onvermijdelijk plooien onder het gewicht. Het is daarom dat ik t'huis het plateau laat rollen met kogellagers op en "L" van aluminium, goed bevestigd op wanden, en dat de hele lengte van de beweging heeft.
Om het plateau perfect parallel te houden, heb ik dit gemaakt:(http://i320.photobucket.com/albums/nn333/titfom/DSC02975-1.jpg)
Een gleuf met een alumininium vierkant gevijst en daarna gekleefd met secondenlijm op een aluminium brede "L". De gleuf heeft 19,2mm. De diameter van de kogellager (19mm) + een stukje 0,2mm plasticard als sjaboon om op de hele lengte de goede afstand te hebben. Zo kan de kogellager er vlot in draaien zonder vast te zitten. Men ziet het beter hier:
(http://i320.photobucket.com/albums/nn333/titfom/DSC02978-1.jpg)
Kleinere kogellagers zijn ook goed, liefst "ZZ" met nylon wanden, voor de stof.
De oorspronkelijke gids in MSM was niet betrouwbaar, nu kan er gerust in gestampt worden.[:o)]En alhoewel het zich aan een uiterste zijde van het ding bevind, rolt dat met een blaasje van de pink...
Het stopsysteem is niet zo gefoefel, het is de staaf van het relais in de verschillende gleuven dat het stoppunt beperkt. Zelfs als de schroefstang een beetje los komt, is het altijd de staaf in de gleuf dat het stopplaats beperkt, met de rails goed gelijnd..
De ingang rails op het plateau en de uitgang rails op het fixe gedeelte moeten toch een beetje van binnen in "V" gevijld of gefreesd worden, niemand is god-de-vader. Ik ook niet!
Het moet misschien gemakkelijker zijn het relais op het fixe gedeelte te platsen en de "L" met de gleuven op het beweegbaar gedeelte, zo moeten de draden het plateau niet volgen. Thuis was dat niet mogelijk, ik ben die kant tegen de muur. Dat moet je zelf beperken.
Ik ben daarstraks eens gaan zien. De enige "spelling" dat ik heb is de spelling voor-achteruit van de moteur-as...Kan herzien worden.[:I]
Anders is alles "een blok"
De rails moeten natuurlijk het laatst gefixeerd worden, als de juiste stopplaatsen beperkt zijn door de gleuven en de staaf van het relais.
Dit met een 2mm vijs in een 3mm gat in de epoxy...
Handwerk blijft handwerk. En hout werkt ook...[:o)]
Anders, de schroefstang is een eenvoudige 14mmX2 van de brico en de moer dito, gefixeerd op een home-made flector
(http://i320.photobucket.com/albums/nn333/titfom/DSC02091.jpg)
Meer is echt niet nodig. En minder duur...Laat het toch rollen op de grond om te zien als het wel rond is...
De schroefstang "hangt" tussen de moteur en de moer.
Meer is ook niet nodig. Met kogellagers is het niet nodig, daar er geen ander vrijfpunt is
Het voornaamste ding is net en proper te werken. Voor de actie, en het uitzicht!
Maar voor de Dcc....[:(] Ik ben full analogisch...
Verder uileg en id?en als je wilt!
Het is hier erg stil, maar dat wil niet zeggen dat ik niets doe.
Ik heb het plan van mijn treinbaan alvast aangepast, omdat er in het vorige plan geen plaats was om de fiddleyard te plaatsen. Het nieuwe plan kun je op mijn website bekijken.
http://www.treinbaanrian.be/html/inleiding.html
Trouwe msm lezers herkennen wellicht het baantje Roycourt.
Rian, propere site, maar je witte tekst op de (donker)grijze achtergrond is bijna niet leesbaar.
Ik ben er nog niet helemaal uit hoe ik foto's kan weergeven, die vergroten als je er op klikt, zonder dat er een nieuwe pagina of tab opent. Als ik ze direct op volledige grote zet, dan staat heel de pagina direct vol, en moet je onnodig scrollen. Iets wat ik zeker wil vermijden.
De methode die ik daar heb toegepast is inderdaad niet erg geslaagd, maar niet getreurd, de tekst staat ook mooi in het zwart in de tekst in de rechterkolom.
Dat scrollen voor grote afbeeldingen moet je inderdaad vermijden.
Hoe je een foto kan aanklikken zodat je een grotere krijgt? Is een nieuwe pagina zo erg?
Stel dat je uitvergroot in een bestaande pagina moet de lezer ook ergens op klikken om de oorspronkelijke layout te zien, h? [;)]
Er zullen wel gadgets bestaan om dit "flashy" te doen, maar zoals Luc al eerder aangaf: de inhoud is veel belangrijker dan toeters en bellen [:)]
Wordt de website goed weergegeven op een 4/3 scherm?
Ziet er goed uit op mijn laptop (3/4 scherm). Eerste foto is een blikvanger.
Maar ik ben minder enthousiast over de indeling in 2 kolomen. Je moet dan eerst 1 kolom lezen, terug naar boven scrollen en dan herbeginnen.
Dat van een kleine foto die groter wordt doe je met 2 foto's. Eerst een "kleine" thumbnail die doorlinkt naar een nieuwe pagina met de grote foto. De blauwe index vind ik ook nogal ongebruikelijk. Bvb als je "bouw" kiest. De tekst verandert maar de pagina zelf niet, je moet dan nog eens iets kiezen om een nieuwe pagina te krijgen en dan is de blauwe balk weer de eerste versie.
De inhoud en presentatie zijn verder wel prima. Graag meer van dat.
In welke mate zijn er vorderingen in de plannen voor ' G.I.P: automatisch schaduwstation zonder wissels ' ?
Ik ben wel benieuwd naar de uiteindelijke uitvoering ?
Momenteel worden alle onderdelen getekend in een CAD tekensysteem (solid edge ST3). Ga als ik eens tijd heb een screenshot plaatsen van de 3d tekening.
(http://www.treinbaanrian.be/images/eindwerk/tekeningen1.jpg)
Even toelichten: een frame van aluminium extrusieprofielen vormt de basis van het geheel. De afmetingen zijn 1600mm *850mm, de houten plaat ligt (voorlopig) op 712mm boven de vloer.
Het aluminium frame zorgt voor de ondersteuning van de Drylin W glijlagers van het merk IGUS. Momenteel ben ik bezig met de aandrijving te tekenen in 3D. = tekening stappenmotor op internet zoeken, trapeziumspindel zoeken, moer zoeken,..., Plaatje tekenen waarop ik de motor zal bevestigen....
Ik sta wat achter met het volgen van dit topic, maar ik vind het best een geniaal systeem ;)
Inderdaad prima aan te sturen met een stappenmotor.
Nog veel succes
Citeereen frame van aluminium extrusieprofielen (knip) Drylin W glijlagers
Je neemt het wel professioneel aan met eerste keus materiaal zo te zien. Misschien nu iets duurder maar wel wat minder problemen achteraf.
Moet ook wel een beetje, moet mijn project op het einde voortonen aan een jury, die bestaat uit een aantal leerkrachten van school, en een aantal externen. Dat zijn meestal directeurs van plaatselijke grote bedrijven. Als die zien dat ik met gefoefel en geknutsel werk, dan vrees ik een beetje voor mijn eindresultaat.
Even een update: de trapeziumschroefdraadstang (tr18*4) heb ik getekend als een as met een diameter van 18mm. Ook IGUS heb ik een speciale moer gevonden waarmee ik de spindel met de houten plaat kan verbinden. Daarvoor heb ik een dwarsbalk getekend, die tevens ervoor moet zorgen dat de plaat minder gaat doorbuigen.
Omdat ik 'schrik' heb dat de plaat gaat doorbuigen, en zo geen mooie aansluiting zal geven op het in en uitrijspoor, heb ik maar direct een 18mm plaat genomen. Samen met die dwarsbalk zal dat niet meer plooien. Moest het toch nodig zijn, dan kan ik achteraf nog extra dwars- en verstevigingsbalken aanbrengen onderaan.
Een extra toevoeging is de brug op het einde van de plaat. Daar komt een sensor op die zal dedecteren dat de trein het einde van het spoor bereikt heeft. Ik ben nog aan het twijfelen tussen een optische sensor genre lichtsluis of een capacitieve (=duurder). Mijn langste trein, 5 l-rijtuigen met loc, is ongeveer 150cm, de plaat 160. Langer kan ik niet want het geheel moet met de auto naar school op de opendeurdag en op het einde van het schooljaar (denk ik toch), en anders heb ik niet genoeg plaats meer om de rest van de baan te bouwen. Ik hoop dat ik de trein mooi kan laten stoppen, liefst zo dicht mogelijk tegen het einde van het spoor.
De poten heb ik even onzichtbaar gemaakt, die hebben eigenlijk niet echt een grote 'functie', en zorgen toch maar voor beeldschermvulling. Voor de lagering, en de verbinding van de spindel met de stappenmotor moet ik morgen even uitleg vragen. Klik op de afbeelding voor de grotere weergave. Tof dat het forum de afbeeldingen automatisch kleiner weergeeft voor mensen met een kleiner scherm.
(http://www.treinbaanrian.be//images/eindwerk/tekeningen2.JPG)
Ga voor een lichtsluis, Rian: betrouwbaar, zelf te maken, goed genoeg voor jouw toepassing
Goed dat je een steun onder die plaat hebt voorzien, want er is zeker kans op doorhangen op zo'n lengte.
Voor die spindel-verbinding kan je best van die flexibele koppelingen gebruiken, je gebruikt voor de andere zaken ook reeds kwalitatief materiaal.
Het is inderdaad een 'grote' overspanning, bijna 1m lang.
mooi project...
Aangezien je op mijn email niet reageert en je hier een andere spindel voorstelt, veronderstel ik dat je de spindel en de moer die ik beloofd had niet meer nodig hebt?
Veel succes!
Ik heb nooit iets ontvangen.
Het is een zeer tof project, en ben blij dat ik dit mag maken, maar we moeten ook het prijskaartje een beetje in de gaten houden. Ik ben niet 100% tevreden met die poten uit die aluminium extrusieprofielen. Die kosten veel (+/- 20 € /m) en als mijn eindwerk klaar is, vliegen die er toch van onderuit om het geheel in mijn baan te integreren. Dat is toch ongeveer 5.5 meter minder. Dan kan ik 100€ nuttiger besteden, maar heb niet direct een idee hoe ik die zou vervangen.
Kan je het geheel niet lager maken misschien? Als het nu 10cm van de grond staat kan je het mogelijk in je baan verwerken en voor de jury plaats je het station op een grote tafel (of enkele bureaus tegen elkaar geschoven) Je kan dan misschien nog extra punten scoren op 'economisch' omgaan met grondstoffen :P
Succes met het project in elk geval
Zou ik ook doen, op tafel(s) of schragen als ze ook de onderkant willen zien.
Tafels of schragen en een doek erover (voor 100 Euro kan je al een heel fancy doek kopen ;) )
Voor je 'eindbepaling': een lichtsluis!
Je aansluitingen naar je vaste sporen... Dit wordt volgens mij een struikelblok... Je kan niet om de natuurelementen heen (krimp/uitzetting/kromtrekken). Als je hiervoor een 'ideale' oplossing vind, bouw ik je na!
Vanaf volgende week kan je je signalen voor je electronica-aansturing bekijken ;)
De tekeningen zijn 'bijna' af. Van de leerkracht elektronica heb ik de vraag gekregen of er driver IC's bestaan die een stappenmotor kunnen aansturen met een clock ingang en een Links/rechts draaien ingang. De bedoeling is dat de µC pulsen stuurt naar dat IC, waarbij de motor elke keer een stap verdraait. Dat moet wel bestaan denk ik, maar 'stepper motor driver ic' op google levert weinig op...
Rian, Ik heb hier zo'n schakeling liggen die net doet wat je wil.
Gun me wat tijd voor de nodige opzoekingen (schema ed)...
Hangt natuurlijk af van het type en vermogen van je stepper maar een mogelijkheid is de L297D met de L298D als power driver. Of de SAA1042 met geïntegreerde driver. Google "stepper driver clock" en die staan op de eerste pagina.
Elektuur juli/aug 1988: stappenmotorsturing met een L297 en L298. Juni 1988 en september 1988 zijn nog aanwezig in mijn archief. Jul/aug... wordt zoeken...
Boekje lag bij de stapel "te (her)klasseren"...
Rian PM!
Dag Rian,
hoe staan de zaken er voor?Vlot het wat?Ik ben zeer nieuwschiering naar u realisatie.
groeten eddy
Vrijdag 7/12 beginnen de examens, en ik moet een deel van mijn dossier indienen. Daar ben ik momenteel mee bezig. Tijdens de examens zal er uiteraard weinig GIPtijd zijn, tussen de eindejaarsfeesten door wil ik de voorbereidingen treffen voor de realisatie (kostprijs uitrekenen, materialenlijst opstellen en bestellen...) . Ik wil zeker beginnen met 'bouwen' in Januari.
Kleine update:
- De µC wordt een pic 16F877a gezien het grote aantal in/uitgangen nodig
- programmeren zal voornamelijk met flowcode gebeuren. (gezien dat we nog maar C leren later dit schooljaar)
- Een nieuw driver ic voor de motor hebben we gevonden: l6208
- Er komt een 'kuistrein modus' zodanig dat een kuistrein (of evt andere trein) zonder stoppen of wachten op de fiddle yard rondjes kan rijden.
- Er komt een 'automatisch rijden' waarbij de treinen elkaar zullen aflossen in het schaduwstation om wat automatisch verkeer mogelijk te maken
- Een LCD display zal de status weergeven: welke sporen zijn er bezet, wat er op het ogenblik gaande is (verplaatsen, oprijden, afrijden,....)
Dit is een tof een veelzijdig project !
Ik duim voor een succesvolle uitwerking ;)
@ conducteur .
Ik blijf het een tof project vinden .
Ik wens je veel doorzetting en een geslaagde landing .
Die kuistrein-modus is in elk geval een goed idee 8)
Citaat van: conducteur op 27 november 2012, 17:28:53 PM
...Ik wil zeker beginnen met 'bouwen' in Januari...
Krijgen we een 'bouwverslag' te zien?
Tuurlijk (als ik de foto's tenminste niet vergeet)
mooi project met een grootte omvang.
Veel succes nog .
mvg niKo
Dat van die kuistreinmode versta ik niet goed. Als ik het begin goed herinner was dit toch een aantal parallel sporen op een roltafel die elk om beurt aan een spoor konden aansluiten. Soort omgekeerde rolbrug. Hoe zit het dan met die kuistrein die "rondjes rijdt" in de fiddle?
Citeer- Een nieuw driver ic voor de motor hebben we gevonden: l6208
Ik heb ooit in een project een L6207 gebruikt, dat is een versie voor DC motoren. Behoorlijk wat problemen mee gehad. Vooral als je "te kleine" motoren aansluit. De inductantie is dan niet groot genoeg en de stroomregeling werkt niet goed. Eigenaardig genoeg draaide het allemaal beter als we een spoel in serie met de motor zetten. Lees die datasheet dus maar verschillende keren!
Het is de bedoeling om de fiddle yard, in een later stadium aan een nog te bouwen treinbaan te koppelen.
Als een trein de fiddle yard op zal rijden, dan zal die volgens het standaard programma op het einde van het spoor stoppen. Vertrekken zal gebeuren door op een knopje te drukken op een bedieningspaneeltje. Per spoor zal een drukknop voorzien worden (= één poort van de µC). Bij het bedienen van die knop zal de tafel zich verplaatsen met het overeenstemmende spoor, en daar de trein laten vertrekken.
In de automatisch rijden modus zal de werking van dat paneeltje overgenomen worden door de µC zelf. Hij zal een trein laten vertrekken, van zodra er een is toegekomen.
In de kuistrein modus zal een trein (bv een kuistrein) gewoon kunnen doorrijden zonder stoppen, of afwisselen. Zo kunnen de sporen continu gekuist worden.
Nog een kleine update.
De examens lopen nog tot dinsdagvoormiddag. Daarna ben ik vrij tot in 2013... De moeilijkste examens zijn al voorbij en er komt al een beetje tijd vrij voor andere dingen te doen. Ik moet de werking van het programma voor de µC in grote stappen in een schema/flowchart weergeven. Om als basis te gebruiken om later het programma te 'maken'. Die moet wel veel doen:
-De 8 sporen aansturen + inrijspoor
-LCD display aansturen
-knoppen/schakelaars bedieningspaneel uitlezen
-motor aansturen
-terugmelding 8 sporen + inrijspoor
...
Ik zie niet zo goed hoe alles te ordenen. Voor zover ik weet kan een µC slechts één ding per keer. Bv hoe controleer je de toestand van de knoppen op het paneeltje, terwijl de µC pulsen stuurt
Dat programma wordt ook wel nog een uitdaging... Mijn enigste ervaring met programmeren (in flowcode) is met de formula flowcode buggy:
(http://www.sparrendal.be/emonds/flowcode/flowcode1/buggy.jpg)
Citaat van: conducteur op 15 december 2012, 23:05:47 PM
...Voor zover ik weet kan een µC slechts één ding per keer...
Rian, vrouwelijke hormonen nemen: ik verklaar me nader: vrouwen gaan er prat op dat ze kunnen multitasken (wij mannen gelukkig niet, maar doen dan één taak wel degelijk)...
Alle gekheid op een stokje: inderdaad multitasken: je processortijd verdelen over de verschillende taken... Dus interrupts en een time-based scheduler...
...Ofwel meerdere controllers 'eenvoudig' werk laten verrichten en laten coördineren door een 'big brother' controller...
Dan bedoel je dat er bv onder op het bedieningspaneeltje een printje hangt met een (kleinere) µC die constant de knopjes inleest en die info naar een centrale µC stuurt.
Hoe zie je die communicatie dan? Hoe gaat zoiets? Is dat zoiets als de 'big brother' µC geen taken heeft dat die een signaaltje uitstuurt naar de µC onder het bedieninspaneeltje in de zin van 'ik ben klaar om info te ontvangen van je' (waarop die zijn laatst geregistreerde knopindrukken doorstuurt)?
Je kan ook de snelheid van de µC gebruiken, hoor: in een lus telkens dingen laten lezen, verwerken, uitgangen zetten.
Een knop indrukken duurt minstens een kwart seconde, en op die tijd loopt je lus héél vaak :)
Er is mogelijk wél een probleem met je beschikbare poorten: een lcd heeft minstens 6 pennen nodig, je hebt acht sporen te sturen en te checken, je toetsenbord met X schakelaars en verklikkers, ...
=> en dan moet je misschien toch met meerdere microcontrollers werken ...
We hebben geteld, er zijn er juist voldoende... Dit is wat ik samen met de leerkracht heb opgesteld:
Nodige uitgangen
8 reliasuitgangen selectie spoor : aan/ afleggen spanning
1 relais uitgang inrijspoor :aan/ afleggen spanning
8 drukknopingangen (spoorselectie)
1 schakelaar continu rijden (sporen kuisen)
1 schakelaar rijden en autom afwisseling
Lichtsluis ingang
Stappenmotor stuurlijnen (L/R,START, snelheid ?)
Mogelijkheid om display aan te sluiten om toestand installatie weer te geven.
Keuze microcontroller 16F877a
Display op poortA
Drukknoppen op poort B
Schakelaars opE0,E1, lichtsluis op E2
Stuurlijnen stappenmotor C (PWM mogelijkheid) + uitgang relais inrijspoor C7
Stuurlijnen relaisuitgangen poort D
Citaat van: conducteur op 16 december 2012, 10:42:05 AM
...
Keuze microcontroller 16F877a
Display op poortA
Drukknoppen op poort B
Schakelaars opE0,E1, lichtsluis op E2
Stuurlijnen stappenmotor C (PWM mogelijkheid) + uitgang relais inrijspoor C7
Stuurlijnen relaisuitgangen poort D
Met een dergelijk beest inderdaad poorten genoeg. Opteer voor een kristaloscillator van 20 MHz dan duurt een instructie slecht 0.2 µs (je zal heel wat instructies moeten verwerken).
Je zet je schakelaars rechtstreeks op een inputpoort: één keer die poort lezen en je weet of er één of meerdere ingedrukt zijn. Relaisuitgangen ook samen op één poort (drivertransistor voorzien!) dus ook in één keer aan te sturen. Je display? Ik weet niet of Flowcode daar bibliotheken voor heeft, maar dat aansturen vraagt ook niet veel tijd.
De meeste tijd voorzien voor je lichtsluizen en je stappenmotorsturing.
Die stappenmotorsturing? Ga je je pulstreinen zelf maken met je controller of gebruik je daarvoor een stuur IC (genre L297)? Met een L297 geef je terug een groot (en tijdgevoelig) deel van je programma uit handen en moet je er dan ook geen rekening meer mee houden.
Ik ben eens gaan kijken wat Flowcode is en hier (http://www.matrixmultimedia.com/video.php?v=iXFMOGXsHP8) een beknopte video.
Ja, er is een L6208 voorzien, dat is één chip die de ganse sturing zal regelen op basis van 'eenvoudige' signalen uit de µC. Beetje vergelijkbaar met de combinatie van l297+l298, maar dan in één chip.
Er zijn verschillende mogelijkheden.
1: je maakt een soort mini operating system dat elke taak tijd geeft. Dat is waar Peter het eerst over heeft. Sommige taken gaan maar af en toe moeten lopen (zoals schakelaars inlezen), andere heel vaak (zoals de pulsen voor de steppers als je die zelf maakt). Sommige taken zijn ook heel kort, andere duren wat langer. Sommige hebben prioriteit (de noodstop). Veel varianten mogelijk. Probleem hier is dat je dat niet liggen hebt en dat je dus een stuk extra werk hebt dat eigenlijk niet zichtbaar is. Voordeel is dat dit heel flexibel is en de processor goed gebruikt.
2: de aanpak van Gerolf met een hoofdlus. Je laat de processor een grote lus doorlopen waarin je telken de inputs inleest en dan beslist welke outputs je als gevolg daarvan (en waar je daarvoor mee bezig was) stuurt. Dat is dan een grote state machine. Probleem hier is dat je zeker moet zijn dat alles te verwerken is in de tijd die de lus nodig heeft. (je kan wel deellussen maken) En je moet alles op voorhand goed plannen. Voordeel is dat het "natuurlijker" overkomt.
3: je zou ook kunnen zien of wel alles tegelijk moet kunnen. Dan krijg je een mix tussen de 2 aanpakken. Je leest de knoppen in en voert dan een lus uit totdat een bepaalde handeling volledig uitgevoerd is. Bvb als je de tafel verplaatst, dan rijdt er geen trein binnen of buiten. Dus dat kan je afsplitsen. Je programma kijkt dus naar de knoppen, ziet dat er een verplaatsing moet gebeuren en voert dan een lus uit totdat die verplaatsing gedaan is. Gaat dan terug knoppen inlezen. Wel altijd de noodstop blijven checken. Voordeel is dat je overzichtbare stukken hebt die onafhankelijk zijn (en dus ook testbaar en toonbaar) maar minder flexibel.
4: multi µC is een optie. Maar ik denk voor jou geen optie. Je moet tenslotte op tijd iets toenbaars hebben dat werkt.
Ik wil me nu niet bemoeien met je µC PIC keuze, maar er is een gelijkaardige µC zoals deze die jij wil gebruiken maar met interne oscillator van 8MHz (RC keten) nl. PIC 16F887. Zo komen de 2 OSC ingangen vrij voor in/outputs die jezelf kan kiezen. Ook kan je bij deze µC de RESET ingang vrij gebruiken voor input. Dit geeft al 36 in/outputs op één µC! Nog een handigheidje op de µC is dat heel de B poort (8bits) een interrupt program kan oproepen als de toestand op één van die pinnen veranderd. Ook heeft deze B poort interne pull up weerstanden. Je hoeft dus geen extra R's van 10kOhm te gebruiken samen met je keuze schakelaars. Voor de rest heeft deze nog voordelen die je vermoedelijk niet zult gebruiken. Misschien kan ik je ook met de kostprijs overtuigen, bij Conrad.nl: 16F877a=8,37€; 16F887=3,08€ (dagprijs op 17/12/2012). Voor minder heb je dus meer ;)
Succes,
Geert
Ik gebruik meestal een "modus"-variabele in de hoofdlus.
Afhankelijk van de modus worden bepaalde routines wel of niet afgehandeld. Dat spaart rekentijd.
De noodstop altijd, maar voor jou moeten handelingen nu eenmaal in een volgorde gebeuren.
Lichtsluizen alleen checken als je plaat beweegt, treindetectie hoeft ook niet altijd, ...
... en laat de controller zelf dingen doen die ingebakken zitten (pwm-signalen hoef je niet zelf aan en uit te zetten, ...)
Even iets anders dan elektronica: de stappenmotor heb ik gekregen van afbraak machines. Omdat die komt van een firma die niet aan particulieren verkoopt, kan ik zelf de 3d tekeningen niet downloaden, dus maar zelf de motor vlug getekend. Ik weet dat de tekening niet 100% juist is, maar de belangrijkste afmetingen zijn correct getekend. Dit is dus een van de laatste tekeningen die ik nog moest maken:
(http://www.treinbaanrian.be/images/eindwerk/IMG_0003.JPG)
Weet er iemand waar ik aan Item 40*40 aluminium extrusieprofielen kan komen, liefst in provincie West-Vlaanderen of Oost-Vlaanderen. Heb al een bedrijfje gevonden in Nederland, maar die zijn erg ver, en kunnen geen stukken verzenden langer dan 1m, (ik heb er twee van 160cm nodig). Een zaagservice is welkom, dan moet ik geen zaagblad voor mijn Metabo aanschaffen.
Ik heb 6 stukken van 77cm nodig ( 4,62m) en nog 2 van 160 cm (3.2m), 7,82m in totaal dus.
http://www.promec.be/
Zijn verdeler van Paletti-Profilsysteme en kunnen zeker leveren.
Let op, 40x40 op een lengte van 1,6m buigt licht door. Misschien wel beter 80x40 op zijn kant zetten. En niet verschieten van de prijs... da's nie goedkoop! Vraag misschien naar licht beschadigde overschotten...
Bedankt voor je snel antwoord, Dirk.
Nog een bedrijfje in Dadizele gevonden (dat is al veel dichter), maar voor zover ik kan afleiden uit hun site verkopen ze enkel het profielsysteem met als basismaat 45*45 (of 45*90, 90*90).
www.alumes.be (http://www.alumes.be)
http://www.damencnc.com/ (http://www.damencnc.com/) Geen klant, ooit gevonden en opgeslagen ter referentie.
Ken ik, maar die leveren geen lengtes langer dan 1m per post, en Alphen aan de Rijn is zo niet direct in de buurt van Bl'ge
Meer dan 1 meter gaat met de post altijd problemen geven. Al op ebay gekeken?
Mijn probleem is denk ik toch opgelost... Dadizele is niet zo ver, daar zal ik pa wel eens voor vragen om eens tot ginder te rijden.
EDIT: aluminium profielen besteld...
Deze middag naar Dadizele om aluminium profielen...
(http://www.treinbaanrian.be/images/eindwerk/frame1.jpg)
Het frame zit in elkaar... Nu is het wachten op de andere onderdelen die ook besteld zijn.
Het frame is gemaakt uit 45*45L profielen, die 'slecht' geanodiseerd zijn, waardoor ik ze aan een goede prijs heb kunnen kopen. Hier en daar zijn er wat plekken waar je het kunt zien, maar voor de rest zijn ze zoals normale nieuwe.
Voor het gemak zitten de profielen vast aan elkaar met 12 kleine zweetjes:
(http://www.treinbaanrian.be/images/eindwerk/frame2.jpg)
Stevig constructie. Met zo'n profielen ziet het er direct een stuk professioneler uit.
Hoi Rian,
Komen ze toevallig van ALUMES? Ik heb er ook m'n onderframe voor de banen gehaald.
Had je de montagestukjes niet? Dan moet je die hoekijzertjes niet gebruiken...
In alle geval stevig!
Ja, zoals hierboven vermeld komen de profielen van Alumes. Was de dichtsbijzijnde die ik gevonden heb die die dingen verkoopt.
Veel te lang geleden dat ik hier nog iets gepost heb. Zojuist enkele bestellingen gezet, zodat we verder kunnen werken aan de realisatie komende vakantie.
Ondertussen hebben we niet stilgezeten:
-elektronica-schema's getekend en printplaatjes ontworpen.
-Theorie verder uitgeschreven. Zal dat voor de geïnteresseerden eens online zetten als het definitief af is.
-schoollicentie van flowcode op mijn PC geïnstalleerd, en de werking even opgefrist na 2 jaar...
PIC is dan toch veranderd van16f877a naar 16F887, met een kwartskristal op 20MHz. Ik kan mogelijk via school een ontwikkelbordje uitlenen om mijn PIC mee te programmeren, moet daar wel nog even de juiste personen voor aanspreken voor toestemming. Nadeel is dat ik na dit schooljaar dan geen eigen programmer meer heb voor zelf (kleine) projectjes te maken. Wat gebruiken jullie om je pic's te programmeren?
Ik gebruik geen pic's, maar avr's. Mijn programmer is vrij eenvoudig zelf gemaakt, heeft 5 contacten nodig van je parallelle poort.
De programmeeromgeving die ik gebruik (Bascom) kan hier prima mee om.
Momenteel experimenteer ik met ISP (in-service-programming) om bij een bepaalde printplaat de controller niet telkens te moeten overplanten.
Ik gebruik een PICSTART Plus (van Microchip) seriëel via een USB omzetter. Is al tamelijk op leeftijd maar nog steeds geschikt voor vele PIC's in DIL behuizing (kost bij Microchip zelf rond de 150 Euro).
Op het net zijn enorm veel schema's te vinden voor een zelfbouw programmer; nadeel is wel dat de meeste via een parallelle poort werken (al een eeuwigheid geleden dat ik nog zo'n poort gezien heb).
Velleman heeft er ook één maar die werkt niet op een seriëel-USB omzetter.
Een ISP programmer is bij Microchip de PICkit 2 en is rechtstreeks via USB aan te sluiten (kost ongeveer 27 Euro).
Ik kan je altijd uit de nood helpen om er ééntje (of meerdere) te programmeren. Nadeel is wel dat je tijdens het ontwikkelen meerdere keren moet (her)programmeren en dan wordt het een beetje duur om telkens een processortje met de post naar mij te sturen om te herprogrammeren.
[edit] Zoek eens op 'pic programmer usb diy' en je komt er verschillende tegen. Je hebt wel een kraan nodig om een kraan te bouwen (er zit een geprogrammeerde PIC in die programmers) maar daarmee kan ik je helpen (op voorwaarde dat het een DIL exemplaar is).
Citaat van: PeterC op 03 februari 2013, 11:28:32 AMnadeel is wel dat de meeste via een parallelle poort werken (al een eeuwigheid geleden dat ik nog zo'n poort gezien heb).
Dat is inderdaad minder leuk. De parallelle poort is in onbruik geraakt.
Er bestaan gelukkig nog kaartjes om in een pc in te bouwen. Voor een laptop wordt dat natuurlijk lastiger ...
Een nadeel van een usb-programmer is dan weer dat je een andere (geprogrammeerde) microcontroller nodig hebt.
De fabrikanten lijken het leuker te vinden dat je een compleet (duur) pakket koopt :(
Zeg, zo'n pickit2 of 3 is toch best bruikbaar voor pics? Kost niet veel, op usb, direct programeren op de pcb. Wat wil je nog meer?
Heb besloten om een controller te lenen van school. Dat bespaart me voorlopig toch de aanschaf van een nieuwe/zelfbouw... Ook het E-blocks LCD'tje kan ik lenen. Verder heb ik nog mijn optische sensor gekregen, een omron E3S-Cl1. De gevoeligheid is regelbaar, hij is omschakelbaar tussen PNP en NPN, heeft een zender en ontvanger in één, en de manier waarop hij reageert bij een detectie is ook regelbaar (zoals op foto brand de led als er niets gedecteerd is, maar dat kan ook ingesteld worden dat hij niet brand).
(http://www.treinbaanrian.be/images/eindwerk/IMG_0073.JPG)
Een testje op 12 volt van een van mijn testvoedingetjes, de led is duidelijk 'uit':
(http://www.treinbaanrian.be/images/eindwerk/IMG_0077.JPG)
Vandaag zijn mijn Drylin glijlagers van IGUS toegekomen, samen met een trapeziumschroefdraadstang, een flensmoer, een flexibele koppeling en nog wat klein spul. Voor die trapeziumschroefdraadstang heb ik wel nog wat hulp nodig, gezien die aan de uiteinden nog moet afgedraaid worden tot op de kerndiameter (van TR18x4 naar 12mm) om in de flexibele koppeling te passen.
Citaat van: conducteur op 07 februari 2013, 22:05:39 PM
...gezien die aan de uiteinden nog moet afgedraaid worden tot op de kerndiameter (van TR18x4 naar 12mm) om in de flexibele koppeling te passen...
Jammer genoeg is mijn draaibankje daarvoor te klein. Een 'gemotiveerde' leraar en volgende week op school tijdens de vakantie? ...Of een forumlid met een grote draaibank?
PS: de ''Kokketeuten' staan nog steeds te wachten op 'een geschikt moment' ;)
Misschien inderdaad interessant voor te vermelden: de schroefdraadstang is 82cm lang... En nog zeer belangrijk te vermelden: mijn programmer vandaag meegekregen, samen met nog wat E-blocks modules (lcd, drukknoppen en led bordjes)
De printplaten voor de elektronica zijn nog niet allemaal gemaakt, en mechanisch is er ook nog wat werk, maar ik kan wel al wat expirmenteren met die E-blocks om het programma te schrijven. Wat mij nu voornamelijk problemen geeft is de sturing van de motor.
In het begin van het programma zoekt de motor zijn homepositie op. Die ligt vast door een microswitch. Daar ligt het nulpunt van het systeem. Dat is niet zo moeilijk, ik laat de motor draaien tot de microswitch geactiveerd is. Is de positie bereikt, wordt een variabele gedefinieerd waarin de huidige positie wordt geschreven ( is hier 0). Hier moet ik niet echt stappen gaan tellen. De volgende stap in het programma is de lege/volle sporen detecteren. Daarvoor moet de plaat terug bewegen, zodat ik de stand van de optische sensor kan uitlezen, en dat is nu wat mijn probleem. Ik moet het aantal stappen kunnen berekenen, en tijdens de aansturing tellen. (er is geen terugkoppeling van de positie).
De stappenmotor wordt door een L6208 aangestuurd. (is besteld). Die heeft een aantal logische ingangen (een clock-signaal, bij elke positieve flank zal de motor één stap verzetten, een voor L/R draaien, en een 'Enable', als die laag is (0v) dan zal de stappenmotor niet reageren op pulsen van het kloksignaal.
-Ik zou op twee manieren die pulsen kunnen genereren: met de PWM functie die in m'n controller zit, of zelf een kloksignaal opbouwen (poort aan, delay 1ms, poort uit delay 1ms en dat herhalen). Ideaal zou zijn als elk spoor op bv 1000 stappen van een ander ligt, maar dat denk ik niet. Ik weet dus niet helemaal goed hoe ik het aantal stappen kan uitrekenen in m'n programma. Voornamelijk het berekenen is een probleem.
Tellen: voor de pwm functie heb ik nog niet echt gevonden of ik daar het aantal stappen kan tellen, dus daar zou ik moeten gaan spelen met de tijdsduur.
Op de andere manier kan ik maar een stapfrequentie halen van 500Hz, ik zou tocha al blij zijn als mijn motor dit aankan maar hier lijkt mij het tellen een minder probleem.
Hebben jullie een idee?
CiteerIk weet dus niet helemaal goed hoe ik het aantal stappen kan uitrekenen in m'n programma. Voornamelijk het berekenen is een probleem.
Ofwel reken je ze op voorhand uit en zet je die als constanten in je programma. Of je maakt een testprogramma waarmee je het aantal stappen bepaalt. Voor het uit te rekenen, je stappenmotor doet x stappen per omwenteling en de schroef heeft een pas van y mm. Dus heb je x stappen nodig om y mm op te schuiven. De rest is een beetje algebra :)
Andere methode is een sensor die schakelt als je spoor goed staat. Je laat dan gewoon je motor draaien tot de goeie sensor schakelt.
Open loop vs gesloten loop.
Dat is niet zozeer het probleem, het gaat hem voornamelijk om het programma. Stel de huidige postie is 2000 stappen van de homeswitch ver, de plaat moet naar spoor 8 op bv 8000 stappen, dan kan ik uitrekenen dat ik 6000 stappen moet verplaatsen. In een variabele kan ik dan schrijven dat spoor8=8000 en met een simpele berekening kan ik bepalen spoor8>huidige positie en zo dus de richting bepalen en spoor8-huidige positie=6000 en dan kan een simpel lusje 6000 keer afgehandeld worden, maar hoe bepaal je in het programma die 6000, want dat kan evengoed van de huidige positie naar spoor 1 zijn, en dan ben ik niets meer met mijn berekening?
Gebruik de nulpositie-instelling (met een microswitch of lichtsluis) om af en toe te synchroniseren.
Je stappenmotor (in de juiste richting) tellen doe je met een tabel (array) voor de gewenste waarden, verschillen berekenen en ... laten stappen
Maximale stap-snelheid hangt af van je motor (traagheid/inertie/betrouwbaar) en is proefondervindelijk
Rian,
in welke taal ben je van plan te programmeren? ASM C JAL ...
Geert
Ik denk dat ik ergens E blocks en Flowcode (http://www.matrixmultimedia.com/eblocks.php) gelezen heb.
Rian, ik probeer straks iets te formuleren voor je telprobleem (moet nu een beetje werken).
Je moet je probleem niet in 'stappen' bekijken maar in 'millimeter', zoals Johan Havoc reeds aangaf.
Tussen spoor 1 en 2 zijn ... mm, spoor 2 en 3 ... mm, enzoverder (en als je slim bent leg je alle sporen op exact gelijke afstand van elkaar!).
Als uw afstand tussen uw sporen allemaal gelijk is (doe dit voor uw eigen gemak!) is die X.
Je kan berekenen aan de hand van de spoed van uw as hoeveel omwentelingen Y hij moet maken om die X mm te verplaatsen.
In de gegevens van uw stappenmoter lees je hoeveel stappen hij moet maken om 1 omwenteling te doen.
Met die gegevens kan je dus berekenen hoeveel stappen uw motor moet maken om afstand X te overbruggen (aantal stappen voor 1 omwenteling) * Y.
Dat is altijd een vaste waarde Z in uw software (vermits je een slimme kerel bent, liggen alle sporen exact even ver van elkaar en heb je dus zo maar 1 constante).
Moet je van spoor 1 naar 2, dan verzet de stappenmotor Z stappen in + richting ('+' want 2 is groter dan 1).
Moet je van spoor 8 naar 3 dan verzet de stappenmotor (8-3)*Z stappen in - richting ('-' want 3 is kleiner dan 8) .
Uiteraard vertrek je in de opstart van uw programma vanuit uw 0-punt.
Paul
Nog enkele foto's die ik nog niet heb gepost hier:
De stappenmotor met koppelbus erop, ernaast de trapeziumschroefdraadstang met achteraan de flensmoer.
(http://www.treinbaanrian.be/images/eindwerk/motor.jpg)
Het E-blocks systeem: de programmer, onder de Pic zit nog een IC voetje om zo verschillende PIC-formaten te kunnen programmeren.
(http://www.treinbaanrian.be/images/eindwerk/programmer.jpg)
Er bestaan heel veel modules, die je kunt aansluiten op een van de poorten.
(http://www.treinbaanrian.be/images/eindwerk/Lcd.jpg)
Mijn testopstelling, de ledjes simuleren de uitgangen, de knopjes de diverse ingangen:
(http://www.treinbaanrian.be/images/eindwerk/eblocks.jpg)
Het programmeren gebeurt voorlopig nog in Flowcode, vanwege (g)een (gebrekkige) kennis van een programmeertaal. Via eenvoudige symbooltjes kan een programma worden opgebouwd.
Voordat de PIC geprogrammeerd wordt, vertaalt de pc de flowchart naar C en ASM. Door dat al enkele keren te bekijken begin ik het te 'begrijpen'. Beslissingen, LCD display aansturen gebeurt hier ook mee. Je kunt ook een blokje in de chart slepen waar je je eigen C code in kunt schrijven.
(http://www.treinbaanrian.be/images/eindwerk/chart.jpg)(http://www.treinbaanrian.be/images/eindwerk/chart2.jpg)
Het is wel de bedoeling om de sporen zo mooi mogelijk op gelijke afstand te leggen van elkaar, maar ik denk dat dat toch altijd een 10-20 stappen zal schelen. Ik zou er niet op rekenen dat ze allemaal op bv 1000 stappen van elkaar liggen.
Zoals Gerolf al aangaf, je gebruikt een array met waardes die je op voorhand invult. Spoor 1 ligt op x stappen --> element 1, spoor 2 op y stappen --> element 2 etc allemaal gemeten tov je 0 positie. Dus eerst zet je de stepper op 0-positie met een initialisatieroutine. Daarna is het enkel beslissen naar welk spoor je moet gaan, je leest de waarde, bepaalt aan de hand van je huidige stand waar je naartoe moet (links of rechts draaien), rekent het verschil uit en laat je routine lopen.
Tenzij je stappen verliest moet je eigenlijk nooit meer naar 0 gaan. Stappen ga je verliezen als je de motor te snel wil laten draaien, er teveel wrijving is of er iets blokeert. Maar als dat het geval is kan je beter naar gesloten lus besturing gaan.
Ga eens zoeken of ik in flowcode een array kan maken, anders wordt het even C leren.
Citaat van: conducteur op 12 februari 2013, 19:59:34 PM
Ga eens zoeken of ik in flowcode een array kan maken...
Op het eerste zich laat Flowcode alleen maar byte arrays toe (waarde 0-255). Als je meer dan 255 stappen per spoor nodig hebt, zal je multiple byte waarden aan je array moeten toekennen en dan beginnen rekenen. Vergemakkelijk de zaak niet echt.
In C geen probleem voor arrays. Daar bepaal je zelf je structuur maar is dan ook niet de gemakkelijkste taal (en bij een verkeerde indexering van je array overschrijf je zonder problemen de rest van je geheugen...).
[edit] Ik zou eerder opteren voor een eenvoudige optische detectie: een IR reflector (gebruikt slechts één poort) en per spoor een wit-zwart-wit overgang. Detecteer die overgang en je zit aan je spoor. Je hoeft dan ook geen rekening te houden dat als je vb van spoor 2 naar spoor 3 gaat en terug naar spoor 2 je met een verschillend aantal stappen gaat zitten (onvermijdelijke speling, hoe miniem ook).
Ik zou ook een eind schakelaar voorzien. Als je soft in de knoop komt, stopt de motor misschien niet meer en zo te zien heb je geen slipkoppeling.
Kijk misschien eens naar een CNY70.
Het is maar een denkpiste van mij.
Als je die byte interpreteert als hoeveel omwentelingen je moet doen dan kom je er wel denk ik. Of een andere factor.
Eindstops zijn zeker aan te raden. En eindstops die niet door de software gaan nog meer.
Ik heb voor elk spoor een variabele gemaakt (spoorpositie1...spoorpositie8). In die variabele staat eigenlijk een constante, het aantal stappen vanaf mijn 'oorsprong' tot aan het spoor. Een variabele 'positie' bevat telkens de huidige positie. Er is nu ook nog een variabele eindpositie bijgekomen.
Als ik nu moet verplaatsen naar bv spoor 2 dan zeg ik:
eindpositie=spoorpositie2
het verplaatsen en opwekken van de klokpulsen heb ik in een subroutine gestoken. Daarin gebeurt het volgende:
Eerst wordt de berekening gemaakt positie-eindpositie=richting
Ten tweede wordt de logische test uitgevoerd: is richting>0
Afhankelijk van ja of nee kan ik dus de richting bepalen. Vervolgens worden in een lus pulsjes opgewekt, de huidige positie wordt telkens uitgerekend. De lus wordt doorlopen zolang positie<>eindpositie...
Lijkt op het eerste gezicht te kloppen.
Heb het op mijn E-blocks geprobeerd en volgens mij werkt het. Ik wacht nog tot mijn l6208 stappenmotor driver ic toegekomen is, die is besteld in de winkel en dan wil ik hetgeen ik nu al heb geprogrammeerd eens uitproberen op de printplaten die ik nog (gedeeltelijk) moet etsen. (er is al één klaar), ga daar morgen eens de relais en andere onderdelen op solderen denk ik.
Het voordeel van een variabele in plaats van een constante voor je spoorlocatie, is dat je de zaak ter plaatse kan afregelen.
Deze waarde kan je dan in eprom opslaan. Bij elke opstart haal je de array-waarden (of een aantal variabelen) uit je eprom.
En, stand van zaken... We zijn echt nieuwsgierig. ;)
Geert
Eens wat stof van dit draadje blazen.Heb iemand gevonden die het draaiwerkje wil doen voor me. Zou dat deze week moeten terug krijgen. Er is nog een stukje dat uit staalplaat moest gelaserd worden en geplooid. De tekeningen daarvoor zijn opgestuurd naar de leerkracht die alle tekeningen van de andere leerlingen verzamelt om dat te samen laten laseren. Die tekeningen zouden nog deze week verstuurd worden naar het bedrijf. De voeding voor de elektronica is gemaakt (78xx voeding), 12v + 5v.
-Mijn L6208 is besteld en toegekomen, ga dus het driverbordje voor de motor ook eens etsen en solderen als ik wat tijd vind deze week.
-Het relaisbordje (8 stuks, voor elk spoor in/uit te schakelen een). Is al gemaakt en getest.
-Het µcontroller kaartje met wat extra onderdeeltjes moet ik ook nog eens etsen. Het programma zal nog niet perfect werken, maar hoop dat er al wat beweging uit zal komen. Het ontwerp voor beide te etsen kaartjes is al gemaakt. Alle onderdelen zijn (voor zo ver ik weet toch) al aangekocht en dus op voorraad.
Met de examens die komende zijn (mondeling, één per dag) moeten we ook eens op proef hetgeen we al hebben presenteren, dus daar zal wat werk aan zijn. Tussen de examens door zal er ook wel een heel klein beetje gewerkt kunnen worden. Voor de taalvakken bv moeten we enkel een boekje lezen en dat voorstellen, dus daar is al weinig werk aan.
foto's zullen voor een andere keer zijn. Heb morgen examen rijbewijs op school en ga nog wat leren...
http://forum.e-train.fr/viewtopic.php?f=46&t=70628
heb mijn post hier geplaatst, is hier meer op zijn plaats
Groeten Peter ;)
Mogelijk sta ik met mijn realisatie op onze grote modeltreinruilbeurs met Pasen, maar dat zal nog afhangen van hoever ik sta met mijn werk en of er nog een plaatsje vrij is in de zaal... Ik hou je op de hoogte.ri
Ook met de opendeurdagen van de school (21 &22 april van 14u tot 18u) vraag dan naar 6de jaar Industriële wetenschappen. Als je eens wilt komen kijken, ik hou je niet tegen.
Enkele foto's (vlug met mijn Ipod genomen, dus niet van de beste kwaliteit)Het relaiskaartje, 8 relais, voor elk spoor een. De treinen vertrekken/stoppen op het einde van het spoor door het DCC signaal in of uit te schakelen. Misschien niet de beste methode, maar wel de eenvoudigste.
(http://www.treinbaanrian.be/images/eindwerk/eindwerk%20brug%201.jpg)
Het voedingetje voor de elektronica op basis van 78xx voor 5 en 12 volt.
(http://www.treinbaanrian.be/images/eindwerk/eindwerk%20brug%202.jpg)
(http://www.treinbaanrian.be/images/eindwerk/eindwerk%20brug%203.jpg)
De 'brug' heb ik deze middag tussendoor in elkaar gestoken, het is de bedoeling dat hierop alle elektronica, het zenuwcenter van mijn systeem komt, het leek mij de ideale plaats. Het laat mij toe om evt onderdelen op de elektronica printen aan te wijzen voor op de verdediging aan de jury en zo de werking van de elektronica uit te leggen. Op de brug komt ook een systeempje waar ik mijn sensor aan kan monteren. Die 'kijkt' of er geen trein op het spoor staat. De drylin glijlagers zijn ook al gemonteerd, maar moet nog wat uitlijning aan gebeuren, het loopt nog niet soepel genoeg, daarom staan ook de 3 vijzen nog wat losjes. De multiplex plaat komt niet tot aan het einde van het frame, omdat ik een systeem heb bedacht om de sporen exact uit te lijnen, zodat heel nauwkeurig met de rand van de plaat evenwijdig kunnnen gelegd worden. Dat bespaart wat werk in het programma omdat de afstand tot het spoor bij het op en afrijden nu gelijk zal zijn.
(http://www.treinbaanrian.be/images/eindwerk/eindwerk%20brug%204.jpg)eem
Heb vandaag mijn L 6208 op zijn printplaatje gesoldeerd, samen met de extra onderdelen voor de sturing van de stappenmotor. Ik moet nog eens uitgebreider testen, maar de motor levert al zijn houdkoppel bij stilstand...
Alles is ingeladen om morgen te vertrekken naar school. Opendeurdag in OLVTD Zeebrugge, ploegstraat 38 komend weekend ZA&Zondag, van 14h-17h30. Iedereen die geïnteresseerd is mag langskomen. Als je mij zoekt, vraag één van de leerkrachten de weg naar klas 6Tiw in lokaal D204.
Veel succes gewenst !!!
dank u...
pff pff pff
even het stof van dit topic blazen. Wie tijd teveel heeft:
https://www.dropbox.com/s/49glx0i09jh33pp/dossier.pdf (https://www.dropbox.com/s/49glx0i09jh33pp/dossier.pdf)
Lijkt mij een heel tof eindwerk.
volgens mij is dit heel "simpel" te doen met een arduino, met simpel bedoel ik natuurlijk dat het meeste al bestaat en het warmwater niet opnieuw moet uitgevonden worden.
ivm de locs besturen, je kan de locs digitaal laten toekomen, vanaf een bepaald punt neemt de arduino over en stuurt de locs analoog.
Bij het buiten rijden gaat het terug van analoog naar digitaal.
Dit is natuurlijk niet zo exotisch als oplossing, maar wel een simpele oplossing.
Ik heb het bewust zo simpel mogelijk gehouden, en daarvoor onderbreek ik gewoon de stroom per spoor met een relais en microcontroller (beetje zoals je voorstelt met arduino, maar dan met een PIC 16f887)
(http://treinbaanrian.be/images/eindwerk/IMG_0190.JPG)
Hier komt het centrale brein op van m'n eindwerk, samen met twee bezetmelders (een voor het inrij, en het andere voor het uitrijspoor voor/na de fiddle yard) links en boven, aansluiting met andere elektronica edm, sub d stekker rechts voor lcd display evt.... Ik heb voor elk pinnetje van m'n µc een connector voorzien, de meeste zijn al bezet, maar als ik nog iets moet bijvoegen is dat makkelijk gedaan. Een probleempje, het printje is nog niet voorzien voor ICSP, maar wou dat printje niet volledig herwerken. Ik plan toch om nog eens een apart programmeerbordje te maken...
pff pfff pfff, nogmaals het stof wegblazen. Doorheen de vakantie af en toe wat verder gedaan aan m'n eindwerk. Het printje die de sturing verzorgt getekend en geëtst zoals je kunt zien in de vorige post, en al wat begonnen met programmeren. Er begint eindelijk een héél klein beetje licht aan het einde van een tunnel te komen. Er zal nog zeker wat werk zijn, maar dat komt in orde denk ik.
Verder vandaag op gaatjesprint een connector en IC-voetje gesoldeerd om een programmeerbordje te bouwen zodanig dat ik dit en een ander project nog kan programmeren, zonder de prints van een connector te moeten voorzien.
Voor m'n stappenmotor moet ik nog een 12V voeding maken, omdat m'n huidige motor volgens mij niet sterk genoeg is moet ik uitkijken naar een sterker exemplaar. Een 7812 zal dus niet voldoen denk ik. Overstappen op SMPS? Hoe begin je aan zoiets?
Citaat van: conducteur op 12 augustus 2013, 22:00:32 PM
Voor m'n stappenmotor moet ik nog een 12V voeding maken, omdat m'n huidige volgens mij niet sterk genoeg is moet ik uitkijken naar een sterker exemplaar. Een 7812 zal dus niet voldoen denk ik.
Er bestaan ook nog "zwaardere" 12Volt-stabilisators:
LT 1085-12 = 3 Ampère
LT 1084-12 = 5 Ampère
LT 1083-12 = 7.5 Ampère
Alledrie low-drop (1 volt), dus een 9 Volt transfo en brugcel is al genoeg ;)
Of een 78S12, die kan 2A aan.
Zal ik eens naar kijken :)
De rest van deze connectoren die ik gekregen heb zijn verkocht voor elk aannemelijk bod. Ik heb een plank gezaagd waar alle module's opkomen zodat ik mooi de onderlinge verbindingen kan maken, en die 'naar buiten', en het is een ramp om deze aan te sluiten.
In het vervolg enkel nog 'verticale' zoals de zwarte, geen van die groene meer. :( Vervangen? Of zijn er minder ingrijpende oplossingen? Ofwel zit de plaat in de weg, ofwel zitten andere module's in de weg. Ik heb nog wat materiaal gekocht bij conrad om dit netjes te bekabelen, samen met wat kabelgoten, die goten moeten nog nageleverd worden, dat zal voor na het weekend zijn denk ik, die zullen ook vreselijk in de weg liggen voor die groene ondingen :(
(http://www.treinbaanrian.be/images/eindwerk/schroefconnectorhorizontaal.jpg)
PS: Wie volgt de bouw van mijn project nog? In de laatste 15 berichten zijn er 10 van mij... Ik weet dat de materie niet zo simpel is, maar als je een vraag hebt, twijfel niet van die te stellen!
Wees gerust, Rian.
Ik volg van nabij !
Maar heb tot nu toe weinig zinvolle inbreng, dan enkele stevige aanmoedigingen !
Die groene connectors lijken me voor dit geval inderdaad niet de juiste keuze, alhoewel ze als connector zeker kwalitatief ok zijn.
Benieuwd naar de software, en natuurlijk ook het eindresultaat ;)
Ik had dit stukje forum nog niet gezien, maar nu wel en ga het eens doornemen van t begin. De techniek interesseer me zeer zeker.
wees gerust Rian, we volgen!
ge zijt goe bezig... doe zo voort!
Ik blijf je ook volgen.
Geert
Rian,
Ook hier: ik blijf volgen (al moet ik toegeven dat ik nog twee pagina's moest inhalen :-[ ).
Het is wel even verschieten als je je naam zit staan in het woord vooraf van je lijvig dossier :) .
Wat je connectoren betreft: ik gebruik graag veerklem. Bij conrad 748847 (5mm) en 732134 (2.54mm)
=> Iets duurder, maar geen schroevendraaier nodig, geen platgeknepen draden, en je kan de klemmen vanuit verschillende hoeken openen ;)
CiteerPS: Wie volgt de bouw van mijn project nog? In de laatste 15 berichten zijn er 10 van mij... Ik weet dat de materie niet zo simpel is, maar als je een vraag hebt, twijfel niet van die te stellen!
Ik volg het nog en wacht op de eerste trein.
Citaat van: PeterC op 18 augustus 2013, 09:27:01 AM
Het is wel even verschieten als je je naam zit staan in het woord vooraf van je lijvig dossier :) .
Jullie hebben me toch allemaal wel wat geholpen, en iedereen die mij geholpen heeft moest in dat rijtje staan...
Vanmiddag (een deel van) die groene dingen te lijf gaan met desoldeerlint en soldeerbout...
M'n voorraad van 3 polige schroefklemmen is blijkbaar vrij beperkt, dus maandag naar de winkel erom.
@ Gerolf: Ik heb hier zo'n decoder tester van esu, om decoders te testen voor inbouw of ze wel werken. Daar zitten aansluitklemmen op met veerklemmen. Vind dat nogal een gepruts om daar een draad in te krijgen, en je moet opletten dat je het hendeltje dat je moet induwen niet plooit. Tenzij die van jou van betere kwaliteit zijn?
Wat lees ik daar , desolderen en nieuwe kopen :o
Vergeet het ik stuur je er op. Ik heb er hele dozen vol van. Als ik daar een student mee kan helpen, graag...
(http://users.telenet.be/RedDeBist/MBAAN/connectors.JPG)
stuur PM
Geert
Geen idee welke connectoren op die decodertester zitten, maar diegene die ik noemde zijn degelijk - bij normaal gebruik ::) ;)
Update:
Deze avond de keukentafel ingepalmd om wat beneden te werken, ipv boven alleen aan m'n bureau...
Toch al een kleine mijlpaal, nu de verschillende modules bij elkaar komen:
Linksboven: relaiskaart, deze 8 relais onderbreken de DCC spanning, 1 relais per spoor. Als de trein op het einde van het spoor is zal het relais uitgeschakeld worden en zal de trein stilvallen. De relais worden gestuurd vanuit het stuurkaartje.
Rechtsboven: het brein achter m'n systeem, het bordje met de pic 16f887. Hier komen alle signalen toe van drukknoppen, schakelaars, sensoren en zullen verwerkt worden door de microcontroller. Die zal dan de passende uitgangen aansturen, zoals de uitgangen die verbonden zijn met het relaiskaartje bv.
Linksonder: simpele 78xx voeding. Deze zet de wisselspanning uit de transformator om in 12V en 5V gelijkspanning voor de elektronica in het systeem.
Rechtsonder, onder het koelblok zit de driver voor de stappenmotor. Deze zet een kloksignaal om in de juiste signalen voor de stappenmotor. Een puls van de klok doet de motor 1,8° draaien. (ik ben btw nog op zoek naar een motor Nema 23 met een groter koppel dan 0,5 Nm). Afhankelijk van het richtingsignaal zal de motor links of rechtsom draaien. Deze twee signalen komen ook van de microcontroller.
(http://www.treinbaanrian.be/images/eindwerk/bedradingelektronica.JPG)
Ik doe m'n best om zo netjes mogelijk en zo goed mogelijk kabeltjes te leggen. Ik gebruik hier 0,5mm² VTB kabel. Ik heb toch een eindje moeten zoeken om 0,5mm² kabel te vinden, tot in Brugge in de Brico...
Ik heb zelf m'n logica opgebouwd om m'n kabels te nummeren. Hiervoor gebruik ik nummertjs uit een setje, gekocht op conrad. (art 540504 - 89), ook de kabelgoten komen van daar. Ik moet eens zoeken waar ik navullingen voor die dingen kan kopen, zonder weer zo'n set te moeten aanschaffen want m'n nummertjes 5 bv zijn bijna op, terwijl ik er van 7-8-9 nog geen heb gebruikt.
Op de foto het stuurkaartje met de PIC, waarvan ik de groene connectoren vervangen heb door de grijze:
(http://www.treinbaanrian.be/images/eindwerk/kabelnummeren.JPG)
Voila, en nu jullie talrijke reacties afwachten...
En als ik het nu goed begrijp, beweegt de stappenmotor al of moet je een andere stappenmotor hebben die volgens jouw logica op het bord werkt?
Het stuurkaartje zelf werkt, dat hebben we op school getest. Nog niet getest met de microcontroller, daarvoor moet ik het programma nog schrijven (aansluiting 20/21 zorgen voor de verbinding met het driver ic voor de motor). Echter de motor, die ik van de leerkracht mechanica cadeau gekregen heb is belange niet sterk genoeg...
Edit: een poging om m'n codeersysteem uit de doeken te doen:
Het eerste cijfer 'groepeert' de draden een beetje.
De in en uitgangen op een microcontroller zijn verdeeld in groepen. Die groepen noemt men 'poorten'. Er zijn vijf poorten op mijn microcontroller.
Is het eerste cijfer 0 dan is die draad verbonden met poort a op de microcontroller. Is het een 1, dan is die verbonden met poort B. Zo tot poort E die het cijfer 4 krijgt.
Groep 5 bevat alle 'stroomvoerende' draden. (0V,5V,12V,16V AC uit transformator, DCC signaal...) 56 is bv een van de twee draden van het dcc signaal.
..en de rest moet ik nog wat uitzoeken...
Citaat van: conducteur op 20 augustus 2013, 23:40:48 PM
Het stuurkaartje zelf werkt, dat hebben we op school getest. Nog niet getest met de microcontroller, daarvoor moet ik het programma nog schrijven (aansluiting 20/21 zorgen voor de verbinding met het driver ic voor de motor). Echter de motor, die ik van de leerkracht mechanica cadeau gekregen heb is belange niet sterk genoeg...
En vervolgens is mijn constatatie dat je een andere motor nodig hebt juist. :D
'k Vind het erg knap wat je allemaal op elektronisch vlak kan Rian. Ik spring hier al een gat in de lucht na het succesvol digitaliseren van een loc met inbouw van andere verlichting.
Groet,
Olivier
In de PIC 16F887 zit hardwarematig een module om stappenmotors aan te sturen. Enkel de vermogen transistors (FET's) moet je zelf toevoegen.
Die kabel nummers, ik denk dat ik deze ook ergens heb liggen. Ik voeg ze wel bij de beloofde connectors enz...
Geert
Citaat van: Geert op 21 augustus 2013, 00:39:55 AM
In de PIC 16F887 zit hardwarematig een module om stappenmotors aan te sturen. Enkel de vermogen transistors (FET's) moet je zelf toevoegen.
Zeg dat dan wat eerder he, heb tamelijk wat moeite moeten doen om dat printje werkende te krijgen...
Zelf heb ik deze module pas leren kennen om digitale signalen op te wekken voor lok's. Toen had jij al een speciaal IC aangeschaft. ;)
EDIT: zie capture/compare/pwm module....
Geert
Inderdaad, gevonden in de datasheet. Maar voor dit project blijf ik bij de l6208...
CiteerIn de PIC 16F887 zit hardwarematig een module om stappenmotors aan te sturen. Enkel de vermogen transistors (FET's) moet je zelf toevoegen.
Dat is wat die L6207 doet: vermogentrap met stroomregeling, stroombeperking, temperatuurbewaakt etc.
Text update:
Vandaag vastgesteld dat m'n rol witte draad op is, dat wil zeggen dat er al 10m witte draad in dit project steekt :o
Nu wachten op Geert z'n schatten, dan kunnen we verder met de bekabeling...
Nu eens een 'constructiefoutje rechtzetten'... Het is nogal een vrij destructieve/ingrijpende maatregel, maar hoop dat ik daar die paar mm speling mee kan wegwerken. Straks update met foto's van het probleem en de vooruitgang van de werken....
Edit: grondige uitleg van dit probleem vereist beelden:
(http://www.treinbaanrian.be/images/eindwerk/probleemspeling.JPG)
Deze stapel van glijlager-lagerblok-houten balk-plaat-sporen is letterlijk een opstapeling van problemen.
1) De ondersteuning ligt een 30 cm van het uiteinde van de plaat, dat geeft problemen om die laatste 30 cm te ondersteunen. In het midden ligt die balk daarvoor, maar aan de uiteinden gaat dat moeilijker.
2)Graag had ik over de ganse lengte één latje gevezen voor extra stevigheid. Dat gaat nu niet.
3)Op een of andere beistere reden zit er nogal wat speling tussen de houten balk en het glijlagerblok.
Resultaat na even werken, grove middelen gebruikt:
(http://www.treinbaanrian.be/images/eindwerk/spelingdemontage.JPG)
1) Het plan? De twee aluminiumprofielen waar elk van de glijlagers op rust is 45*45mm groot, die worden elk vervangen door een profiel van 45*90mm dat rechtop staat. Geen last meer van houten balken die speling veroorzaken. Voor zij die nog niet zolang m'n project volgen, die profielen haal ik bij 'Alumes', een bedrijfje in Dadizele. (www.alumes.be) Ik wacht een antwoord af van hen ivm m'n e-mail voor deze bestelling.
2)De profielen van 45*90 komen zo dicht mogelijk bij de uiteinden te staan. Dit laat me toe een veel groter stuk te ondersteunen.
3)Van de situatie gebruik maken, heb ik gebeld met de verkoper van de glijlagers. Nu zitten er 4 vaste lagers onder, wat erg stroef loopt, omdat dat heel moeilijk uit te lijnen is. Hij ging wat opzoekwerk verrichten wat het mij zou kosten om twee losse en twee vaste lagers te nemen. Het is allesinds mogelijk om dat om te wisselen zonder nieuwe 'rails' te moeten kopen, want die hebben me véél gekost...
4)Terwijl ik bij IGUS dingen moet aankopen, eens kijken wat kabelrups kost. Moet dat nog eens bekijken, maar mogelijk gebruik ik dat om proper te werken...
als je dan toch graag reacties hebt op je onpopulaire draadje... :)
Je rails staan op een alu constructie en je glijlagers op een houten constructie. Dat kan NOOIT goed blijven gewoon door de verschillende uitzetting bij temperatuurschommelingen. Ofwel alles op alu, ofwel alles op hout.
Maar vooral nooit de moed opgeven! Al doende... ;)
Blij dat iemand mijn link gevonden heeft. Je moet eens teruggaan in dit draadje en kijken hoeveel keer ik 3 berichten na elkaar iets schrijf zonder enige vorm van antwoord. Als je daar echt geen respons op krijgt denk je dat niemand je volgt... :D
Het zal inderdaad een grote verbetering zijn, als de plaat direct op de glijlagers gemonteerd is. Bij Alumes ga ik nog eens moeten bellen, want van hen hoor ik niets, losse glijlagers en rups heb ik ondertussen besteld, en ga dat direct betalen!
Citaat van: conducteur op 27 augustus 2013, 15:18:59 PM
Blij dat iemand mijn link gevonden heeft. Je moet eens teruggaan in dit draadje en kijken hoeveel keer ik 3 berichten na elkaar iets schrijf zonder enige vorm van antwoord. Als je daar echt geen respons op krijgt denk je dat niemand je volgt... :D
ge moet gene schrik hebben... Big brother is watching you... ;)
:D Nu afwachten op Geert z'n schatten uit z'n schof die hij me opgestuurd heeft, wachten tot ze bij Alumes bijten en levering van Igus afwachten... En dan kunnen we verder denk ik?
Ik was net nog eens aan het nalezen wat je allemaal nog te goed hebt zoals beloofd. Ik had al draadnummers en printconnectors opgestuurd. (Morgen of overmorgen komen ze aan) Op één van de foto's zag ik 2 polige printconnectors staan en heb er daar van opgestuurd. Nu lees ik nog eerder in dit draadje dat je 3 polige printconnectors nodig hebt :o. Heb je deze dringend nodig of gaat dat ook met 2 polige ?
Nog een vraagje, moet jij je G.I.P. nog verdedigen binnenkort? Zo ja dan ben je er wel laat mee begonnen ...
Geert
GIP verdediging is al lang gedaan eind juni, in Industriële Wetenschappen moest ik enkel een theoretisch werk maken. De jury was aangenaam verrast van m'n enthousiasme en manier waarop ik de technische kant van het verhaal uit de doeken gedaan heb... Ik ga eens kijken op de facebookpagina van de school, er staan filmpjes op van de gip verdediging (ook van richtingen bouw/sanitair/elektriciteit-elektronica, en ik geloof dat ik in een van die voorkom. Eens kijken of ik die hier krijg...
De realisatie was een eigen keuze/geen verplichting en moest niet perse 'af' zijn voor de jury, daarom heb ik in mei bijna geen energie gestoken in de realisatie, wel in m'n bundel waarvan de link hier ergens in het draadje staat. Die werk ik nu op m'n gemak af zonder enige vorm van verplichting wanneer iik tijd en goesting heb in de hoop dat het systeem 'ooit' eens zal werken.7
Wat die 3-polige connectoren betreft, geen erg, de enige die ik niet heb kunnen vervangen omdat de voorraad op was is eigenlijk 'optioneel'. Als het systeem ooit werkt bouw ik die optie misschien in in het programma...
Hier de klasgenoten uit Elektromechanica en elektriciteit elektronica
https://www.facebook.com/video/embed?video_id=538840206177304 (https://www.facebook.com/video/embed?video_id=538840206177304) (ik hoop dat dit wat zichtbaar is...)
Hier op 3:44 en 5:27 kom ik even in beeld, weerom, de video's staan niet op youtube, dus mogeijk geeft dat problemen:
https://www.facebook.com/video/embed?video_id=538894122838579 (https://www.facebook.com/video/embed?video_id=538894122838579)
Rian het wordt wel gevolgd hoor, ik was enkel de interesse een beetje kwijt door dat het de laatste pagina's heel wat noodzakelijk technisch gekeuvel is en ik daar niet zo sterk in ben, maar ik wacht, tot het schaduwstation werkt en volg dus ook wel als je wat nieuw post. ;)
Ik volg het ook met veel interesse, maar ik ben technisch niet voldoende onderlegd om er op te reageren.
Hier hetzelfde. Ik volg wel, net als zoveel topics, maar echt reageren doe ik niet omdat ik ofwel er geen kennis van heb ofwel nog te onervaren ben omtrent het onderwerp ;D
En reageren om enkel maar wauw en ohh te zeggen doe ik niet graag, dat doen andere wel :P
mooi om volgen , wel met veel interesse helaas is mijn technische bagage wat dit betreft echt wel onvoldoende. Spijtig :(
Daarom geen reactie om ook geen domme dingen uit te kramen ! Dat zullen anderen wel doen ;)
Blij dat zoveel interesse getoond wordt! Ondertussen heeft Alumes 'gebeten'. Even geduld dus tot alles dat ik nodig heb toekomt per post! Ik zet alvast m'n bed bij de deur en de brievenbus! ;D
Beste zou zijn als je de plaat maar langs 1 kant vastzet op de glijblokken en de andere kant enkel ondersteunt met de glijblokken. Dan kan de plaat en het frame onafhankelijk van elkaar werken. Tenzij beide in hetzelfde materiaal zijn ga je dat zeker nodig hebben. En dan nog, als je 2 alu frames neemt en op 1 ervan een houten plaat vijst, dan gaat die krom genoeg trekken om met zo'n glijlagers problemen te geven. Ik veronderstel dat dat is wat je met je losse glijblokken van plan bent.
Om je plaat voldoende te ondersteunen moet je eens kijken hoe "marmers" ondersteund worden. Dat zijn die grote stenen blokken die ze als referentievlakken gebruiken om zaken op te meten. Die worden op specifieke punten ondersteund om de doorbuiging te beperken: Airy points (*). Soms worden ook Bessel points gebruikt.
(*) heel eigenaardig, maar enkel in het engels vind ik er iets over. Kennelijk meten ze in het nederlands niet zo nauwkeurig :D
en nu een beetje reageren op dat van Johan ;)
Ik zou alu op alu nemen en de houten plaat vlottend vastmaken. Nu, als dat een beetje kromtrekt, is het geen ramp want het is een systeem om treintjes te verplaatsen. Geen CNC op 0,01mm nietwaar? ;)
en Rian, heb je nu al je spindel gemonteerd? :)
Dat is ook een optie, Dirky. Rian doet inderdaad geen CNC op 0.01mm maar die glijlagers zijn wel voor zo'n toepassingen gemaakt. En daar wringt het nietwaar. :D Gewone geleiders voor schuiven zouden die problemen niet geven.
Wie technisch tekenen gehad heeft moet weten dat je altijd "vrije" maten moet hebben. Anders is het stuk niet te maken.
Daarvoor schakel ik nu over op de losse glijlagerblokken, die hebben een halve mm speling tov de as...
Die moeten dus dergelijke fouten ivm uitzetten, krimpen, uitlijning compenseren...
Op de linkerrail twee vaste lagers (die héél nauw aansluiten op de rail), rechts twee losse lagers.
Schuifgeleiders? Ik denk dat de leerkracht mechanica eens goed ging lachen met me, niet de bedoeling dus.
Eens dit probleem aangepast is, ook eens de montage van de spindel herbekijken...
Citaat van: Havoc op 27 augustus 2013, 21:05:41 PM
Wie technisch tekenen gehad heeft moet weten dat je altijd "vrije" maten moet hebben. Anders is het stuk niet te maken.
Nu je het zegt, waar is de tijd... ;D ;D
Geert
(http://i836.photobucket.com/albums/zz286/Dirky/20101116006_zpsee93aa46.jpg) (http://s836.photobucket.com/user/Dirky/media/20101116006_zpsee93aa46.jpg.html)
Dit is, was, de tafel voor wat ooit een CNC frees moest worden. Ook met Igus materiaal maar alles op aluprofielen gebouwd. Ik heb de tafel jaren als manuele freesmachine gebruikt en alles liep spelingvrij.
Wil ik maar zeggen: "juist op juist past ook" ;)
Vrije maten zijn inderdaad belangrijk maar toleranties op maten zijn noodzaak!
Hoe zit die lange as helemaal rechts gelagerd?
Rechts zat die in een gewone lager. Links werd de spindel gelagerd met een "koppel" lagers. Juiste naam in 't Vlaams weet ik niet... :)
Links zit de aandrijving, rechts, heb je daar de schroefdraad zo laten zitten en dat in het lager 'gestoken'?
Edit: pech: het zal niet gaan zonder extra draaiwerk :(
xx03 lagers zijn 17mm diameter en xx04 20mm, m'n as 18mm (TR18x4), tenzij ik ergens een lager vind dat afwijkt van die standaardafmetingen...
Rechts is minder belangrijk en zit dus idd met de schroefdraad in het lager. Hier was het wel diameter 20...
Voor jou zal de goedkoopste oplossing een ringetje zijn met 18 binnen en 20 buiten. Kan gewoon in kunststof gemaakt worden. Misschien zelfs een stuk PVC electrobuis van 20mm ???
Geert Z'n schatten zijn toegekomen :D
CiteerSchuifgeleiders? Ik denk dat de leerkracht mechanica eens goed ging lachen met me, niet de bedoeling dus.
Als hij met jou lacht en niet de problemen die je nu tegenkomt voorzien had (en je dus gewaarschuwde) dan is hij niet echt de man om naartoe te gaan voor mechanische problemen.
Bepaalde mensen gaan soms op 'schattenjacht', maar hier komen de schatten gewoon toe in een grote bruine envelop. Vandaag is een 2de zending van Geert toegekomen, waarvoor dank!
Wachten, Wachten tot alles binnenkomt wat besteld is, dan kan ik voortwerken aan het project.
Vandaag een doosje van IGUS ontvangen (losse glijlagerblokken, kabelrups).
Dit ook nog aangekocht, nog even geduld voor ie thuis staat.
(http://goovercnc.be/images/CNC460%20Large.jpg)
Wat een gerief en wat voor elektrische begrippen waarvan ik niks van weet. Ziet er wel goed uit.
Rian,
Niet geheel wat je gekocht hebt. :P
De jouwe is met een watergekoelde 1.5kw HF spindel.
De getoonde cnc router heeft een 240W luchtgekoelde spindel.
Je bent dus klaar voor de toekomst.
Grtjs,
David
Nog beter dus :D
(http://www.treinbaanrian.be/images/eindwerk/serieklemmen.JPG)
We doen rustig verder aan dit project. De plaat zal ik moeten wat groter maken, want die was niet echt voorzien om met die klemmen te werken.Ik had die overwogen, maar de prijs (1€/stuk *40) was wat teveel. Het alternatief dat ik had was echter nogal prutswerk. Gelukkig heb ik een groot deel van die klemmen cadeau gekregen... Ik hoop morgen dus nog eens te kunnen 'zagen', zodat ik plaats kan maken voor de kabelgoot die aan de voorkant van de klemmen moet komen. Dan kan ik oa die vrijhangende lussen mooi wegwerken...
Er zijn van die doorverbindingenstroken die je in het midden van je klemmenstrook kan vijzen zodat je de rode en blauwe kabels aan de voorzijde niet hoeft te bekabelen.
Geert
Weet ik, maar met wat restjes kabel lukt dat ook, en die goot moet er toch komen voor de bekabeling richting motor, optische sensor, richting de sporen....)
En je moet die vinden, hier in de buurt vind ik niet direct een zaak die veel elektrotechnisch installatiemateriaal verkoopt...
De din-rail gevonden in een plaatselijk doe het zelf zaakje, maar veel voorraad was er niet, vanmiddag gekeken in de stock-americain vermeersch, daar heb ik die verbindingstroken niet gevonden, verkopen wel din-rail klemmen, maar de voorraad was beperkt tot 10 stuks... (geen gekocht...)
De kabelgoten komen van conrad, die vind ik ook niet direct hier in de regio...
Om terug te komen op de verbindingsstroken: de linkse zijn die die ik van je heb gekregen, en die gebruiken een heel ander systeem om doorverbindingen te maken dan de rechtse, die ik van school nog gekregen had tijdens het schooljaar...
Eindelijk heeft alumes geleverd, toch een héél klein beetje positief nieuws vandaag, want mama ziet het niet langer zitten om tot maandag te wachten, het zou vanavond doorgaan :'(
Veel sterkte man!
#include <htc.h>
// Config: HS ext Xtal- Watchdogtimer disabled - LVP Disabled
__CONFIG(FOSC_HS & WDTE_OFF & LVP_OFF);
#define _XTAL_FREQ 20000000 // freq voor delay
void main()
{
unsigned char i; //variabele i
unsigned char teller; //variabele teller
teller=1; //startwaarde telle =1
TRISA = 0x00; //config poort als output
TRISB = 0xFF; //config poort als input
TRISC = 0x00; //config poort als output
for(i=1;i<4;i++) //test relais inrijspoor c6 lus 4 maal herhalen
{
PORTC = 0x40; //C6=1
__delay_ms(250); //wacht 250ms
PORTC = 0x00; //relais terug uit
__delay_ms(250);
}
TRISD = 0x00; //config poort output
for(i=1;i<10;i++) //test relaiskaart
{
PORTD = teller; // hiermee wordt elk relais apart aangestuurd voor 500ms
teller=teller*2+1;
__delay_ms(500);
}
TRISE = 0xFF; //port E is input
for (; { // loop forever
;
}}
Het eerste C-programma is een feit, testje of de relais correct aangesloten zijn en werken... Er zit gelukkig slechts één koppig relais tussen dat niet wil werken, maar dat komt in orde!
Dat is zeker het laatste relais dat niet wil werken? :D
for(i=1;i<4;i++) telt nl 1,2,3 en stopt... Dus je lus loopt maar 3x en geen 4x. Je gaat dat dikwijls voorhebben en het heeft zelfs een naam: fencepost error.
- ofwel begin je te tellen bij 0
- of je test <=4
- of je test <5
- of je gebruikt een while do
Nee, ik heb één relais op het printje met de µC aan te sturen met c6, die gaat een paar keer aan en uit, en dan heb je de 8 relais (D0-D7) op het relaiskaartje... die gaan elk om buurt eens aan... 't is één van die laatste die het niet doet.
Er moet een slechte soldering zitten op de transistor van dat relais. Als je hem een duwtje geeft schakelt het relais...
Edit: alle 9 relais werken zoals het moet! Volgende dat ik probeer is de stappenmotor een paar toertjes te laten draaien... Nu opruimen, nog wat tv kijken en dan gaan slapen, moet morgen vroeg opstaan want het uurrooster is veranderd waardoor ik maandag vroeg moet beginnen op school...
Op C0 moet het signaal kome die naar de stepper driver gaat om L/R te draaien. Op C1 het kloksignaal, om eventueel met PWM dat op te wekken, maar dan moet ik zien het aantal pulsen te tellen...
In de Cursus C van vorig jaar staat dat je zo één bitje kunt setten, maar bij mij werkt dat toch niet? Ik moet 1 of 0 uit die ene poort krijgen?
unsigned char richting; //richting bevat het getal 1 of 0, 1 is wijzerzin 0 tegenwijzerzin...
PORTC= richting;
PORTC=PORTC|0x08;
Rian,
gebruik je de PIC16F887?, dan is C2 de uitgang van PWM!
Dat tellen van het aantal pulsen die de PWM uitstuurt is vrij eenvoudig. Elke keer dat deze start met een puls, zal deze een ISR oproepen waarin geteld wordt. Wil je geen pulsen meer uitsturen, dan kan je in het ISR voorzien dat de PWM stopt.
Hoe dat zit met C om een poort aan te sturen weet ik niet...
Geert
Als je 0 of 1 in een unsigned char steekt staat er 0b00000000 of 0b00000001 in. Dan een bitwise OR doen met 0x08 = 0b00001000 geeft volgens mij 0b00001000 of 0b00001001. Dus voor de L/R in te stellen met de laagste bit lukt dat, voor pulsen te genereren niet.
Ik denk dat je het schema van wat er bestuurd moet worden me dat voorbeeld programma er moet bijhalen. Als dat een stepperdriver is die zelf de pulsen genereert moet je inderdaad enkel een richting instellen, niet pulsen. En om een of andere reden zal het vierde bitje altijd 1 moeten zijn vandaar de bitwise OR.
Citaat van: Geert op 23 september 2013, 10:21:47 AM
Rian,
gebruik je de PIC16F887?, dan is C2 de uitgang van PWM!
Dat tellen van het aantal pulsen die de PWM uitstuurt is vrij eenvoudig. Elke keer dat deze start met een puls, zal deze een ISR oproepen waarin geteld wordt. Wil je geen pulsen meer uitsturen, dan kan je in het ISR voorzien dat de PWM stopt.
Hoe dat zit met C om een poort aan te sturen weet ik niet...
Geert
Ga dat eens moeten nakijken, of de klok weldegelijk aan C2 hangt. Tof te weten dat het alvast mogelijk is pwm pulsen te tellen.
@Johan: heb wat te letterlijk gekopieerd uit de cursus, je moet het uiteraard met 0x01 doen...
Wat is de frequentie van die pulsen?
Zal anders is een voorbeeldje schrijven in ASM, kan je zelf omzetten naar C code.
Geert
400hz (2tr/s) was het maximale die ik uit de motor kreeg tijdens testen op school, daarna bleef ie resoneren en andere rare dingen doen...
Wat ik niet snap.... waarom al dat moeilijk gedoe met pwm en met pulsen tellen en frekwenties en assembler programmatie en zo ?
Ik heb een paar routinekes geschreven in C (eentje voor vooruit, eentje voor achteruit) waar je een parameter kan mee geven en die dan de servo motor aanstuurt volgens jouw bevel...
Eigenlijk zijn het 4 routines, want ik heb er ook 2voor "half pulse" waardoor je meer koppel ontwikkelt op de as van de stepper en nog nauwkeuriger kan sturen.
De parameter die je meegeeft is gewoon het aantal milliseconden dat de controller wacht tussen het geven van 2 pulsen, dus eigenlijk een soort frekwentiebepaling.
gebaseerd op dit artikel is dat een "fluitje van een cent".
http://zone.ni.com/devzone/cda/ph/p/id/247
en het bestaat ook voor bipolaire
http://users.ece.utexas.edu/~valvano/Datasheets/StepperHalfstep.pdf
Misschien heb je er wat aan, het is platform-agnostisch :-) :-) :-)
Ziet er zeer interessant uit, Dani, maar heb niet echt door wat je probeert duidelijk te maken. Mijn motor hangt aan de 'L6208', die genereert de stapsequence en stuurt een H brug van Mosfets aan op basis van een kloksignaal en een richtingssignaal... Dan moet ik toch ergens een kloksignaal genereren en tellen? Hoe weet ik anders dat ik 200 stappen verwijderd ben van m'n beginpunt en er bv nog 2000 moet doen?
Elke aanpak heeft zijn voordelen. Die van Rian heeft stroomregeling, beveiliging en moet zich niets van de sequentiegeneratie aantrekken. De aanpak van Dani is simpel en weet direct waar alles is (als er geen slip is).
M'n programmer ligt klaar, MPlab opgestart nu de code nog. Ik wil eens uitzoeken hoe ik m'n stappenmotor kan aansturen met de pwm functie, waarbij ik het aantal pulsen van de pwm test.
PWM functie aansturen in C en dan ook tellen, waar vind je de commando's daarvoor? In de datasheet van de µC?
Citaat van: conducteur op 19 oktober 2013, 19:17:41 PM
...Ik wil eens uitzoeken hoe ik m'n stappenmotor kan aansturen met de pwm functie, waarbij ik het aantal pulsen van de pwm test.
PWM functie aansturen in C en dan ook tellen, waar vind je de commando's daarvoor? In de datasheet van de µC?
Rian, waarom PWM??? Je stuurt je motor met een L6208. Die moet enkel pulsen krijgen (1 puls per stap, 2 pulsen indien half-step).
Ik zou als volg te werk gaan: eerst je maximum step-frequentie van je motor bepalen. Een timer van je controller op de dubbele frequentie instellen (zo krijg je een mooi symmetrisch signaal). Interrupts uit.
Er moet 'gestapt' worden: een variabele (byte = 256 stappen, word = 65536 stappen, long word = ... stappen) bevat het aantal uit te voeren stappen. Interrupt enablen.
Bij het 'afgaan' van de timer een interrupt genereren.
In de interruptroutine de uitgang naar je clock van je L6208 inverteren en je 'telvariabele' met 1 verminderen indien je de clock van 0 naar 1 hebt gezet. De 'telvariabele' testen of deze 0 is. Indien niet: gewoon terugkeren van je interrupt. Indien 0: de interruptroutine zelf zijn interruptenable laten uitschakelen en een vlagje zetten zodat je main-loop weet dat er niet meer wordt 'gestapt'.
Simpel uitgelegd ;)
Citaat van: PeterC op 19 oktober 2013, 20:01:10 PM
Citaat van: conducteur op 19 oktober 2013, 19:17:41 PM
...Ik wil eens uitzoeken hoe ik m'n stappenmotor kan aansturen met de pwm functie, waarbij ik het aantal pulsen van de pwm test.
PWM functie aansturen in C en dan ook tellen, waar vind je de commando's daarvoor? In de datasheet van de µC?
Rian, waarom PWM??? Je stuurt je motor met een L6208. Die moet enkel pulsen krijgen (1 puls per stap, 2 pulsen indien half-step).
Ik zou als volg te werk gaan: eerst je maximum step-frequentie van je motor bepalen. Een timer van je controller op de dubbele frequentie instellen (zo krijg je een mooi symmetrisch signaal). Interrupts uit.
Er moet 'gestapt' worden: een variabele (byte = 256 stappen, word = 65536 stappen, long word = ... stappen) bevat het aantal uit te voeren stappen. Interrupt enablen.
Bij het 'afgaan' van de timer een interrupt genereren.
In de interruptroutine de uitgang naar je clock van je L6208 inverteren en je 'telvariabele' met 1 verminderen indien je de clock van 0 naar 1 hebt gezet. De 'telvariabele' testen of deze 0 is. Indien niet: gewoon terugkeren van je interrupt. Indien 0: de interruptroutine zelf zijn interruptenable laten uitschakelen en een vlagje zetten zodat je main-loop weet dat er niet meer wordt 'gestapt'.
Simpel uitgelegd ;)
Ook een optie, maar m'n kennis van (de commando's in) C is nog erg beperkt. Waar vind je (een index) van de commando's nodig voor dit (en voorbeeldjes evt, voor die interrupts en timers?)
Rian,
Als mijn vermoeden juist is, werk je met Hi-tech C?
Kijk eens naar het voorbeeldje "C:\Program Files\HI-TECH Software\PICC\9.83\samples\TimerDemo\timer0.c".
Daar staat een interruptroutine op Timer 0.
Hier (http://www.pctoytoy.be/jal/16f684/16f684_3.htm) zie je een leesbaar voorbeeldje voor een Timer0 interrupt (welliswaar in JAL maar gemakkelijk om te zetten naar C).
Begin eenvoudig met een ledje te laten knipperen en breidt dan uit (eerst stappen dan pas lopen - in jou geval is dat stappen niet op je motor bedoeld ;) ).
ja! Ik ga dat eens bekijken!
Dit volgens ASM: init Pwm, init timer2 en init INT: (komt uit MM2 protocol generator)
;****************************************************
;******* INIT PWM (TIMER 2) ************************
;****************************************************
MOVLW b'00001100' ;PWM mode en start MM protocol generator
banksel CCP1CON
MOVWF CCP1CON
MOVLW .104 ;=208µs
banksel PR2
MOVWF PR2
MOVLW b'00000101'
banksel T2CON
MOVWF T2CON
;****************************************************
;******* INIT INTERRUPT ****************************
;****************************************************
banksel INTCON
movlw b'11100000'
movwf INTCON
banksel PIE1
movlw b'00000010'
;------1- enable Timer 2 interrupt
movwf PIE1
banksel 0
INTERRUPT:
;****************************************************
;****** DIT DEEL HEEFT TE MAKEN MET MM PROTOCOL *****
;****************************************************
ISR_SPR0 BTFSS PIR1,TMR2IF ;TIMER 2 INTERRUPT?
GOTO ISR_SPR50
BCF PIR1,TMR2IF
hier kan je pulsen tellen
Edit:verkeerde interrupt gebruikt
Geert
ASM ziet er complex uit ???
Citaat van: conducteur op 20 oktober 2013, 13:17:17 PM
ASM ziet er complex uit ???
Klopt, C doet dat ook zo, maar dat zie je niet ;)
Geert
Citaat van: conducteur op 20 oktober 2013, 13:17:17 PM
ASM ziet er complex uit ???
Vooral omdat je, telkens voor je naar een bepaald register schrijft of van een bepaald register leest, je je bank moet juist zetten (vandaar al die
banksel instructies).
In een hogere programmeertaal neemt de compiler je dat werk uit de hand. Het nadeel van een hogere programmeertaal is dat je niet direct weet hoelang een routine gaat duren. In ASM hoef je maar je instructies te tellen om de tijdsduur van je stuk code te berekenen.
Basis uitleg, en C code in volgende LINK (http://www.gooligum.com.au/tutorials.html). (ook gratis!)
De HI-TECH C is wel vervangen door zijn opvolger XC8 .
Geert
Voorlopig doe ik het op een wellicht iets minder katholieke manier, op een methode die ik zelf volledig begrijp en zelf weet hoe ik het moet schrijven:
#include <htc.h>
// Config: HS ext Xtal- Watchdogtimer disabled - LVP Disabled
__CONFIG(FOSC_HS & WDTE_OFF & LVP_OFF);
#define _XTAL_FREQ 20000000
void main()
{
unsigned char richting;
unsigned int positie;
unsigned int eindpositie;
int verplaatsing;
verplaatsing = eindpositie - positie;
if (verplaatsing < 0) {
richting = -1;
}
else {
richting = 1;
}
while (eindpositie != positie) {
TRISC = 0x00;
__delay_us(1250);
PORTC = 0XFF;
__delay_us(1250);
PORTC = 0X00;
positie = positie + richting;
}
while (1) {
}
}
Het is nog niet helemaal wat ik wil voor de test, morgen doen we verder (hopelijk).
In afwachting dat ik de timers & interrupts meester ben, een testprogramma geschreven (elk testprogramma bewaar ik zodat het eindprogramma gedeeltelijk knip en plakwerk wordt) maar het gedraagt zich erg gek:
#include <htc.h>
// Config: HS ext Xtal- Watchdogtimer disabled - LVP Disabled
__CONFIG(FOSC_HS & WDTE_OFF & LVP_OFF);
#define _XTAL_FREQ 20000000
void main()
{
unsigned char richting;
unsigned int positie;
unsigned int eindpositie;
int verplaatsing;
while(1){
TRISB=0xff;
switch (PORTB)
{
case(1): eindpositie=1000; break;
case(2): eindpositie=2000; break;
case(4): eindpositie=3000; break;
case(: eindpositie=4000; break;
case(16): eindpositie=5000; break;
case(32): eindpositie=6000; break;
case(64): eindpositie=7000; break;
case(128): eindpositie=8000; break;
default: eindpositie=positie;
}
verplaatsing=eindpositie-positie;
if(verplaatsing>0){
TRISC=0xfC;
if(verplaatsing<0)
{
richting=-1;
PORTC|=0x02; //c2=1
}
else
{
richting=1;
PORTC &=0xFD; //C2=0
}
while(eindpositie!=positie)
{
__delay_us(1250);
PORTC=0XFF;
__delay_us(1250);
PORTC=0X00;
positie=positie+richting;
}}
}}
De motor zou moeten een paar toeren draaien afhankelijk van welke knop ingedrukt was, maar voorlopig draait hij enkel vrolijk rondjes in een richting zonder dat je dat wil (draait niet soepel en maakt een hoop herrie) en als je ergens een metalen deel aanraakt stopt het (koelvinnen van voeding en l6208, motor zelf en gelaserde steun)
de laatste zinnetjes moet je wel iets meer verduidelijken. Ik kan even niet volgen.
En is dit geschreven voor een 16F887 PIC µC?
Geert
#include <htc.h>
// Config: HS ext Xtal- Watchdogtimer disabled - LVP Disabled
__CONFIG(FOSC_HS & WDTE_OFF & LVP_OFF);
#define _XTAL_FREQ 20000000
void main()
{
char richting;
unsigned int positie;
unsigned int eindpositie;
int verplaatsing;
while (1) {
TRISB = 0xff;
switch (PORTB) //Zoek welke knop ingedrukt was:
{
case (1):
eindpositie = 1000;
break; //ga naar 1000 stappen tov referentie
case (2):
eindpositie = 2000;
break; //ga naar 2000 stappen tov referentie
case (4):
eindpositie = 3000;
break; //ga naar 3000 stappen tov referentie
case (:
eindpositie = 4000;
break; //....
case (16):
eindpositie = 5000;
break; //...
case (32):
eindpositie = 6000;
break;
case (64):
eindpositie = 7000;
break;
case (128):
eindpositie = 8000;
break; //ga naar 8000 stappen tov referentie
default:
eindpositie = positie; //huidige positie=te bereiken positie --> geen verplaatsing
}
verplaatsing = eindpositie - positie; //bereken aantal te verplaatsen stappen
__delay_ms(500);
TRISC = 0xfC; //enkel C0 en C1 zijn output
if (verplaatsing != 0) //indien geen verplaatsing, onderstaande niet doorlopen
{
if (verplaatsing < 0) {
richting = -1; //positie moet 'aftellen'
PORTC |= 0x02; //c2=1 --> bepaalt draaizin motor
}
else {
richting = 1; //positie moet optellen
PORTC &= 0xFD; //C2=0
}
while (eindpositie != positie) //zet een boel stapjes zolang de eindpositie niet is bereikt.
{
__delay_us(1250);
PORTC = 0XFF;
__delay_us(1250);
PORTC = 0X00;
positie = positie + richting;
}
}
}
}
Ja, 16f887, dat staat ergens in de settings van dit 'project' in MPLab
EDIT: bovenstaande versie is al een licht verbeterde versie van dat in de vorige post (het stuk die de motor aanstuurt wordt nu enkel doorlopen indien er effectief een verplaatsing is.
Unsigned char richting --> daar kan onmogelijk -1 in staan. Dus nu Char Richting;. en dan...
EUREKA! de motor draait niet meer gelijk zotten, maar enkel als je op knop 7 of 8 duwt en enkel in één richting. Duwen op een van beide knoppen doet het programma precies in het honderd lopen (motor blijft voor lange tijd draaien en stopt plots) (heb nu het aantal stappen verlaagt naar 200 per 'spoor' als test. (200 pulsen = 1 toer)...
Toch een kleine vooruitgang!
Edit: kan het zijn dat ik die interne pull-up weerstanden moet uitschakelen voor portB? Ik gebruik NO knopjes met hun eigen 10K weerstandje (5v---knop--ingang pic -weerstandje naar massa) of zit er een foutje in het staptelsysteem waar ik al heel de tijd over kijk?
Nog steeds de insecten in mijn systeem aan het zoeken.
case ( 8 ) klopt al niet! 8 staat er niet bij
probeer dit al is aan te passen.
Geert
In assembler moet ik bij een PIC 16F887 de analoge ingangen uitschakelen, anders doen de B ingangen raar!
Zo moet dat in assembler:
banksel ANSEL
CLRF ANSEL ;Geen analoge ingangen
CLRF ANSELH
Ik weet niet dat dit ook in C moet
EDIT: ik heb net gemerkt dat je ook op een ander draadje hierover vragen steld. Wel zeer verwarend zo :-\ Daaruit kan ik afleiden dat je schakeling wel werkt op poort B6 en B7 (64 en 128 volgens jou programma). Nu zijn het net deze twee ingangen op de B poort waar geen analoge ingang op zit. De ander wel! Dus deze uitschakelen zal nodig zijn. Kan je geen assembler toevoegen in C code?
Geert
Citaat van: Geert op 28 oktober 2013, 14:50:28 PM
case ( 8 ) klopt al niet! 8 staat er niet bij
probeer dit al is aan te passen.
Geert
copy paste foutje, in origineel werkt het.
Citaat van: Geert op 28 oktober 2013, 15:00:44 PM
In assembler moet ik bij een PIC 16F887 de analoge ingangen uitschakelen, anders doen de B ingangen raar!
Zo moet dat in assembler:
banksel ANSEL
CLRF ANSEL ;Geen analoge ingangen
CLRF ANSELH
Ik weet niet dat dit ook in C moet
Geert
Blijkbaar is dat een vereiste... Al veel websites tegengekomen waar dat probleem zich stelt maar een duidelijke oplossing niet direct.
Char richting --> signed char richting en nu reageert de boel op alle knoppen, maar niet zoals het hoort. (het beperkt zich tot terplaatse trillen en resoneren).
Citeer
Char richting --> signed char richting en nu reageert de boel op alle knoppen, maar niet zoals het hoort. (het beperkt zich tot terplaatse trillen en resoneren).
Allee, is een klassieker: voor chars nooit afgaan op de default, voor ints mag dit wel (steeds signed).
Waarom toggle je eigenlijk de volledige C-poort in uwen stappenlus? Je verandert dan toch ook de richting?
Geert
Dender van de schakelaars?
Citaat van: MickeyMouse op 28 oktober 2013, 19:52:49 PM
Citeer
Char richting --> signed char richting en nu reageert de boel op alle knoppen, maar niet zoals het hoort. (het beperkt zich tot terplaatse trillen en resoneren).
Allee, is een klassieker: voor chars nooit afgaan op de default, voor ints mag dit wel (steeds signed).
Waarom toggle je eigenlijk de volledige C-poort in uwen stappenlus? Je verandert dan toch ook de richting?
Geert
Aha! inderdaad, foutje van de firma. Ik heb de indruk dat bij het indrukken van de knoppen de motor gelijk voortdurend links/rechts draait.
while(eindpositie!=positie) //zet een boel stapjes zolang de eindpositie niet is bereikt.
{
__delay_us(1250);
PORTC|=0X01;
__delay_us(1250);
PORTC&=~0X01;
positie=positie+richting; //zet een stap en hou de huidige positie bij.
}Het is een vooruitgang op vlak van code, maar het werkt er niet beter mee
Citeer
Het is een vooruitgang op vlak van code, maar het werkt er niet beter mee
Ben geen PIC-specialist: zeker dat 'read-modify-write' rechtstreeks op de poort wel werkt? Bij veel controllers kun je de toestand van de poort niet uitlezen. Indien dit zo zou zijn, de bewerking steeds in een variabele doen en de inhoud daarvan dan op de poort zetten.
Geert
zodus eens testen met
PORTB=nieuwe variabele;
switch(nieuwe variabele)...?
Citaat van: conducteur op 28 oktober 2013, 21:02:26 PM
zodus eens testen met
PORTB=nieuwe variabele;
switch(nieuwe variabele)...?
gewoon al uw bewerkingen in een variabele doen en deze dan telkens naar PortC kopieren
Delay
Var |= 0x01;
PortC = Var;
Delay
Var &= 0xFE;
PortC = Var;
Idem om van richting te veranderen, bewerking ook in Var doen, wel zorgen dat deze correct geinitialiseerd is.
Test het eerst eens, als dit de oplossing zou zijn kun je de code mooier maken door die 2 instructie welke je steeds nodig hebt, te vervangen door een #define of door een functie.
Staat uw poort trouwens als Output gedefinieerd?
Geert
volgens mij is dit niet nodig. Kijk eens naar reactie 230 en volgende, daar heb ik een testprogramma voor de relais gemaakt zonder die techniek...
TISC=0xFC; --> enkel c0 & c1 zijn output
Citaat van: conducteur op 28 oktober 2013, 21:20:52 PM
volgens mij is dit niet nodig. Kijk eens naar reactie 230 en volgende, daar heb ik een testprogramma voor de relais gemaakt zonder die techniek...
Ja, maar:
- Daar zet je poort C als output
- en schrijf je direct naar de poort, je gebruikt geen bewerking |= of &=, deze lezen eerst de poort uit en dit kan soms mis gaan, zeker als die niet als output staan, en dan nog...
Citaat van: MickeyMouse op 28 oktober 2013, 21:12:46 PM
Citaat van: conducteur op 28 oktober 2013, 21:02:26 PM
zodus eens testen met
PORTB=nieuwe variabele;
switch(nieuwe variabele)...?
gewoon al uw bewerkingen in een variabele doen en deze dan telkens naar PortC kopieren
Delay
Var |= 0x01;
PortC = Var;
Delay
Var &= 0xFE;
PortC = Var;
Idem om van richting te veranderen, bewerking ook in Var doen, wel zorgen dat deze correct geinitialiseerd is.
Test het eerst eens, als dit de oplossing zou zijn kun je de code mooier maken door die 2 instructie welke je steeds nodig hebt, te vervangen door een #define of door een functie.
Staat uw poort trouwens als Output gedefinieerd?
Geert
Geeft dit geen probleem die VAR, gezien er nog enkele andere in/outputs zijn op die poort? Ik geloof dat de homepositieswitch daar ook zit, alsook het inrijspoorrelais & eindespoorlichtsluis... (ik denk alle I/0 van m'n µC te hebben gebruikt, op een of twee na).
Ik ben nog maar een 'beginner' als het op programmeren aankomt, dus dit kan complete nonsens zijn:
Is contactdender niet eerder een probleem als je moet tellen hoe vaak een knop wordt ingedrukt of hoe vaak een sensor een signaal krijgt? Indien niet, kun je eenvoudig contactdender filteren in software?
-->analoge uitgangen uitzetten lost het probleem niet op
ANSEL=0; //toe te voegen instructies in C...
ANSELH=0;
Rian,
ik lees in stilte mee, maar er mij iets niet duidelijk in je probleemomschrijving. Heb je nu een probleem met PORTB, en de switch/case reeks? Ben je zeker dat deze (inclusief het gedrag en voorwaarde van de ""default" case) correct werkt? Ben je zeker dat je steeds binaire waarden via PORTB krijgt (1,2,...128) of krijg je ook andere getallen (33, 68...) die dan ongewilt in de "default" case sukkelen? Wat gebeurt er als PORTB "0" terug geeft? Mag/kan dit?
Of heb je een probleem met het berekenen van de bestemmingsstappen en sturing van de stappenmotor naar deze positie?
Nog enkele mogelijkheden:
De schakelaars op portB zijn dit maak- of breekcontacten? Bij maakcontacten krijg je 255 i.p.v. 0 als deze allen op staan. (omdat ik ergens gelezen heb dat je externe pull-up R gebruikt)
Probeer is bit gestuurd te programmeren naar de uitgangen en niet via een byte.
De volledige ingang B port naar een ander port (D of A) als uitgang doorsturen en nameten wat er gebeurd op port B. (LED's)
Geert
De knoppen zijn maakcontacten, maar met een weerstandje naar massa --> 0 op de ingang als niet ingedrukt is, 1 op de ingang als de knop wel ingedrukt is (want dan verbind je de ingang via de knop met 5V).
Citaat van: conducteur op 29 oktober 2013, 12:42:02 PM
De knoppen zijn maakcontacten, maar met een weerstandje naar massa --> 0 op de ingang als niet ingedrukt is, 1 op de ingang als de knop wel ingedrukt is (want dan verbind je de ingang via de knop met 5V).
staat de interne pull-up dan uit?
Geert
ah... eh... hoe doe je dat ::) Ik zit nu wel echt te werken met dingen die we nooit gedaan hebben in die lessen C en moet het nu wel veel zelf gaan uitzoeken, maar heb nog niet echt een deftige uitleg gevonden voor bv het Timer0 probleem, vandaar nu terug zoals ik het zelf beheers met __delay-us();... Ik heb in m'n planning portb voorzien voor de knoppen om eventueel gebruik te kunnen maken van de pull-up intern, maar die heb ik nu niet nodig...
Rian, kan je de logica niet omkeren, en met de interne pull-ups werken? Alles staat dus op "1", behalve de pin (bit) dat je "0" trekt. Programmastrutuur blijft, maar "1" wordt "254", etc... Je activeert de interne pull-ups, en klaar! (ik roep maar wat, maar weten doe ik het ook niet, hoor) ;D
Citaat van: Michiel op 29 oktober 2013, 13:03:38 PM
Rian, kan je de logica niet omkeren, en met de interne pull-ups werken? Alles staat dus op "1", behalve de pin (bit) dat je "0" trekt. Programmastrutuur blijft, maar "1" wordt "254", etc... Je activeert de interne pull-ups, en klaar! (ik roep maar wat, maar weten doe ik het ook niet, hoor) ;D
Blij dat we in een gelijkaardige situatie verkeren...
... maar dan moet ik gans het knoppenbordje terug ombouwen, niet dat dat zoveel werk is... Ik probeer het deze avond.
Ombouwen zal ik niet direct doen. Zet is een R van 1k parallel over je huidige pull-up als test. De interne pull-up van de µC is zeer zwak, en volgens de data sheet niet ingeschakeld bij opstart. (net gekeken). Stapje voor stapje werken, elke ingang rechstreeks naar een uitgang sturen om te zien wat er gebeurd en zo stapje verder. Ik doe dat ook zo om fouten te zoeken. (kan soms weken duren voor alle fouten er uit zijn ;D :o )
Geert
Bij de Arduino gebruik ik pin 13 met LED als debugsignaal. Is een tijdelijke debugvoorwaarde waar/niet-waar? -> onboard led aan/uit. Geeft meteen een visuele controle.
Ik geloof dat er nog twee I/O's op de C poort vrij zijn, ga daar eens twee ledjes aanhangen...
Ik denk dat ik bijna weer een EUREKA moment heb, maar voor de spanning in te houden wacht ik tot morgen.
Nog geen vooruitgang in het stappenmotor verhaal, wel een grote vooruitgang algemeen ivm programmeren. Toen ik dit project begonnen ben had ik zo'n e-blocks programmer geleend van school, en m'n printjes zijn dus niet voor zien met een header om een connector op aan te sluiten voor m'n pickit2 die ik deze zomer gekocht heb (programmer uiteraard moeten teruggeven).
Nu kan ik zonder problemen regeltje per regeltje de code schrijven en direct uitproberen. Ik hoef niet meer te vrezen voor geplooide µC pinnen, en ben verlost van het ganse gepruts door nu op een stukje gaatjesprint een connector te zetten en de 5 draden te verbinden naar de juiste pin op de µC.
Leve ICSP!
Nu dus van 0 terug begonnen, heel simpel en elke keer de code wat vooruitgegaan is (hoe eenvoudig die ook mag zijn) testen, veel vlugger dan vroeger. Ik ben nog ver van daar waar ik bijna was, maar het gaat vooruit en werpt z'n vruchten af, de nieuwe werkmethode! Samen met de tip van Michiel staan nu ook twee ledjes op de 2 vrije I/0 op de C poort. Daarmee staat het boeltje 'vol'.
ALs ik je nog een tip mag geven... Lees heel goed e datasheet van de controller na. Elke controller (ook bij Microchip) heeft z'n eigen speficiteiten en eigenaardigheidjes. Zoals default uitgeschakeld pullups, sommige poorten die open collector zijn, analoge ADC die by default actief zijn, ...
Heel dikwijls is niet werkende software te wijten aan incorrecte configuratie van de controller. Ik ben hier zo ook al een paar keer tegen de lamp gelopen omdat ik dacht dat alle Microchips dezelfde of gelijkaardig zouden zijn; foute veronderstelling...
--> Ik zal me eens moeten storten op de werking van die instelregisters voor dingen te configureren in de chip... bv voor de interne pull-up van Port B
#include <htc.h>
// Config: HS ext Xtal- Watchdogtimer disabled - LVP Disabled
__CONFIG(FOSC_HS & WDTE_OFF & LVP_OFF);
#define _XTAL_FREQ 20000000
void main(){
ANSEL=0;
ANSELH=0;
unsigned char b;
while (1){
TRISB=0xFF;
PORTB=b;
__delay_ms(500);
TRISD=0x00;
PORTC=b;
__delay_ms(500);
}
}
PortB in een variabele stoppen en dan naar poort D sturen (de relais weet je) en die gaan allemaal aan. Er klopt dus iets niet aan poortB en zal daar dus nooit iets kunnen bedienen op die manier. (hoewel ik 0,000mV meet op de pinnen van poortB leest ie ze toch in als 1 dus intern probleem wellicht?
Ik weet niet hoe het zit bij jouw Pics en je programmeeromgeving, maar bij Bascom en AVR's bestaan er drie registers per poort
ddrb: direction (richting) van de poort. 0=ingang, 1 is uitgang
portb: register om uitgang te schrijven, of voor de interne pull-up bij ddrb=0
pinb: register om de ingang te lezen
"a=portb" leest dus de "aktiviteit" van alle pull-ups. "a=pinb.2" leest de elektrische toestand van een ingangssignaal.
't Is een klassieker om pinb en portb met elkaar te verwarren ;)
Citaat van: Gerolf op 31 oktober 2013, 08:26:47 AM
Ik weet niet hoe het zit bij jouw Pics en je programmeeromgeving, maar bij Bascom en AVR's bestaan er drie registers per poort
ddrb: direction (richting) van de poort. 0=ingang, 1 is uitgang
portb: register om uitgang te schrijven, of voor de interne pull-up bij ddrb=0
pinb: register om de ingang te lezen
"a=portb" leest dus de "aktiviteit" van alle pull-ups. "a=pinb.2" leest de elektrische toestand van een ingangssignaal.
't Is een klassieker om pinb en portb met elkaar te verwarren ;)
Voor zover ik geleerd heb zijn er 2 het TRIS commando zet de ingang/uitgang. 0 is output I is input. Bv TRISB=0xFF; --> alle pins van poort b zijn input. of TRISC=0x3E; --> bepaalde pins zijn input/output op de c poort... En het commando om de poort te lezen/schrijven is gewoon PORTB/PORTA/PORTC bv --> PORTB=255
wil je een pin schrijven moet je met die logische operatoren werken.
Nog een mogelijke ergernis bij PIC's is het 'read modify write' probleem. Eenvoudig uitgelegd kan ik dit als volgt omschrijven:
Als je een uitgangsbit een bepaalde logische waarde toekent, dan gaat dit via een register, technisch: een D F-F, die de uitgangspin aanstuurt (zie figuur data sheet PIC16F887, I/O ports C):
BSF PORTC,1 <-- zet bit 1 van poort C logisch '1'
Lees je nu de logische waarde van poort C bit 1, dan lees je niet de logische waarde van de D F-F maar de logische waarde direct op de uitgangspin. En deze logische waarde is niet altijd de logische waarde van de D F-F, maar kan afhankelijk van wat er geschakeld is op de uitgang een andere logische waarde zijn. Kan bijvoorbeeld voorkomen bij capacitieve of inductieve belasting, maar ook bij stoorbronnen.
Als je nu de volgende instructie uitvoert in C code (alle pinnen op poort C zijn uitgangen):
PORTC |=0X01 //PORTC = PORTC OR 0X01
Wat doet de µC dan: deze leest de logische toestand op de pinnen van poort C, voert er een bewerking op uit, en zet deze in de D F-F's van poort C. Zonder dat het eigenlijk de bedoeling was kan je zo een bitwaarde van een D F-F wijzigen, met in het uiterste geval als je de instructie snel na elkaar uitvoert een alternerende uitgang.
Daarom wordt er heel veel aangeraden met schaduw registers te werken.
Ik kijk bij een µC die ik nog niet goed ken altijd in de data sheet wat er op deze pin allemaal geschakeld zit. Je staat soms versteld wat er op die C pinnen allemaal op geschakeld staat.
Geert
p30: http://ww1.microchip.com/downloads/en/devicedoc/41291f.pdf (http://ww1.microchip.com/downloads/en/devicedoc/41291f.pdf)
dat register moet dus op 128 staan (0x80;) Nu nog het commando vinden :D
pfff.... registers, meervoudige instructies, assembler toestanden..... geef mij toch maar een meer geavanceerde programmeertaal.
Al snap ik best wel het nut van compacte programma's en voorspelbare cyclustijden .
Wat gebruik je dan, Dani?
een C/C++ gebaseerde taal (maar dan op een ander platform dan PIC, namelijk Ard........o )
Ik werk toch ook in C dus wellicht is er toch niet zoveel verschil? Wat is dan het probleem :
Citeerpfff.... registers, meervoudige instructies, assembler toestanden..... geef mij toch maar een meer geavanceerde programmeertaal.
Al snap ik best wel het nut van compacte programma's en voorspelbare cyclustijden .
heb ik dan gezegd dat er een probleem is ?
waar staat dat ? waarschijnlijk waar veel mensen het vaakst lezen, tussen de regels. Maar daar zou het niet moeten staan.
never mind. ligt wslk aan mij
Ik dacht dat zo te interpreteren, excuses als je je aangevallen voelt...
maar nee, ik voel me zeker niet aangevallen Rian, en je hoeft je niet te excuseren. Ik ben gewoon van mening dat "getikte tekst" vaak anders geïnterpreteerd wordt dan wat er eigenlijk staat, en dat is niet alleen hier of bij jou, dat is een algemeen gegeven Daarom dat ik zeg "zal aan mij liggen".
Doe rustig verder met je werk, ik volg het op de voet en ben benieuwd wat het resultaat gaat zijn .
Eerst die poortB oplossen, niet moeilijk dat die raar doet--> ze inlezen geeft '255' terwijl het 0 zou moeten zijn...
switch (PORTB) //Zoek welke knop ingedrukt was:
{
case(1): eindpositie=200; break; //ga naar 1000 stappen tov referentie
case(2): eindpositie=400; break; //ga naar 2000 stappen tov referentie
case(4): eindpositie=600; break; //ga naar 3000 stappen tov referentie
case(: eindpositie=800; break; //....
case(16): eindpositie=1000; break; //...
case(32): eindpositie=1200; break;
case(64): eindpositie=1400; break;
case(128): eindpositie=1600; break; //ga naar 8000 stappen tov referentie
default: eindpositie=positie; //huidige positie=te bereiken positie --> geen verplaatsing
}
en gezien er nergens 255 in de switch staat uit enkele programma's geleden... gebeurt er niets.
Citaat van: conducteur op 31 oktober 2013, 13:21:48 PM
p30: http://ww1.microchip.com/downloads/en/devicedoc/41291f.pdf (http://ww1.microchip.com/downloads/en/devicedoc/41291f.pdf)
dat register moet dus op 128 staan (0x80;) Nu nog het commando vinden :D
Op deze manier moet het lukken:
OPTION_REGbits.nRBPU = 1;
Dit zou de pullups van PORTB moeten activeren. Ik ken je schema niet, maar ik denk dat je verkeerd redeneert (tenminste als je schakelaars verbonden met de massa en pullups gebruikt). Als alle schakelaars open staan zal je overal 1 zien, deze die dicht zijn gaan 0 geven.
In jouw geval meen ik te lezen dat je schakelaar via een weerstand aan de massa hangt, maar waar hangt de andere kant van je schakelaar? Aan de voeding? Of direct aan je µC? In ieder geval mag je nooit de interne pullup gebruiken als je al een externe pulldown hebt (wat ik denk), want dan krijg je een spanningsdeler en ga je met veel pech nooit het correcte niveau halen om een 0 of een 1 te krijgen.
Kan je je schema eens posten? Dan kan ik zien wat je moet doen met de interne pullups en evt. je code wat bijsturen...
Ik hoop dat er zo geen verwarring meer kan zijn:
(http://www.treinbaanrian.be/images/eindwerk/knoppen.png)
De pullup moet toch op disable staan?
Inderdaad de pullup moet disabled zijn, dus wel degelijk:
OPTION_REGbits.nRBPU = 1;
Je redenering in je code is dus wel degelijk correct. Maar je case bevat wel een foutje voor waarde 8 en je schrijft de case best zonder haakjes, ik had het zo gedefinieerd:
switch (PORTB) { //Zoek welke knop ingedrukt was:
case 0x01:
eindpositie=200;
break; //ga naar 1000 stappen tov referentie
case 0x02:
eindpositie=400;
break; //ga naar 2000 stappen tov referentie
case 0x04:
eindpositie=600;
break; //ga naar 3000 stappen tov referentie
case 0x08:
eindpositie=800;
break; //....
case 0x10:
eindpositie=1000;
break; //...
case 0x20:
eindpositie=1200;
break;
case 0x40:
eindpositie=1400;
break;
case 0x80:
eindpositie=1600;
break; //ga naar 8000 stappen tov referentie
default:
eindpositie=positie; //huidige positie=te bereiken positie --> geen verplaatsing
}
Of met wat meer geavanceerde C-code, alle waarden in een constante array stoppen en de dan bit waarde van PORTB berekenen via een for loop en een right shift. Deze 'bit' dan gebruiken om de gewenste waarde uit de array te halen. Zou minder code moeten opleveren, maar jouw methode is ook goed.
Ik hou het voorlopig wel op een niveau dat ik zelf begrijp, maar ik begrijp niet waarom dit het al een ganse week niet doet?
[font=Verdana][size=9px][[/size][/font]code]
#include <htc.h>
// Config: HS ext Xtal- Watchdogtimer disabled - LVP Disabled
__CONFIG(FOSC_HS & WDTE_OFF & LVP_OFF);
#define _XTAL_FREQ 20000000
void main()
{
OPTION_REGbits.nRBPU = 1;
ANSEL = 0;
ANSELH = 0;
unsigned char richting;
unsigned int positie;
unsigned int eindpositie;
TRISC = 0x00;
while (1) {
PORTC = 0x30; //twee vrije I/0 op c poort --> debug ledjes moeten knipperen als motor niet draait.
__delay_ms(250);
PORTC = 0x00;
TRISB = 0xff; //port B drukknoppen input
switch (PORTB) { //Zoek welke knop ingedrukt was:
case 0x01:
eindpositie = 200;
break; //ga naar 1000 stappen tov referentie
case 0x02:
eindpositie = 400;
break; //ga naar 2000 stappen tov referentie
case 0x04:
eindpositie = 600;
break; //ga naar 3000 stappen tov referentie
case 0x08:
eindpositie = 800;
break; //....
case 0x10:
eindpositie = 1000;
break; //...
case 0x20:
eindpositie = 1200;
break;
case 0x40:
eindpositie = 1400;
break;
case 0x80:
eindpositie = 1600;
break; //ga naar 8000 stappen tov referentie
default:
eindpositie = positie; //huidige positie=te bereiken positie --> geen verplaatsing
}
if (eindpositie != positie) //indien geen verplaatsing, onderstaande niet doorlopen
{
if (eindpositie < positie) {
richting = -1; //positie moet 'aftellen'
PORTC |= 0x02; //c2=1 --> bepaalt draaizin motor
}
else {
richting = +1; //positie moet optellen
PORTC &= ~0x02; //C2=0
while (eindpositie != positie) //zet een boel stapjes zolang de eindpositie niet is bereikt.
{
__delay_us(1250);
PORTC |= 0X01;
__delay_us(1250); //400hz max frequentie motor
PORTC &= ~0X01;
positie = positie + richting; //zet een stap en hou de huidige positie bij.
}
}
}
}
}
Normaal gezien, als ik geen knoppen induw doorloopt hij het ganse onderste deel niet, en zouden de debugledjes die ik toegevoegd heb aan de µC moeten knipperen... Die gaan aan, maar knipperen niet. Als de motor begint te draaien zouden die moeten uitgaan, echter ziet het er naar uit dat de boel niet reageert op de knoppen... De ledjes gaan niet uit, en de motor begint niet te draaien na indrukken van een knop?
Je code ziet er mij correct uit (heb niet alles gecontroleerd) en je ledjes zouden normaliter moeten knipperen. MAAR... Heb je de /MCLR (reset) pin wel correct aangesloten of geconfigureerd? Want ik heb de indruk dat je schakeling permanent in reset gaat door een verkeerd gebruik van dit pinnetje...
De /MCLR dien je in normale mode aan de voeding te hangen (in programmeermode natuurlijk niet). Of je can ook in de __CONFIG de /MCLR uitschakelen:
__CONFIG(FOSC_HS & WDTE_OFF & LVP_OFF & MCLRE_OFF)
Deze laatste disabled de /MCLR zodat je deze als gewone I/O kan gebruiken, je hoeft dan niks aan dat pinnetje te hangen.
Opmerking: om je /MCLR pin aan de Vdd te krijgen kan je een jumperke over de Vdd en de Vpp pinnetjes van de ISP connector plaatsen.
Die hangt met een 10K weerstandje aan 5V, en met een draadje naar de header voor de programmer.
OK, dan gaan we je code stap voor stap nakijken...
Probeer eens alles in je while loop te verwijderen en laat enkel je leds knipperen. We zullen ze deze maal veel trager laten knipperen want ik denk dat je code na PORTC = 0x00 te snel is en je daardoor zie de knippering niet. Als dit werkt, weten we dat je hardware en je software + configuratie op dat vlak al min of meer ok is:
#include <htc.h>
// Config: HS ext Xtal- Watchdogtimer disabled - LVP Disabled
__CONFIG(FOSC_HS & WDTE_OFF & LVP_OFF);
#define _XTAL_FREQ 20000000
void main()
{
OPTION_REGbits.nRBPU = 1;
ANSEL = 0;
ANSELH = 0;
TRISC = 0x00;
while (1) {
PORTC = 0x30; //twee vrije I/0 op c poort --> debug ledjes moeten knipperen als motor niet draait.
__delay_ms(500);
PORTC = 0x00;
__delay_ms(500);
}
}
Inderdaad, de delay na het uitzetten van de ledjes was ik vergeten. Dat gaat al...
Dan kunnen we een stapje verder. We gaan eens kijken of je één van de schakelaars kan inlezen en daarmee één van de ledjes aan en uit zetten. Het andere ledje laten we continu knipperen.
#include <htc.h>
// Config: HS ext Xtal- Watchdogtimer disabled - LVP Disabled
__CONFIG(FOSC_HS & WDTE_OFF & LVP_OFF);
#define _XTAL_FREQ 20000000
void main()
{
OPTION_REGbits.nRBPU = 1;
ANSEL = 0;
ANSELH = 0;
TRISC = 0x00;
TRISB = 0xff; //port B drukknoppen input
while (1) {
PORTC ^= 1 << 5; // Toggle 5e bit van PORTC (0x10)
__delay_ms(500);
switch (PORTB) { //Zoek welke knop ingedrukt was:
case 0x01:
PORTC ^= 1 << 6; // Toggle 6e bit van PORTC (0x20)
break;
default:
}
}
Dit zou één ledje (PORTC 5e bit) moeten laten knipperen; en telkens je op de eerste schakelaar drukt, het 2e ledje (PORTC 6e bit) omzetten (aan/uit).
Het werkte min of meer --> de while lus mistte een } en de ledjes zitten op c4 en c5 (niet op c6), maar dat was geen probleem om dat aan te passen.
zo dus:
#include <htc.h>
// Config: HS ext Xtal- Watchdogtimer disabled - LVP Disabled
__CONFIG(FOSC_HS & WDTE_OFF & LVP_OFF);
#define _XTAL_FREQ 20000000
void main()
{
OPTION_REGbits.nRBPU = 1;
ANSEL = 0;
ANSELH = 0;
TRISC = 0x00;
TRISB = 0xff; //port B drukknoppen input
while (1) {
PORTC ^= 1 << 4; // Toggle 5e bit van PORTC (0x10)
__delay_ms(500);
switch (PORTB) { //Zoek welke knop ingedrukt was:
case 0x01:
PORTC ^= 1 << 5; // Toggle 6e bit van PORTC (0x20)
break;
default: 0 ;
}
}
}
Inderdaad, heb de code niet getest. Dus nu weet je dat je schakeling in orde is en dat je inputs werken (althans één ervan). De volgende stap wordt dus de rest van de inputs nakijken en je uitgangen naar de (stappen)motor testen. Hoe is je motor trouwens aangesloten? Heb je daar een schema van? Je bent er bijna...
Wel meteen een opmerking: de huidige code kan wel voor problemen zorgen. We hebben een ledje dat aan en uit knippert met telkens een interval van 0.5 seconden. In diezelfde loop (while lus) ga je ook je inputs lezen en je uitgangen sturen. Vroeg of laat zorgt dat voor problemen omdat je veel tijd verbruikt waarbij je je input niet kan lezen (bv. 500ms delay); dus als er input 2x wijzigt (aan/uit bv) gedurende dit interval, gaat je software dit niet zien. Let daar dus goed op.
Je kan je inputs bv. interrupt driven maken (zitten gelukkig op PORTB waar je een interrupt on change hebt); op deze manier zal je geen inputwijzigingen missen
Ik doe straks verder, eerst zien dat m'n voorbereiding voor in de treinclub deze avond af is, bijna...
Het enige dat ik zie is dat er eventueel iets mis is met het inlezen van je schakelaars. Je gaat er immers van uit dat er maar 1 bit tegelijk hoog kan zijn, anders doe je niets. Vermits je nooit iets doet, zou het wel eens kunnen dat er bvb door een kortsluiting steeds de default wordt aangeroepen. Je zou de input van poort B eens naar een andere poort moeten kunnen outputten. Andere mogelijkheid is dat je bvb in de default sectie 1 led eens laat knipperen, dan weet je tenminste dat hij in de default komt en kan je zien of hij er niet inkomt als je op een knop drukt.
Als 0x01 werkt in het testprogje van Patrick, wil dat zeggen dat op dat moment enkel 0x01 ingelezen wordt, en geen andere --> geen kortsluitingen. Ik ga Patrick z'n programma nog 7 keer testen, elke keer met een andere knop.
#include <htc.h>
// Config: HS ext Xtal- Watchdogtimer disabled - LVP Disabled
__CONFIG(FOSC_HS & WDTE_OFF & LVP_OFF);
#define _XTAL_FREQ 20000000
void main()
{
OPTION_REGbits.nRBPU = 1;
ANSEL = 0;
ANSELH = 0;
TRISC = 0x00;
TRISB = 0xff; //port B drukknoppen input
while (1) {
PORTC ^= 1 << 4; // Toggle 5e bit van PORTC (0x10)
__delay_ms(500);
switch (PORTB) { //Zoek welke knop ingedrukt was:
case 0x01: //hier telkens andere waarden invullen.
PORTC ^= 1 << 5; // Toggle 6e bit van PORTC (0x20)
break;
default:
0;
}
}
}
Alle pinnen van de b-poort worden apart herkend door bovenstaand programma, als je in de switch de juiste waarde invult. :D
Rian,
Ik kom regelmatig eens piepen naar je vorderingen. Ik lees niet altijd je code maar ik heb enkele (schoonheids)opmerkingen: laat al die white-space weg (blanco regels maken je programma moeilijker leesbaar - één blanco regel per overgang is meer dan voldoende). Inspringen: 2 spaties (geen tab!) en je haakjes mooi onder elkaar zodat duidelijk is welk haakje bij welk hoort.
Wat ik niet snap van die High-tech C is dat je nergens een controller moet definiëren; als je naar de ..\include\ directory van de compiler kijkt, staat die vol met definities van iedere mogelijke controller. Iedere controller heeft andere eigenschappen/registers.
De headerfile 'htc.h' kijkt enkel of het gaat om een gewone pic, een 18... of een ds...
De header 'pic.h' neemt vervolgens 'chip_select.h'.
Daarin staat duidelijk:
/*
* Select device-specific header file
*/
Volgens mij kan je jezelf veel ergernis voorkomen door in het begin van je programma de definitie van je controller op te nemen:
#define _16f887
Dan weet je compiler ten minste dat je met een 16F887 bezig bent. Anders kan je register aanspreken die in je controller niet voorkomen. Je compiler trekt zich daar geen snars van aan en compileert je programma (één van de voordelen van C/C++ maar daarom dat ik voor een taal kies waar de compiler kieskeuriger is en minder fouten toe laat).
Blij dat je vorderingen maakt, maar vergeet niet eerst te stappen vooraleer te lopen ;)
In het begin heb ik in MPlab een nieuw project aangemaakt en daar aangevinkt dat ik die controller wil, en zo weet ie dus wat te doen...
Citaat van: conducteur op 01 november 2013, 19:07:26 PM
In het begin heb ik in MPlab een nieuw project aangemaakt en daar aangevinkt dat ik die controller wil, en zo weet ie dus wat te doen...
Vermoedelijk (hopelijk) weet je compiler dat op die manier, maar een lezer van je programma niet...
[edit]
Een keertje teveel definiëren kan geen kwaad:
#if !defined _16f887
#define _16f887
#endif
Rian gebruikt MPLAB, dan hoef je de gebruikte µC inderdaad niet te definiëren in de code; je geeft die enkel mee via de configuratie (select device). De keuze van de controller wordt mee opgeslagen met je project en als parameter meegegeven aan de compiler...
Voordeel is dat je code makkelijk overdraagbaar is naar andere controllers van dezelfde familie. Heel veel PICs kun je gewoon uitwisselen...
Maar inderdaad de vele spaties en lege lijnen maken de code moeilijk leesbaar... Maar opgelet met code formatting, ieder heeft z'n eigen systeem. Op 't werk wordt er zelfs een verplichte formatting afgedwongen (via automatische controle); als de formattering niet klopt, vliegt de code terug naar de developer. Dit is nodig om te vermijden dat Source Versioning Control (Subversion, CVS, Git, ...) gek wordt van de verschillen tussen de developers. En wij doen net het omgekeerde van wat Peter zegt: wel tabs (zeker geen spaties) en het begin haakje altijd op de lijn waar de instructie begonnen is. Door tabs te gebruiken kan iedereen z'n indent instellen (via de editor) hoe hij/zij dat wil, met spaties kan dit niet meer. Haakjes (accolades) op dezelfde lijn maken je code compacter en beter leesbaar; en altijd haakjes gebruiken ook wanneer ze niet verplicht zijn, bv.
void main() {
if (state) {
do_something();
} else {
do_something_else();
}
}
De if test heeft in prinicipe geen accolades nodig (omdat er maar één regel volgt); maar wij verplichten de developers om ze toch te zetten, want een veel voorkomende fout is dat men de code nog effe wil aanpassen en regeltje wil toevoegen aan de if test, maar men vergeet dan de accolades en 't is koekenbak (zoals wij in België zeggen)...
Rian's vorderingen komen er stilletjes bij beetje... we weten nu dat de µC correct de software uitvoert (geen verdoken resets) en dat de inputs correct gelezen worden. Volgende stap: uitgangen verder controleren (2 ledjes hebben we al gedaan). Laat eerst je schema eens zien en dan kijken we wat we kunnen testen...
Dit zijn ongeveer dezelfde stappen die ik uitvoer wanneer ik m'n twijfels heb over m'n printjes; telkens één onderdeel tegelijk testen en dan later alle stukken 'assembleren' in de code om tot één mooi geheel te komen.
Patrick: de ganse beschrijving van dit systeem staat in m'n dossier dat ik heb moeten maken voor het eindwerk vorig jaar, heb dat eens op de server gesmeten:
http://www.treinbaanrian.be/downloads/dossier.pdf (http://www.treinbaanrian.be/downloads/dossier.pdf)
(pin assignments, schema's, principewerking... allemaal in dit heilig dossiertje. :D )
Knap dossier(tje)! Heel proper uitgewerkt!
Om terug bij je controller te komen, ik vermoed dat je nu probeert om één van de NPN transistoren aan te spreken die een relais moeten schakelen? (p. 49)
Ik kan jammer genoeg het schema niet goed zien, de tekening is nogal wazig...
Maar als m'n veronderstelling juist is, heb je al geprobeerd om je relais 'manueel' om te schakelen door effe een kant van het basisweerstandje van de NPN aan de 5V te houden? Als deze manuele test niet werkt, heb je een probleem met je transistor (een BC547 ?)
Alle relais heb ik al kunnen aansturen met de µC... Elke relais inderdaad met een bc 547 aan te sturen, nu zou ik dit doen met een ULN2803, maar dat IC was mij toen onbekend...
Citaat van: conducteur op 02 november 2013, 00:27:35 AM
nu zou ik dit doen met een ULN2803, maar dat IC was mij toen onbekend...
beginnersfoutje, we maken ze allemaal, ik heb dit IC ook pas recentelijk "ontdekt" en even gevloekt. Maar wat gebeurd is, is gebeurd :-)
Vooruit kijken en gewoon lekker verder doen is de boodschap. Komt wel goe !
Met de BC547 of de ULN2803, maakt niet zoveel uit. De ULN2803 is compactere versie van de BC547 met flyback diode als je er 8 nodig hebt...
Messtal probeer ik effe te googlen wat ik probeer uit te voeren, heel dikwijls vindt je dan heel wat hints hoe dit opgelost kan worden. Maar de basis elektronica is steeds verrekte handig en die heb je blijkbaar wel onder de knie. En als je ergens een oplossing 'vindt', controleer dan steeds de datasheets van de gebruikte componenten; want jammer genoeg levert het internet niet altijd even correcte resultaten.
Kan je nu verder met je software of heb je nog hulp van ons nodig? Indien ja, laat maar weten welke test je graag zou uitvoeren...
De truc is om niet teveel software ineens te ontwikkelen, probeer steeds met kleine stukjes zoals we hierboven gedaan hebben en voeg ze dan met beetjes samen. Probeer ook om de belangrijkste blokken (lezen van de input, sturen van de output bv.) in aparte routines onder te brengen. Later kan je zelfs overwegen om deze onder te brengen in andere modules, zodat je ze snel kan includen in andere projecten.
/* **************************************************************************
* HITECH C for PIC program A_01- 1/11/2013 *
• Author: Rian De Rous *
****************************************************************************
* Processor: PIC16F887 *
* Compiler: HI-TECH C PRO v9.65PL1 Lite *
• Project: G.I.P. Automatisch schaduwstation zonder wissels *
• Discription: test poort B & stepper motor *
*
************************************************************************* */
#include <htc.h>
// Config: HS ext Xtal- Watchdogtimer disabled - LVP Disabled
__CONFIG(FOSC_HS & WDTE_OFF & LVP_OFF & MCLRE_OFF);
#define _XTAL_FREQ 20000000
void main()
{
unsigned int teller;
OPTION_REGbits.nRBPU = 1; //pull-up b poort disable
ANSEL = 0; //analog input disable
ANSELH = 0;
TRISC = 0x00;
TRISB = 0xff; //port B drukknoppen input
while (1)
{
PORTC ^= 1 << 5; // Toggle 5e bit van PORTC (0x10)
__delay_ms(500);
switch (PORTB)
{
case 0x01:
teller = 0;
while (teller != 200)
{
PORTC = 0x01;
__delay_us(1500);
PORTC = 0x00;
__delay_us(1500);
teller++;
}
break;
case 0x02:
__delay_ms(50);
teller = 0;
while (teller != 400)
{
PORTC = 0x01;
__delay_us(1500);
PORTC=0x00;
__delay_us(1500);
teller++;
}
break;
case 0x04:
__delay_ms(50);
teller = 0;
while (teller != 600)
{
PORTC = 0x01;
__delay_us(1500);
PORTC=0x00;
__delay_us(1500);
teller++;
}
break;
case 0x08:
__delay_ms(50);
teller = 0;
while (teller != 800)
{
PORTC= 0x01;
__delay_us(1500);
PORTC=0x00;
__delay_us(1500);
teller++;
}
break;
case 0x10:
__delay_ms(50);
teller = 0;
while (teller != 1000)
{
PORTC = 0x01;
__delay_us(1500);
PORTC=0x00;
__delay_us(1500);
teller++;
}
break;
case 0x20:
__delay_ms(50);
teller = 0;
while (teller != 1200)
{
PORTC = 0x01;
__delay_us(1500);
PORTC=0x00;
__delay_us(1500);
teller++;
}
break;
case 0x40:
__delay_ms(50);
teller = 0;
while (teller != 1400)
{
PORTC = 0x01;
__delay_us(1500);
PORTC=0x00;
__delay_us(1500);
teller++;
}
break;
case 0x80:
__delay_ms(50);
teller = 0;
while (teller != 1600)
{
PORTC = 0x01;
__delay_us(1500);
PORTC=0x00;
__delay_us(1500);
teller++;
}
break;
default:0;
}
}
}
We gaan vooruit, dit werkt... Afhankelijk van welke knop ingedrukt was draait de motor een (paar) toer(en).
Volgende wat ik probeer: de draaizin omkeren.
Allez hup, dan ben je nu goed op weg.
Roep maar als we moeten helpen...
Ben iets te rap geweest met m'n reactie. Je code zal wel werken, maar bevat een groot gevaar. Op 't werk noemen we het 'code duplication'; 't is te zeggen dat ik in je code een paar blokken code zie, die steeds terug keren:
PORTC = 0x01;
__delay_us(1500);
PORTC=0x00;
__delay_us(1500);
teller++;
Bovenstand blok komt verschillende keren voor in je code en dat is niet goed:
1) Je code wordt er minder leesbaar door
2) Als je hier iets wil wijzigen, moet je dat verschillende keren gaan doen, met meer risico op een dom foutje
3) Het verbruikt meer ROM geheugen
Zulke zaken stop je best in een (sub)routine.
Een tweede opmerking is: gebruik defines om je hardware aan te spreken, als je dan later je hardware wil wijzigen, hoef je enkel maar deze defines aan te passen ipv. van je hele code te moeten doorlopen.
Derde opmerking: je hebt een paar 'gevaarlijke' testen. Bv.
while (teller != 200)
Dit is levengevaarlijk wanneer je teller door één van de subroutines bokkesprongen gaat/kan maken en je hierdoor bv. plots van 199 naar 201 zou springen of iets dergelijks. Je while loop gaat deze 'missen' en blijven doorlopen... Bad practice...
Dit vervang je beter door:
while (teller < 200)
En nog een vierde opmerking (en dan laat ik je gerust ;)): ik vermoed dat je telkens maar één bit van PORTC wil aansturen; maar je zet telkens wel de volledige PORTC.
PORTC = 0x01;
Dit zet alle bits op 0 behalve de eerste.
Betere versie:
PORTC |= (1<<bit);
Bovenstaande zet enkel bit 'bit' aan van PORTC en blijft van de andere bitjes af. Idem voor het clearen van een bit:
PORTC &= ~(1<<bit);
't Zijn maar details, maar op langere termijn kunnen ze bepalend zijn voor de goede werking van heel je software.
Citaat van: Sattrickske op 02 november 2013, 16:17:49 PM
Ben iets te rap geweest met m'n reactie. Je code zal wel werken, maar bevat een groot gevaar. Op 't werk noemen we het 'code duplication'; 't is te zeggen dat ik in je code een paar blokken code zie, die steeds terug keren:
PORTC = 0x01;
__delay_us(1500);
PORTC=0x00;
__delay_us(1500);
teller++;
Bovenstand blok komt verschillende keren voor in je code en dat is niet goed:
1) Je code wordt er minder leesbaar door
2) Als je hier iets wil wijzigen, moet je dat verschillende keren gaan doen, met meer risico op een dom foutje
3) Het verbruikt meer ROM geheugen
Zulke zaken stop je best in een (sub)routine.
Dat moet ik inderdaad eens uitzoeken hoe dat moet, in het defenitieve programma zal ik dat ook enkele keren moeten gebruiken
Citeer
Een tweede opmerking is: gebruik defines om je hardware aan te spreken, als je dan later je hardware wil wijzigen, hoef je enkel maar deze defines aan te passen ipv. van je hele code te moeten doorlopen.
Dit begrijp ik niet helemaal, bedoel je dat ik toch <htc.h> vervang door die van de controller?
Citeer
Derde opmerking: je hebt een paar 'gevaarlijke' testen. Bv.
while (teller != 200)
Dit is levengevaarlijk wanneer je teller door één van de subroutines bokkesprongen gaat/kan maken en je hierdoor bv. plots van 199 naar 201 zou springen of iets dergelijks. Je while loop gaat deze 'missen' en blijven doorlopen... Bad practice...
Dit vervang je beter door:
while (teller < 200)
Inderdaad, het werkt maar ideaal is het dus niet. In het vervolg dus te vervangen...
Citeer
En nog een vierde opmerking (en dan laat ik je gerust ;) ): ik vermoed dat je telkens maar één bit van PORTC wil aansturen; maar je zet telkens wel de volledige PORTC.
PORTC = 0x01;
Dit zet alle bits op 0 behalve de eerste.
Betere versie:
PORTC |= (1<<bit);
Bovenstaande zet enkel bit 'bit' aan van PORTC en blijft van de andere bitjes af. Idem voor het clearen van een bit:
PORTC &= ~(1<<bit);
't Zijn maar details, maar op langere termijn kunnen ze bepalend zijn voor de goede werking van heel je software.
Heeft dit dezelfde werking als PORTC|=0x01 (bitje set) & PORTC&=~0x01; (bitje clear)? Ja toch? Dat kende ik toch al ;)
Citaat van: conducteur op 02 november 2013, 17:12:33 PM
Citeer
Een tweede opmerking is: gebruik defines om je hardware aan te spreken, als je dan later je hardware wil wijzigen, hoef je enkel maar deze defines aan te passen ipv. van je hele code te moeten doorlopen.
Dit begrijp ik niet helemaal, bedoel je dat ik toch <htc.h> vervang door die van de controller?
Neen, ik bedoel iets anders. Her en der in je code gebruik je PORTC = 0x01 -wat je dient te vervangen door een bit set-, maar deze instructie wijst eigenlijk op een stukje van jouw hardware (een spoel van de stappenmotor activeren bv.). Dit vervang je beter door zoiets:
#define STEP_COIL1_ACTIVATE PORTC |= 0x01
En in je code gebruik dan je gewoon STEP_COIL1_ACTIVATE ipv. de PORTC |= 0x01. Het voordeel is dat je alle defines bij elkaar plaatst in een header file of bovenaan je applicatie, als je dan later je hardware wijzigt, hoef je niet overal in je code naar dat pinnetje te zoeken. Gewoon effe de define aanpassen en het is gepiept...
Citaat van: conducteur op 02 november 2013, 17:12:33 PM
Citeer
En nog een vierde opmerking (en dan laat ik je gerust ;) ): ik vermoed dat je telkens maar één bit van PORTC wil aansturen; maar je zet telkens wel de volledige PORTC.
PORTC = 0x01;
Dit zet alle bits op 0 behalve de eerste.
Betere versie:
PORTC |= (1<<bit);
Bovenstaande zet enkel bit 'bit' aan van PORTC en blijft van de andere bitjes af. Idem voor het clearen van een bit:
PORTC &= ~(1<<bit);
't Zijn maar details, maar op langere termijn kunnen ze bepalend zijn voor de goede werking van heel je software.
Heeft dit dezelfde werking als PORTC|=0x01 (bitje set) & PORTC&=~0x01; (bitje clear)? Ja toch? Dat kende ik toch al ;)
Ja inderdaad, je hebt het alleen niet toegepast in je code...
De '<<' is een left-shift, deze verplaatsen de bitjes met x posities naar links bv. 1<<3 komt overeen met 0x80. Dat is gewoon een trucje om eenvoudig de waarde van een bit binnen een byte te bepalen. De compiler vertaalt deze operatie automatisch naar de correcte waarde.
Kan zo'n define dan ook bv 4 lijntjes code vervangen?
Citaat van: conducteur op 02 november 2013, 19:34:49 PM
Kan zo'n define dan ook bv 4 lijntjes code vervangen?
Ja en nee...
Technisch kan het wel, een define is eigenlijk een macro die tijdens de compilatie vervangen wordt door de code die gedefinieerd werd; maar in de praktijk vervang je dit echter beter door een subroutine.
De code wordt dus korter, maar het vreet nog evenveel geheugen...
En ga ik dus nu eens google raadplegen hoe dat in elkaar zit, zo'n routine...
Helemaal niet moeilijk:
int myRoutine(int param2) {
return param2 +1;
}
void main() {
int myVar;
myVar = myRoutine(2);
myVar = myRoutine(5);
}
En ik kan Patrick voor alle raadgevingen alleen maar bijtreden.
Overzicht en onderhoudbaarheid van de code zijn zeker even belangrijk als de werking er van!!
Naarmate je meer zal programmeren wordt dit uiteindelijk een automatisme.
Geert
Citaat van: Sattrickske op 02 november 2013, 20:15:53 PM
int myRoutine(int param2) {
return param2 +1;
}
void main() {
int myVar;
myVar = myRoutine(2);
myVar = myRoutine(5);
}
Ik weet het, ik ben een zagevent, maar voor mij is dit toch veel duidelijker (plaatsing van de haakjes):
int myRoutine(int param2)
{
return param2 +1;
}
void main()
{
int myVar;
myVar = myRoutine(2);
myVar = myRoutine(5);
}
En volgens mij niet alleen, cfr een artikel in de laatste Elektor...
Anderhalve decennia geleden heb ik vaarwel gezegd tegen C/C++ en ben me gaan bezighouden met (in mijn ogen) betere talen voor RAD (Rapid application development). Zo ben ik voor PC programma's bij Delphi terecht gekomen (laat zowel high-level als low-level programmering toe) en voor µC's bij JAL (een op Pascal gebaseerde taal die ook ASM toe laat).
Voor mij primeert de 'leesbaarheid' van de code. Als ik vandaag in een inspirerende bui ben en hopen code produceer, wil ik binnen drie jaar nog weten wat ik toen geschreven heb (ook al staat er weinig of geen commentaar in de code). Het inspringen en codeblokken aan elkaar hangen vind ik daarbij een minimum moeite.
Een voorbeeldje in Object Pascal zonder commentaar in de procedure:
(http://www.pctoytoy.be/2013/20131102_1.jpg)
Daar is toch duidelijk te zien welke code bij welke sprong hoort?
[Edit] Niet dat ik iemand wil bekeren tot een andere taal, maar houd de regels van andere talen ook in C/C++ aan en je hebt duidelijk leesbare code.
int stappen(int param2) {
//hier subroutine code//
return param2 +1;
}
void main() {
//hier programma//
int myVar;
stappen= stappen(2); // ga naar subroutine
//hier rest porgramma//
}
Zo dus?
Code styling conventies zijn geen wetten, enkel richtlijnen, dus eenieder doet in feite zijn goesting. De huidige voor C en C++ kan je hier vinden: http://gcc.gnu.org/codingconventions.html (http://gcc.gnu.org/codingconventions.html) en http://www.possibility.com/Cpp/CppCodingStandard.html (http://www.possibility.com/Cpp/CppCodingStandard.html)
Wat betreft braces (accolades), beiden zijn toegelaten en maken niks uit. Alleen dient eenieder binnen hetzelfde team dezelfde formatting te gebruiken, zoniet wordt het moeilijk om 2- of 3-way compares te gaan uitvoeren. De keuze van de braces op dezelfde lijn of de lijn eronder is puur psychologisch. Ik verkies ze op dezelfde lijn omdat ik dan op m'n scherm veel meer code kan lezen en minder hoef te scrollen. Een if/else comibinatie kost bij mij 5 lijntjes, in jouw geval 8...
Als de indents juist staan maakt het geen bal uit waar de braces staan, een moderne editor geeft trouwens meteen de matching brace als je het broertje of zusje aankilkt.
Waar ik nu werk, wordt alle opgeleverde code automatisch gecontroleerd op deze conventies (en ja, de braces staan hier op dezelfde lijn). De meeste developers hebben een automatische formatter in hun editor die ervoor zorgt dat de code altijd juist geformatteerd is. Zoniet kost het hun punten...
By the way, de code formatter van MPLAB X (UI voor PICs) gebruikt dezelfde regels als die van mij.
Maar nogmaals, ieder z'n goesting, zolang je maar hetzelfde doet als de rest van je team.
Citaat van: conducteur op 02 november 2013, 21:28:10 PM
Zo dus?
Ja, maar opgelet, je gebruikt dezelfde naam voor je variabele en functie. Kan verwarrend zijn, maar in theorie kan het wel.
Citaat van: Sattrickske op 02 november 2013, 21:50:09 PM
...Maar nogmaals, ieder z'n goesting, zolang je maar hetzelfde doet als de rest van je team...
Ik speel meestal 'solo-slim' (http://nl.wikipedia.org/wiki/Wiezen) ;)
Citaat van: PeterC op 02 november 2013, 21:57:12 PM
Ik speel meestal 'solo-slim' (http://nl.wikipedia.org/wiki/Wiezen) ;)
Dan hebde gij meer chance dan ik, bij kleurenwiezen heb ik dat nog maar één keer gehaald ;D
Ik verkies ook om meer lijnen code ineens op een scherm te kunnen zien, dus haakjes op dezelfde lijn.
main () {
codelijn1;
codelijn2;}
De indents maken duidelijk wat de blokken zijn. Let wel, toen ik pas in C begon deed ik dit ook niet. Maar na een tijd begin je de voorkeur te geven om gemakkelijk een overzicht te zien in de talloze lijnen code.
Geert
Citaat van: MickeyMouse op 02 november 2013, 22:23:30 PM
Ik verkies ook om meer lijnen code ineens op een scherm te kunnen zien, dus haakjes op dezelfde lijn.
Ik 'speel' dus Solo of Solo-Slim... :D :D :D
Ik probeer ook zelf de structuur aan te houden ( { en } op dezelfde tab onder elkaar, extra insprong voor dei blok code) maar dat loopt dan in de knoei door die blok in bv een while lus te gaan steken edm en wijzigingen en loopt het in het 100...
In de editor die ik gebruik voor html zit er een automatische formatter, zit zoiets ook in MPLAB?
En nu terug naar de routines en subroutines aub ;) [size=78%] [/size]
In de paar IDE's die ik gebruik, zit de mogelijkheid om je codeblok te selecteren en dan met één tab of shift-tab gans dat blok te doen in- of uitspringen.
Dat lukt ook, maar sublime (nu niet het meest krachtige programma, kan met een druk op de knop, gans je code just plaatsen).
Yep, de automatische formatter zit ook in MPLAB X, de oude MPLAB heeft dit niet... En Peter's trucje met de tab werkt bij mij in alle code editors die ik ken...
subroutines: okidoki... was er nog een probleem?
Morgen probeer ik het even, de routines, voor vandaag genoeg C gezien... Voor de rest gaat het traag maar beetje bij beetje vooruit...
Als ik regelmatig eens wat probeer moet het project toch binnen handvol maanden al (gedeeltelijk) werken...
Ik zal dus blijkbaar eens moeten updaten van m'n versie 8 naar ?
Die routines zijn geen noodzaak hoor. Het zal je wel helpen om later je code nog aan te passen.
Als je vindt dat sneller vooruit kan zonder die routines, mag je dat wat mij betreft gerust doen. Later kan je nog altijd je code optimaliseren, maar dan doe je dus dubbel werk. Ik verkies ervoor om het meteen correct uit te voeren. En meestal besparen de routines me een hoop miserie omdat ik niet meer wijs geraak uit m'n code wanneer alles in één grote routine zit.
Citaat van: conducteur op 02 november 2013, 22:49:23 PM
... Voor de rest gaat het traag maar beetje bij beetje vooruit...
Dat is het leerproces dat je nu doorloopt. En het siert je dat je volhoudt!
En met een beetje hulp komt iedereen er!
Ik heb vorig jaar in een paar lessen de very basic (poorten setten, lezen, delay, if, for, while, switch,..) geleerd van C, maar dingen zoals die registers instellen, subroutines, interrupts, timers edm niet gedaan... -
Ik had het programma ook in Flowcode kunnen maken, een grafische programmeertaal waar je wat blokjes moet slepen in een flowchart en dan was het wellicht al af, maar dan heb ik niet echt een programmeertaal mee geleerd...
Nu ik toch bezig ben, kan ik het maar goed doen en starten in C, en die paar struikelblokken (met vallen en opstaan) leren zeker?
Dus die routines probeer ik morgen uit, ze zullen zeker van pas komen in het uiteindelijke programma. (de stappenmotor zal vanop een aantal plaatsen in het programma moeten gestuurd worden, dus het stappen samen met wat berekeningen steek je dan maar in de routine he)
Allez je hebt duidelijk de goede instelling... Da's al meteen de helft van het werk.
Laat je code maar komen, als er problemen zijn, zullen we je proberen te helpen.
Citaat van: Sattrickske op 02 november 2013, 23:34:53 PM
...als er problemen zijn, zullen we je proberen te helpen...
Patrick, ere wie ere toekomt! ;)
Ik zit met duistere gedachten: misschien moet Rian zijn ganse project even in assembler hermaken. Heel veel struikelblokken; veel vallen en soms eens opstaan, maar op het einde van de rit een totale kennis van zijn processor...
...Maar dan is Geert de enige die ter hulp kan schieten... 8)
Citaat van: PeterC op 02 november 2013, 23:46:42 PM
Citaat van: Sattrickske op 02 november 2013, 23:34:53 PM
...als er problemen zijn, zullen we je proberen te helpen...
Patrick, ere wie ere toekomt! ;)
Ik zit met duistere gedachten: misschien moet Rian zijn ganse project even in assembler hermaken. Heel veel struikelblokken; veel vallen en soms eens opstaan, maar op het einde van de rit een totale kennis van zijn processor...
...Maar dan is Geert de enige die ter hulp kan schieten... 8)
Assembler? Waar is die spoedcursus chinees :D
Citaat van: conducteur op 03 november 2013, 00:04:27 AM
Citaat van: PeterC op 02 november 2013, 23:46:42 PM
Citaat van: Sattrickske op 02 november 2013, 23:34:53 PM
...als er problemen zijn, zullen we je proberen te helpen...
Patrick, ere wie ere toekomt! ;)
Ik zit met duistere gedachten: misschien moet Rian zijn ganse project even in assembler hermaken. Heel veel struikelblokken; veel vallen en soms eens opstaan, maar op het einde van de rit een totale kennis van zijn processor...
...Maar dan is Geert de enige die ter hulp kan schieten... 8)
Assembler? Waar is die spoedcursus chinees :D
Misschien Chinees, maar de basis van µC/µP programmering! En eenmaal als je de basis onder knie hebt,... :)
Kijk eens in de datasheet van je controller: enkel assembler!
Citaat van: PeterC op 02 november 2013, 23:46:42 PM
Patrick, ere wie ere toekomt! ;)
Bwa, omdat ik de laatste 2-3 dagen effe wat actiever ben? Neen hoor, daarvoor heeft Rian ook veel hulp gehad van anderen. Dus hou het maar op
we...
En assembler is bijlange niet zo moeilijk hoor, en volgens sommigen zelfs gemakkelijker dan C. Maar ik hou het zoveel mogelijk op C omdat de code mooier en beter gestructureerd is, maar als ik realtime processing nodig (cruciale timing van beppaalde routines) dan schakel ik wel over assembler (al dan niet gemixed met C). Hier heeft Peter een serieus goed punt van assembler aangehaald: als je het kent, ken je meteen ook alle kenmerken van de processor. Assembler + datasheet = totale kennis. De C compiler doet trouwens niks anders dan de instructies omzetten naar assembler...
En de combinatie van C en assembler is nog het mooiste: assembler voor de low-level functies, die in vele gevallen ook tijdskritisch (interrupts, seriële communicatie, ...) kunnen zijn en C voor het programma zelf om makkelijker de flow te kunnen volgen.
En ja, je leert er inderdaad uw microcontroller goed mee kennen.
Maar goed, stap voor stap is de beste keuze en vooral niet opgeven!!!
De A (A0-A4) poort op de µC is eigenlijk voorzien om een LCD aan te sturen...
Daarover staat een redelijke uitleg hoe dat moet in de cursus die ik nog staan heb, hebben we wel niet gedaan in de les maar lijkt me niet zo moeilijk:
www.treinbaanrian.be/downloads/Microcontrollers_in_C_met_MPlab_deel2.docx
Kan ik zomaar elk lcd display daarmee aansturen? Deze bv:
http://www.conrad.be/ce/nl/product/183047/ (http://www.conrad.be/ce/nl/product/183047/)
Assembler is volgens mij enkel de moeite als je lang met één zelfde processor kan blijven werken of als je echt het onderste uit de kan moet halen. Probleem als hobbygebruiker is dat processoren sneller veranderen dan wij ze gebruiken en dat voor de typische projecten de processor meestal niks staat te doen ipv te werken. Komt daarbij nog dat moderne compilers vaak efficientere assembler maken van je C programma dan je zelf kan als je geen super-specialist bent.
Trouwens al heel lang geleden dat ik nog assembler in een datasheet gezien heb. Geen enkele Freescale processor waar ik de laatste 10 jaar mee gewerkt heb om te beginnen. en bij die Atmel stond er ook niets.
Citaat van: conducteur op 03 november 2013, 11:38:21 AM
De A (A0-A4) poort op de µC is eigenlijk voorzien om een LCD aan te sturen...
Daarover staat een redelijke uitleg hoe dat moet in de cursus die ik nog staan heb, hebben we wel niet gedaan in de les maar lijkt me niet zo moeilijk:
www.treinbaanrian.be/downloads/Microcontrollers_in_C_met_MPlab_deel2.docx
Kan ik zomaar elk lcd display daarmee aansturen? Deze bv:
http://www.conrad.be/ce/nl/product/183047/ (http://www.conrad.be/ce/nl/product/183047/)
Zomaar elke LCD, nee. De LCD moet een 4-bits interface hebben en zoals in je doc beschreven staat de E, RS en RW pinnetjes hebben. Deze die je van Conrad hebt opgegeven is een goede (kijk maar in de datasheet), maar wel aan de dure kant. Zoek eens op eBay achter LCD 1602, als je effe geduld hebt (maandje levertijd vanuit China), kost deze je 2€.
De LCDs die ik gebruik zouden bij jou niet werken; ik gebruik de touchscreens die bv. ook in GSMs gemonteerd worden. Deze zijn iets duurder (10-15€) maar zijn volledig grafisch en met kleurtjes. De interface is in mijn geval SPI (dezelfde als de seriële interface van de microcontroller); maar het kan ook 8/16 bit parallel zijn.
Dus uitkijken wel type LCD je aanschaft, altijd de datasheet raadplegen... In principe zou elke 1602 LCD goed moeten zijn voor jou.
zoek eens op "arduino LCD" op eBay.
De displays die je dan vindt zijn 99,9% ook bruikbaar op PIC interfaces.
http://www.benl.ebay.be/sch/i.html?_trksid=p3984.m570.l1313&_nkw=arduino+lcd&_sacat=0&_from=R40
En vooral dit : leer eerst kruipen en dan stappen, voor je wil gaan lopen.... Informeer je op voorhand (zoals je nu doet ! prima...)
Ik heb ook die fout gemaakt en daardoor zijn er al heel wat (soms dure) componenten in de vuilbak beland !
https://www.youtube.com/watch?feature=player_embedded&v=chdEpyhh_EM ??? ::) Just iemand blij gemaakt blijkbaar, als je hen mag geloven ;D
displaytjes gekocht bij Conrad, Rian ? :-)
Of toch niet ... ?
Om daar even op terug te komen, ik heb er wel nog een stuk of 2 klaar liggen voor later.
Als je niet te ver uit de buurt woont (Aalst-OVL) mag je er altijd eens ene komen "lenen" voor een paar weekjes om te testen.
Ja, die bij Conrad, en die zijn wellicht vrijdag met beetje chance thuis.
Citaat van: conducteur op 05 november 2013, 23:18:52 PM
https://www.youtube.com/watch?feature=player_embedded&v=chdEpyhh_EM ??? ::) Just iemand blij gemaakt blijkbaar, als je hen mag geloven ;D
Hihihi, daarom zijn de displaytjes dus zo duur bij Conrad ;)
Heb geen goesting om weer 30 dagen te moeten wachten, ben nu al 30 dagen aan 't wachten op die Chinese graveerfreesjes die maar niet toekomen...
Als die per boot komen zijn ze direct 4 weken onderweg. Dan nog 10 werkdagen bij de douane en 5 met de post tot bij jou. Tegen kerstmis misschien? Als ze niet gaan staken :D
Heb dan toch al een kerstcadeau dat nuttig is ;D
Citaat van: Havoc op 07 november 2013, 20:03:26 PM
Als die per boot komen zijn ze direct 4 weken onderweg. Dan nog 10 werkdagen bij de douane en 5 met de post tot bij jou. Tegen kerstmis misschien? Als ze niet gaan staken :D
Komen tegenwoordig altijd per vliegtuig, maar 't zijn beide douanes (Chinese en Belgische/Nederlandse) die traag zijn. Als je een trackingnummer hebt, moet je eens kijken waar ze 't langste blijven zitten: bij de douane...
www.treinbaanrian.be//downloads/eindwerk/driver%20v2%20schema.pdf (http://www.treinbaanrian.be//downloads/eindwerk/driver%20v2%20schema.pdf)
www.treinbaanrian.be/downloads/eindwerk/driver%20v2.pdf (http://www.treinbaanrian.be/downloads/eindwerk/driver%20v2.pdf)
M'n driver voor de stappenmotor zal ik opnieuw maken, versie 1 telt nogal wat 'fouten' en 'tekortkomingen' en is dus voor verbetering vatbaar!
EDIT: Ik ben erg teleurgesteld, ik had een fanfare verwacht met een lcd-display in een doosje, maar ik kreeg enkel een camionette van TNT post daarnet aan de deur... ??? Gelukkig had ie het pakje mee.
Zeer proper printje! Ik zie dat je externe labelling in Eagle aan de praat hebt gekregen ;). Dit maakt je schema meteen pak leesbaarder omdat er veel minder draden in de weg lopen.
Je kan je printje wel nog wat verbeteren door wat dunnere baantjes te gebruiken en daardoor kan je minstens 2 draadbruggen uitsparen. De massa draadbrug kan je zo tussen 2 pinnetjes van je connector blok doorsturen. En je motor 1-2 kan je dan ook naar pinnetje 21 tussen de 2 rijen pootjes van je driver sturen. En met wat zoeken zal je derde draadbrug ook nog wel weg krijgen.
Draadbruggen kunnen in principe geen kwaad voor dit soort toepassingen, maar hoe minder hoe beter (minder knip/strip/soldeer werk).
PS. Wat is belangrijker? De fanfare of je LCD schermpje? ;D
Stel je voor dat ze zo'n lcd display echt per fanfare zouden thuis brengen... ::)
-->http://www.produktinfo.conrad.com/datenblaetter/175000-199999/183047-da-01-en-LCD_MODUL_16X2_LED_GE_C1602B_CFH_JT_R.pdf
Pin 1) 0V
Pin 2&3) 5V
Pin 4-5-6) naar µC? maakt het uit wat ik waar mee verbind? (A poort)
Pin 7-14)Niet nodig?
Pin 15) +5V
Pin 17) voor groene achtergrondverlichting --> 0V
Pin 16 & 18 (rode en blauwe achtergrondverlichting) niet gebruikt...
Ben ik just bezig?
Pinnetje 3 zet je best via een potmeter (variabele spanning voor het contrast van de LCD). Dan kan je de intensiteit van het contrast van de LCD regelen, bij jou staat ie op 'vollen bak'. Kijk naar pagina 8 voor de correcte aansluiting.
4-5-6, maakt inderdaad niet uit zolang het maar uitgangen zijn op je µC; PortA is goed genoeg, als je de ADC uitschakelt.
!!!! 7-14: juist wel nodig !!!! Dat zijn je data lijnen. Als je in 4-bit werkt, heb je enkel DB0-DB3 nodig. Als je in 8-bit werkt, allemaal (DB0-DB7). 8-bit is eenvoudiger om te programmeren en minstens 2x sneller. Voor de meeste toepassingen is 4-bit echter meer dan voldoende.
Ik heb tussen pinnetje 15 (voeding van de backlight) en m'n 5V een weerstandje van 47 ohm gestoken, ik vond op mijn displays de backlight nogal sterk...
Rian,
Kijk hier (http://www.pctoytoy.be/jal/16f684/16f684_4.htm) eens: een eenvoudig 'Hello World' programma (en schema) met een PIC en LCD. LCD backlight is in het schema wel niet aangesloten, maar 47 ohm zoals Patrick zei.
Je brengt me toch even in verwarming eh verwarring Peter,
http://www.pctoytoy.be/jal/16f684/16f684_hello.pdf-->pin 5 moest toch naar de µC, volgens Patrick?
-->Bij jouw is D4-D7 aangesloten, wat is het nu? D0-D3 of D4-D7?
CiteerPinnetje 3 zet je best via een potmeter (variabele spanning voor het contrast van de LCD). Dan kan je de intensiteit van het contrast van de LCD regelen, bij jou staat ie op 'vollen bak'. Kijk naar pagina 8 voor de correcte aansluiting.
4-5-6, maakt inderdaad niet uit zolang het maar uitgangen zijn op je µC; PortA is goed genoeg, als je de ADC uitschakelt.
!!!! 7-14: juist wel nodig !!!! Dat zijn je data lijnen. Als je in 4-bit werkt, heb je enkel DB0-DB3 nodig. Als je in 8-bit werkt, allemaal (DB0-DB7). 8-bit is eenvoudiger om te programmeren en minstens 2x sneller. Voor de meeste toepassingen is 4-bit echter meer dan voldoende.
Ik heb tussen pinnetje 15 (voeding van de backlight) en m'n 5V een weerstandje van 47 ohm gestoken, ik vond op mijn displays de backlight nogal sterk...
Foutje van mij, 't moet inderdaad DB4-DB7... Sorry!
R/W kan je permanent op 0 zetten (dus steeds in write modus), maar dan kan je de LCD niet meer uitlezen. Heb je niet altijd nodig (zie pagina 13 van de datasheet)
Citaat van: Sattrickske op 10 november 2013, 14:41:39 PM
...R/W kan je permanent op 0 zetten (dus steeds in write modus), maar dan kan je de LCD niet meer uitlezen. Heb je niet altijd nodig (zie pagina 13 van de datasheet)...
Dat lezen gebruik je alleen als je de interne registers van je LCD wil raadplegen (zet je instellingen ergens in je controller en dan heb je die van je LCD niet meer nodig) en om de busy-vlag te lezen. Gebruik vertragingslussen in je code en dan hoef je die vlag ook niet te lezen (die LCD modules zijn 'vrij' traag).
De bibliotheken die ik ken zijn erop gebaseerd om enkel E, RS en de 4 datalijnen aan te sturen. Welk signaal op welke poort komt, bepaal je vooraf en laat dat weten aan je bib. Ik vermoed dat er in C ook dergelijke bibilotheken bestaan.
(http://www.treinbaanrian.be/images/eindwerk/stappenmotor.JPG)
Nieuwe motor voor het project: van 0,5Nm naar 2,5 Nm. Nu nog wachten op de CNC freesmachine om een nieuwe driver te kunnen maken voor deze motor.
-->het programmeren in C heb ik opgegeven voor dit project, terug naar flowcode. Wat primitiever, maar heb ondertussen al een programma dat volgens mij redelijk wat moet doen, maar kan het dus niet testen op dit ogenblik. Wat niet wilt zeggen dat ik het stop: een volgend projectje met µC is zo complex niet en zal ik terug proberen in C. Maar eerst GIP afwerken.
Ik vind het bewonderenswaardig dat je verder blijf werken aan dit project.
Het is knap.
Examens zijn bezig, maar toch kleine vooruitgang hier:
Het frezen van pcb'tjes lukt nog niet zo goed omdat de cnc niet voorzien is van een constante hoogteregeling, maar met dank aan David, zou daar binnenkort verandering in moeten komen.
In afwachting van heb ik het bedieningspaneel maar opgebouwd uit een restje gaatjesprint, het lcd gemonteerd en potentiometer voor het contrast, en de 8 drukknoppen, met elk hun eigen weerstandje gesoldeerd. 0 en 5 volt al overal doorverbonden.
Nu zit ik met een dilemma:
Ofwel plan ik het te doen zoals eerst het geval was, alles aansturen door de ene µC, ofwel plaats ik een extra µC op het paneeltje (er is nog plaats voor een 16f876) die dan het lcd aanstuurt en de knoppen inleest, en communiceert met de hoofdµC in het systeem via een of andere seriele bus.
De deadline voor dit project is ergens na Pasen, het is dan opendeurdag in mijn vorige school, en zou als ik ga graag kunnen zeggen dat het ding werkt na al die tijd. Moet ik daar aan beginnen met het risico dat het een extra element is dat niet werkt? En wel belangrijk is, zonder bedieningspaneel zal er weinig mee aan te vangen zijn....
Het zou me toelaten met dat ene bedieningspaneeltje nog andere dingen aan te sturen of te controleren die dan verbonden zijn met dezelfde bus... Het zou ook een deel bedrading besparen nu heb ik 5v+gnd & 8x drukknop + 6 draden als ik nog kan tellen nodig voor m'n lcd, dat zou dan kunnen vervangen worden door 5V+GND+paar draden voor de communicatiebus...
Ik moet dan wel die communicatie in orde krijgen, en zien dat de beide µC synchroon werken... Ze moeten beiden reageren als een knop wordt ingedrukt, of er info voor het lcd moet verzonden worden....
Doen of niet?
Ik dacht dat je al een diepteregelaar had op je CNC, want zonder is het verrekte moeilijk. Je moet print perfect vlak kunnen leggen, 1/10 van een mm ernaast en je freest niet diep genoeg of net te diep... Ik ga bij mij volgende week eens een poging ondernemen om eens 2 baantjes op een afstand van 0.5mm van elkaar te frezen met elk van de baantjes met een breedte van bijna 0.3mm. Heb daarvoor titanium-coated freesjes aangeschaft met een punt van 0.1mm. Ben zelf benieuwd... Als het lukt, kan ik TQFP chips met een pitch van 0.5mm op m'n printjes gebruiken.
Voor je paneel:
Als het paneel maar eenmaal moet dienen, zou ik geen aparte µC voorzien maar alles op één en dezelfde µC aansluiten.
Als je het wil herbruiken heb je 2 mogelijkheden:
- aansluiten via flatcable op één µC
- 2e µC inschakelen en communiceren over SPI
SPI met PICs is relatief eenvoudig als je PICs hierop voorzien zijn. Voor de 16f876 is dat al geen probleem, welke is je andere µC alweer?
Je kan je bedieningspaneel dan aansluiten met 6 draden:
- 2 voor de voeding (GND en +5V)
- 4 voor de SPI (/CS, CLK, SDI en SDO)
Als er maar één device op je SPI bus zit, kan je de /CS laten vallen.
Je kan nog een stapje verder gaan en bv. 1-wire gaan gebruiken, dan heb je 2 of 3 draden nodig. Maar deze communicatie is iets moeilijker om op te zetten.
Persoonlijk gebruik ik zoveel mogelijk SPI, is zeer snel en eenvoudig te implementeren. 1-wire gebruik ik ook, maar veel minder (temperatuursensoren bv.), deze is veel lastiger om te implementeren (lastige handshake).
De andere is het grotere 40 pins exemplaar, 16f887... Ik hoop dat de diepteregeling in orde komt, want 0,8mm breedte en evenveel tussenruimte lukt niet altijd even goed...
1Wire heb ik al veel gebruikt - voor eenvoudige communicatie (één richting, één master en één slave, en vast aantal bits)
=> geen handshaking nodig, slave kan via interrupt communiceren en "intussen" nog iets anders doen, ...
Ik denk dat ik het gewoon zal houden, en als het eenmaal werkt het even zo laten, en dan kan ik nog altijd dit veranderen...
SPI tussen een 16F887 en een 16F876 is heel simpel te realizeren, beide chips zijn uitgerust met SPI. Juist kwestie van effe in de datasheet welke pinnetjes je moet gebruiken en in je MPLab de juiste instellingen in te geven (bus mode en snelheid). Daarna is het gewoon data lezen en schrijven via het SPI register.
Ik kan je aanraden om SPI te gebruiken, want in de µC wereld is dit wijd verspreid. Ik gebruik SPI om kant-en-klare Ethernet modules, SD card readers, LCD displays ed. mee aan te spreken. Die modules koop voor een prikje op eBay of AliExpress of elders.
Daarnaast gebruik ik het ook voor de communicatie tussen m'n µC.
1-wire gebruik ik alleen als het niet anders kan (sommige temp. sensoren of RFID toepassingen), want je zit met vervelende timings voor je reset puls, present puls, master read en master write. (Da's wat ik bedoelde met protocol in m'n vorige post).
SPI in C implementeren voor PIC bedraagt 10 lijnen code (polling of interrupt). M'n 1-wire 'library' is meer dan 50 lijnen (moet effe checken, want is al een tijdje geleden).
C heb ik voorlopig opgegeven, enkele details die ik nog niet weet doen het niet vooruitgaan, ik ga (voorlopig) terug naar ofwel flowcode (wellicht) of JAL als ik m'n boek tijdig krijg van de boekhandel. Hoe zit dat in JAL voor SPI?
Flowcode ondersteunt blijkbaar ook SPI en I²C, maar ik moet ook nog eens uitzoeken hoe het precies moet...
Hoe zit dat trouwens, want als je data verstuurt, moet die ook ontvangen worden, hoe weet je dat de data is toegekomen? Dat zit verwerkt in het protocol zeker, die dan de andere µC even doet 'stoppen'?
Citaat van: conducteur op 17 januari 2014, 11:51:27 AM
C heb ik voorlopig opgegeven, enkele details die ik nog niet weet doen het niet vooruitgaan, ik ga (voorlopig) terug naar ofwel flowcode (wellicht) of JAL als ik m'n boek tijdig krijg van de boekhandel. Hoe zit dat in JAL voor SPI?
Flowcode ondersteunt blijkbaar ook SPI en I²C, maar ik moet ook nog eens uitzoeken hoe het precies moet...
Hoe zit dat trouwens, want als je data verstuurt, moet die ook ontvangen worden, hoe weet je dat de data is toegekomen? Dat zit verwerkt in het protocol zeker, die dan de andere µC even doet 'stoppen'?
SPI is een low-end hardware protocol, eerder een technologie. Het uiteindelijke protocol bepaal je zelf. Als je zeker wil zijn dat de data aan de andere zijde ontvangen is, kan je vragen om een ofwel een simpele ACK of een checksum van de ontvangen data terug te sturen. Checksum is te verkiezen omdat je dan weet dat de ontvangen data correct is; met ACK weet je enkel 'hij heeft IETS ontvangen, maar wat?'
Wat noem je stoppen? SPI is razendsnel, als je via interrupts werkt (er is er eentje op de SPI input buffer: SPIF, die je enabled via SPIE) wordt je code idd even stilgelegd om de interrupt routine te bedienen. Dus heel veel tijd zal er niet verloren gaan, als je de code in de interrupt routine kort houdt. Met polling moet je meer uitkijken, omdat daarvoor meestal 'tijdrovende' loops gebruikt worden.
Met JAL kan ik je niet helpen, dat is helemaal niet mijn dada (of ding zoals ze Nl zeggen). Google is your friend?
Hoe zit dat eigenlijk met die kristallen, tot nu toe heb ik die paar PIC projectjes al altijd voorzien van een extern kristal. Heb ik die nodig voor de PIC op het bedieningspaneel, of bij seriele communicatie? Wanneer wel/niet?
Ik werk altijd met de interne oscillator. Deze kan je ook nog is kalibreren. En tot nu toe nog nooit een probleem gehad met timing. De interne oscillator is wel gevoelig aan temperatuur schommelingen, maar de meeste van onze projectjes zijn binnenhuis en gewoonlijk bij kamertemperatuur.
Geert
Citaat van: conducteur op 19 januari 2014, 11:24:03 AM
Hoe zit dat eigenlijk met die kristallen, tot nu toe heb ik die paar PIC projectjes al altijd voorzien van een extern kristal. Heb ik die nodig voor de PIC op het bedieningspaneel, of bij seriele communicatie? Wanneer wel/niet?
Geert was me net voor :)
Enkel bij preciese timing gebruik ik een kristal of om met een 18F PIC vanuit een 20 MHz Xtal via de ingebouwde PLL 96 MHz te halen voor USB communicatie.
Citaat van: conducteur op 17 januari 2014, 11:51:27 AM
...Hoe zit dat in JAL voor SPI?
Hier (http://justanotherlanguage.org/content/jallib/tutorials/tutorial_spi_introduction). Zelf nog geen behoefte gehad aan SPI. Ik los (voorlopig?) nog alles op met I²C.
Citaat van: PeterC op 19 januari 2014, 11:39:08 AM
Enkel bij preciese timing gebruik ik een kristal of om met een 18F PIC vanuit een 20 MHz Xtal via de ingebouwde PLL 96 MHz te halen voor USB communicatie.
USB communicatie... Ik hoop ooit wel eens 'van je ervaring hiermee' gebruik te maken. Ik denk er ook aan dit eens toe te passen.
En de PLL klok versneller, ook daar heb ik geen ervaring mee. Ik kom nog steeds kloksnelheid te kort voor mijn zelfbouw centrale.
Geert
@Geert: als je die USB communicatie in ASM gaat schrijven, wens ik je veel plezier :o :o :o
In JAL werkt die communicatie zonder probleem (zowel als HID of als seriële emulatie). Alleen met de timers heb ik problemen. Intern zou de µC op 48MHz moeten werken, maar als ik mijn timers bereken, kom ik op 32MHz clock uit... Bizar...
De knoop doorgehakt: het wordt met 2 µC in het systeem... (nu wel met 16f887 2x, de voorziene controller lag blijkbaar niet in z'n doosje en zo'n 40 pins krijg ik er wel op. Misschien wat overkill met redelijk wat I/O op overschot nu)...
LCD aangesloten op de Dpoort
D4-D7 van lcd op D0-D3 in respectievelijke volgorde...
D4 RS
D4 Enable
De 8 knopjes op B-poort, dan is de c vrij voor SPI, als ik goed gekeken heb heb ik daar C4-C6 nodig?
eens proberen of ik er 'hello world' uit krijg...
Citaat van: conducteur op 19 januari 2014, 19:28:10 PM
D4-D7 van lcd op D0-D3 in respectievelijke volgorde...
D4 RS
D4 Enable
Gaat niet werken, ik vermoed dat je de laatste op D5 of zoiets gaat hangen?
Citaat van: conducteur op 19 januari 2014, 19:28:10 PM
De 8 knopjes op B-poort
Meer dan 4 knopjes hang je best aan een matrix, bespaart wat pinnetjes. Maar ja, je had er op overschot dacht ik te lezen...
Citaat van: conducteur op 19 januari 2014, 19:28:10 PM
dan is de c vrij voor SPI, als ik goed gekeken heb heb ik daar C4-C6 nodig?
Paragraaf 13.3 van de datasheet voor PIC16F887:
SDO = RC5
SDI = RC4
SCK = RC3
/SS = RA5 (als er maar één SPI device is, mag je deze op de slave aan de massa hangen; op de master heb je die niet nodig)
Ik weet niet waar je C4-C6 bent gaan halen, maar kijk altijd je datasheet na.
Nog een kleine opmerking, probeer in je posts de PIC poorten te benoemen zoals Microchip dat doet. Dat maakt het voor mij (en andere Microchip adepten) iets makkelijker om te lezen.
Bv. PortD = RD0..RD7
Voila, ik heb me er volledig door deze draad gelezen.
Van de elektronica begrijp ik niets of heel weinig, de programmeertalen zijn me niet bekend.
Maar toch met plezier alles doorgenomen en zeker slimmer geworden.
Sowieso dikke proficiat Rian met je doorzetting, deze is helemaal de regel niet meer tegenwoordig.
Welke richting volg je nu?
Citaat van: Sattrickske op 20 januari 2014, 19:40:51 PM
Citaat van: conducteur op 19 januari 2014, 19:28:10 PM
D4-D7 van lcd op D0-D3 in respectievelijke volgorde...
D4 RD4 RS
D4 RD5 Enable
Gaat niet werken, ik vermoed dat je de laatste op D5 of zoiets gaat hangen?
Citaat van: conducteur op 19 januari 2014, 19:28:10 PM
De 8 knopjes op B-poort
Meer dan 4 knopjes hang je best aan een matrix, bespaart wat pinnetjes. Maar ja, je had er op overschot dacht ik te lezen...
Citaat van: conducteur op 19 januari 2014, 19:28:10 PM
dan is de c vrij voor SPI, als ik goed gekeken heb heb ik daar C4-C6 nodig?
Paragraaf 13.3 van de datasheet voor PIC16F887:
SDO = RC5
SDI = RC4
SCK = RC3
/SS = RA5 (als er maar één SPI device is, mag je deze op de slave aan de massa hangen; op de master heb je die niet nodig)
Ik weet niet waar je C4-C6 bent gaan halen, maar kijk altijd je datasheet na.
-Inderdaad lcd hangt op RD0 tot RD5 (typfoutje, nu zou dat toch moeten werken?)
-De matrix: inderdaad, ik heb voldoende I/O, ook moest ik voortgedaan hebben met de originele opstelling met één microcontroller. En misschien ook uit praktische overwegingen? Je leest direct de juiste waarde in...
-bedankt voor de hulp ivm SPI (mogelijk ook typvoutje)
bedankt HYA, het is heel tof te lezen dat ook non-techneuten het draadje eens gezien hebben! bedankt! Nu volg ik elektronica aan de hogeschool Vives te Oostende...
Yep, zo zou het moeten werken.
De matrix was maar een suggestie, onthou dit voor later wanneer je IO pinnetjes wil besparen. Je hebt toch een serieus stukje software nodig voor zo'n matrix. Als je pinnetjes genoeg hebt, is het inderdaad makkelijker om ze rechtstreeks aan de IO te hangen. Gewoon effe de TRIS van de betreffende bits van de poort in de goede richting zetten (input=TRIS=1 ;)) en lezen maar...
De drukknoppen worden al correct ingelezen (vlug eens flowcode een testprogramma gemaakt), nu dat lcd nog... Dat wordt wat moeilijker denk ik...
en dan de stok in het hoenderhok .... (sorry mannen, kon het me deze keer echt niet laten)
"bestaan daar geen libraries voor ?" -> Bij de Arduino SDK heb je libraries voor al die soorten apparaten en toestanden die je gewoon kan "includen" in je programma, en die bieden je dan functies om te gebruiken in je code. Simpel als wat ..... Je moet natuurlijk wel nog kunnen programmeren, maar je zit al meteen een laag of 2 hoger "in het abstracte" ipv direct met je neus in de registers, wat het dan weer moeilijker maakt om prciese timing te programmeren, maar is dit altijd echt nodig ?
Het gebruik van bibliotheken maakt het leven van de programmeur een stuk makkelijker. En ik ben zelf van nature lui (typisch aan ingenieurs of gewoon mijn karakter ?).
Enfin, soit, kompleet irrelevant en off topic, maar ik meld intussen toch even dat ik dit in stilte volg.
Ja en nee...
Eerst en vooral, je praat over Arduino, da's een platform; je vertrekt van een bord/module gebouwd rond één bepaald type processor (ARM Cortex M0 of M3) waarop je vanalles kan inpluggen (shields). Voor elk van die shields is er wel ergens één of andere goedhartige developer die daarvoor een libje gemaakt heeft. Dat werkt heel mooi en is heel handig zolang je bij dit platform blijft (je kan het bijna vergelijken met Plug and Play). ARM/Arduino heeft daar heel handig op ingespeeld en een hele community rond gebouwd.
Deze methode heeft wel een paar nadelen, om er een paar te noemen:
- de prints bevatten meestal overtollige componenten voor 'jouw' project en vallen dus groter uit
- de libraries sleuren heel vaak overbodige code mee, omdat ze proberen iedereen te gerieven.
De PIC (Microchip) wereld werkt ietsje anders, daar zijn er honderden verschillende platformen te vinden, omdat ze veel meer diversifiëren en zich niet vastpinnen op één platform. Gevolg is dat er dan ook een veelvoud aan libraries bestaan, en hierdoor veel minder bekend zijn (iedere fabrikant van PIC modules heeft zo z'n eigen bibliotheek). Bv. Mikroe heeft er zo eentje.
PIC legt zich niet direct toe op de hobbyist, die effe -met alle respect- een schakelingetje in mekaar wil flansen zonder eigenlijk een bal af te weten van elektronica; PIC richt zich eerder op de electronics engineers en de industrie.
Nadeel hiervan is dat je 1000en verschillende schakelingen hebt met PICs en daardoor wordt het verrekte lastig om standaard libraries hiervoor te maken.
Nu, begrijp me niet verkeerd, ik heb geen specifieke voorkeur voor PIC of ARM/Arduino. Ik gebruik ze allebei, maar kies wel in functie waar ze het best tot hun recht komen. En soms durf ik af en toe wel modules voor een Arduino aan een PIC te koppelen, en dan kan je gewoon de library van de Arduino shield effe porten naar PIC. Da's meestal kwestie van een paar defines aan te passen en klaar is kees.
Tot nu toe is m'n keuze voor 8bit modules, bijna altijd PIC geweest, omdat ik die schakelingen volledig op maat maak. Voor de 32bit is dat ARM, omdat die processoren goedkoper en makkelijker te verkrijgen zijn.
Ieder maakt zo z'n eigen keuzes, en eerlijkheidshalve, hier is geen verkeerde keuze. Zolang je maar de design regels voor iedere familie respecteert en je ze in je ontwerp kan inpassen.
klopt als een zwerende vinger, en ik heb daar dan ook geen verdere toevoegingen op, alleen dat het "Arduino" platform inderdaad een instap is, en eens je dat doorgrond hebt, kan je makkelijk zelf je boards ontwerpen rond de Atmel chips zonder die shields en zo.
Om een en ander uit te proberen heb ik aan RA2 een ledje gehangen, en de knoppen al kunnen uittesten: het ledje gaat aan als ik op een van de knoppen duw. Op het lcd zou "hello world" moeten verschijnen. Omdat ik nog eens moet uitvogelen hoe dit in C moet, dit testje gemaakt met flowcode. Een tof systeem om op grafische wijze zonder enige kennis van C een programma te schrijven, dus aan het programma kan volgens mij weinig fout zijn.. Uit het lcd komt echter weinig leven, van de bovenste rij karakters lijken volgens mij alle pixels gewoon aan te staan, de onderste rij niets.
Er hangt een knopje aan de reset ingang van de µC, met een pull-up weerstandje naar +5V, als ik die indruk om het spel te resetten reageert de lcd ook, hoewel er geen verbinding is met de lcd zelf. Er is dus toch een zekere vorm van signalen tussen beide?
ps: (n)iemand goesting om eens op een zaterdag of zondagnamiddag in februari me even op weg te helpen met dit project? De deadline voor dit project staat op de opendeurdag van m'n vorige school. Ik hoop eindelijk dan als ik ga te kunnen melden dat het ding werkt. Dat is ergens na Pasen/begin mei... Met de huidige beperkte ervaring/kennis van programmeren krijg ik het ding nooit tijdig klaar. (bv het probleem met het lcd nu, ben ik toch al aardig wat uren op aan het zoeken, de bedrading gecontroleerd, opnieuw programma gemaakt terwijl het misschien iets doodsimpel is dat ik moeilijk via het forum kan tonen/vragen?)
helaas heb ik zelf van PICs weinig (lees: geen) kaas gegeten. Anders zou ik wel es kunnen binnen wippen als ik nog eens in Blankenberge ben....
Maar ik weet niet of je veel aan mij gaat hebben nu. En om alles vanaf nul op een ander platform te herbeginnen is misschien ook niet echt meer aan de orde.
Toch bedankt, Dani! ;)
PS: zo ziet het er nu uit:
(http://treinbaanrian.be/images/eindwerk/bedieningspaneel.jpg)
In afwachting dat ik beter overweg kan met de cnc om er printjes mee te maken (hulpstuk nodig) nog een oud stuk gaatjesbord gebruikt...
Is het display geïnitialiseerd/geconfigureerd?
Geert
Door op de reset te drukken, krijg je allemaal niet geïnitializeerde pinnetjes die ook met je LCD in verbinding staan. Daardoor zie je 'm wat flikkeren. Dat bewijst (nog) niets.
Een 1602 LCD aansturen is helemaal niet zo moeilijk, hieronder m'n libje voor zo'n display in 8bit:
lcd.h
#define LCD_DATA PORTD
#define LCD_DATA_TRIS TRISD
#define LCD_E PORTBbits.RB2
#define LCD_E_TRIS TRISBbits.TRISB2
#define LCD_RW PORTBbits.RB1
#define LCD_RW_TRIS TRISBbits.TRISB1
#define LCD_RS PORTBbits.RB0
#define LCD_RS_TRIS TRISBbits.TRISB0
extern char LCDIsBusy(void);
extern void LCDCommand(unsigned char cmd);
extern void LCDInit(void);
extern void LCDPut(char data);
extern void LCDWrite(char row, char col, char *string);
lcd.c:
#include <htc.h>
#include "lcd.h"
#include "delay.h"
char blocking = 0;
void LCDInit(void) {
blocking = 1;
LCD_DATA_TRIS = 0x00;
LCD_DATA = 0;
LCD_RS_TRIS = 0;
LCD_E_TRIS = 0;
LCD_RW_TRIS = 0;
LCD_RS = 0;
LCD_E = 0;
LCD_RW = 0;
LCDCommand(0x01); //Clear screen
LCDCommand(0x38); //8 bit, 2 lines, 5x7 dots
LCDCommand(0x06); //Display not rotated, cursor shift right
LCDCommand(0x0C); //Display on, cursor off, blink off
blocking = 0;
return;
}
char LCDIsBusy(void) {
LCD_E = 0;
LCD_RS = 0;
LCD_RW = 1;
LCD_DATA_TRIS = 0xFF; //Make data port input
LCD_DATA = 0;
Delay10Us(1);
LCD_E = 1;
unsigned char busy = 0;
if (blocking == 0) {
if (LCD_DATA&0x80) {
busy = 1;
}
LCD_DATA_TRIS=0x00;
}
return busy;
}
void LCDCommand(unsigned char cmd) {
LCD_DATA = cmd;
LCD_RS = 0;
LCD_RW = 0;
LCD_E = 0;
Delay10Us(5);
LCD_E = 1;
}
void LCDPut(char data) {
LCD_DATA = data;
LCD_RS = 1;
LCD_RW = 0;
LCD_E = 0;
Delay10Us(5);
LCD_E = 1;
return;
}
void LCDWrite(char row, char col, char *string) {
LCDCommand(0x80 + 0x40 * row + col);
while (*string) {
LCDPut(*string);
string++;
}
}
Om in 4bit mode te werken dien je enkel de init methode aan te passen en de LCDPut en LCDWrite de data in 2 stapjes laten doorvoeren.
Was daar ook achter aan het zoeken, maar is al een 15-tal jaar geleden en vond niet meteen mijn sourcecode terug... :-[ :-[
Maar goed, Patrick heeft het wel bij de hand ;D ;D
en wat staat in delay.h? Die heb ik toch ook nodig?
Citaat van: conducteur op 22 januari 2014, 21:55:24 PM
en wat staat in delay.h? Die heb ik toch ook nodig?
Gewoon routines om pauzes in te lassen. Kan je makkelijk zelf schrijven met een paar loopjes...
Citaat van: Sattrickske op 22 januari 2014, 23:11:00 PM
Citaat van: conducteur op 22 januari 2014, 21:55:24 PM
en wat staat in delay.h? Die heb ik toch ook nodig?
Gewoon routines om pauzes in te lassen. Kan je makkelijk zelf schrijven met een paar loopjes...
Ik zie het, ik heb echt een expert nodig....
Citaat van: conducteur op 24 januari 2014, 08:31:14 AM
Ik zie het, ik heb echt een expert nodig....
Ik zou het anders durven stellen : je moet je toch eens wat meer verdiepen in het leren programmeren, Rian.
Sorry, man, maar wat ik hier nu zie is dat je probeert om anderen jouw werk te laten schrijven. Als je echt veel interesse hebt, dan ga je er toch helemaal voor ? Ik weet dat je niet vies bent van werk, en dat je allerlei ideetjes hebt, maar je moet ook de nodige tijd maken om ze dan te realiseren. Ik ben zeker dat al de tijd die je steekt in het navragen, postst lezen, testen van anderen hun werk, even nuttig kan gebruikt worden om er bvb eens een boek op na te slaan of iets on line op te zoeken.
't is niet mijn bedoeling om te zeggen dat je lui bent, begrijp me niet verkeerd, maar je gaat er veel meer mee leren op die manier , geloof me !
Zeker niet, Dani. Ik wil het zeker zelf doen, maar als ik na een week het lcd nog altijd niet aan de praat krijg, weet in zelf niet meer wat ik kan doen... Het is niet zo evident om het programma te maken met die paar uur les/initiatie c die in gezien heb vorig jaar...
In mijn programmeeromgeving (Bascom AVR) bestaan er standaard instructies om bvb een LCD aan te sturen.
Bestaat er niets dergelijks voor jouw "ras" controllers ?
Citaat van: conducteur op 24 januari 2014, 10:52:26 AM
weet in zelf niet meer wat ik kan doen...
misschien kan je het dan gewoon zonder LCD display doen ? is dat echt een must ?
Als je het "minimum aan functionaliteit" er in kan krijgen en het werkt volgens het basis principe, zijn displays en Ledjes eigenlijk maar toeters en bellen, toch.
Dat kan ook, maar het kan toch niet onoverkomelijk zijn om dit te laten werken, en dan moet ik weer het bedieningspaneel ombouwen...
ombouwen ? nee, toch...
"kijk, mevrouw, meneer.... het paneel is al voorzien op toekomstige uitbreidingen maar nu momenteel is vooral naar het functionele gekeken, de afwerking en display is voor de volgende bouw fase maar is nu al gepland en fysisch al voorzien"
Het komt er allemaal op aan hoe je je zaak "verkoop", mijn jonge vriend, je leert dat nog wel naarmate je ouder wordt en ervaring op doet.
Ik snap het niet goed. Mijn LCD routine is een standaard routine, zwaar vereenvoudigd naar mijn noden. Ze komt uit één van de Microchip application notes. Mits wat zoekwerk kan je die gemakkelijk zelf vinden.
Ten tweede als je in C programmeert werk je altijd met libraries, of je ze nu zelf schrijft (zoals ik), of je download ze (zoals Gerolf en Dani suggereren). En dit geldt niet alleen voor C, je moet je werk eerst wat organiseren voor je erin vliegt.
En dan verder, zo'n delay is toch echt niet moeilijk. Gewoon ervoor zorgen dat je controller een bepaalde hoeveelheid tijd verliest. Maar als je wil zal ik vanavond wel de bron hiervan posten. Ik gebruik precisie delay routines met een mix van assembler en C. De routines hebben de exacte klokfrequentie nodig (#define). Voor elk van m'n courante frequenties heb ik een blokje assembler die zeer precies 1 µs wacht.
Voor jouw LCD heb je geen super precieze delays nodig, een paar lege instructies na elkaar is al voldoende.
Maar ik denk dat het grote probleem inderdaad aangegeven werd door Dani. Je zal echt zelf moeten proberen, door de code van iemand over te nemen, ga je bitter weinig leren. En de volgende keren dat je iets wil programmeren sta je weer voor hetzelfde probleem.
Ik denk dat je probleem voor dit projectje voornamelijk zit in begrijpen van libraries en includes. Probeer eens een simpel progje te schrijven waarbij je een led aan en uit laat knipperen met een variabele tussenpauze en zorg dat je volgende files correct gebruikt hebt:
main.c
timer.h
timer.c
Dit mag je niet meer dan een (half)uurtje kosten om zoiets in mekaar te steken. Desnoods volg je maar een paar tutorials ansi C programming op het internet.
Eerst leren stappen en dan pas lopen ;)
Blink a led? Normaalgezien geen probleem:
/***************************************************************************
* HITECH C for PIC program A_01- 24/01/2014 *
• Author: Rian De Rous *
****************************************************************************
* Processor: PIC16F887 *
* Compiler: HI-TECH C *
• Files required: none *
• Discription: light up led1 of port A *
• PIN Assignments: led at A1 *
************************************************************************* */
#include <htc.h>
// Config: HS ext Xtal- Watchdogtimer disabled - LVP Disabled
__CONFIG(FOSC_HS & WDTE_OFF & LVP_OFF & MCLRE_OFF);
#define _XTAL_FREQ 20000000 //20 MHz kristal
void main()
{
while(1){
TRISA = 0x00; // configure POORT A als output
PORTA = 0b00000010; // Pin A1 hoog
__delay_ms(500); //wacht 500 ms
PORTA=0b00000000; //terug uit
__delay_ms(500);
}
}
(het werkt, zij het dat de led 2seconden aan is en 2 seconden uit, 4x langer dan geprogrammeerd?)
Met biblotheken geen idee hoe dat moet...
edit:
weer iets bijgeleerd, één pin van een poort setten/clearen zonder die ambetante logische bewerkingen op ganse poort van de µC
/* **************************************************************************
* HITECH C for PIC program A_01- 24/01/2014 *
• Author: Rian De Rous *
****************************************************************************
* Processor: PIC16F887 *
* Compiler: HI-TECH C *
• Files required: none *
• Discription: light up led1 of port A *
• PIN Assignments: led at A1 *
************************************************************************* */
#include <htc.h>
// Config: HS ext Xtal- Watchdogtimer disabled - LVP Disabled
__CONFIG(FOSC_HS & WDTE_OFF & LVP_OFF & MCLRE_OFF);
#define _XTAL_FREQ 20000000
unsigned char i;
void main(){
TRISA = 0x00; // configure POORT A als output
RA1=1; // set enkel RA1 (nieuw)
__delay_ms(500); //wacht 500 ms
RA1=0; //RA1 reset
__delay_ms(500);
}
nog steeds werkt het veel te traag?
Citaat van: conducteur op 24 januari 2014, 14:36:46 PM
...weer iets bijgeleerd, één pin van een poort setten/clearen zonder die ambetante logische bewerkingen op ganse poort van de µC
...
Ik weet niet hoe dit bij de huidige pics is, maar niet alle processoren zullen die bit-commando's naar poorten ondersteunen hoor. Bij sommigen zijn het zelfs maar bepaalde poorten die dit supporteren.
Als je programmeerwerk op controllerniveau wilt doen zul je met and-en, or-ren, exor-en, enzo toch moeten kunnen spelen hoor, desnoods via voorgedefineerde #define's. Ook voor periferie-chips is dit vele keren nodig!!
Bitneukerij noemen wij dit....
Libraries: ik vermoed dat hiermee het schrijven van functies bedoeld wordt welke je dan verzamelt in een aparte .c-file, bvb alles voor je lcd plaats je in lcd.c --> routines om een bepaalde tekst op een bepaalde positie te zetten bvb...
Succes ermee en blijven volhouden tot het ding doet wat je wilt dat het doet en vooral waarom!!
Geert
Nu nog de LCD en de SPI en dan is dit deel al voor 95% gereed
4x te traag, dat lijkt erop dat er geen rekening gehouden werd met de interne klok van de PIC16. Als je quartz kristal effectief 20MHz is, dan draait je interne klok op 5MHz (zonder PLL), omdat de PIC16 4 klokcycli nodig heeft om één instructie uit te voeren. Dus je moest _XTAL_FREQ op 5000000 zetten...
Je hebt eigenlijk al een bibliotheek gebruikt, de htc.h die onrechtstreeks de Hi-Tech delay routines bevat, deze zijn niet super nauwkeurig maar kunnen ermee door.
Ik wou je een delay routine in een eigen bibliotheek laten zetten en via een include in je main programma opnemen. Als je kijkt naar mijn LCD code, zie je bovenaan 3 includes:
#include <htc.h>
#include "lcd.h"
#include "delay.h"
De eerste is een 'globale' include (gaat het volledige path afzoeken naar de header). De laatste 2 zijn 'locale' includes, in dit geval staan ze in dezelfde directory als de code (daar waar lcd.c staat).
In de header stop je voornamelijk constanten en signaturen van routines. Elke header heeft een .c file nodig met de implementatie van de routines die je in de .h geplaatst hebt. Je moet er enkel voor zorgen dat de compiler en linker aan dit bestand aankunnen. Dat kan op verschillende manieren, de eenvoudigste is om alle .c bestanden in één en dezelfde directory onder te brengen. Een andere manier is om de benodigde .c bestanden te includen in je hoofdprogramma, dan kan je relatieve paths gebruiken en blijft je project netjes.
De bedoeling was nu om je ledje te laten knipperen door zelf een delay functie te schrijven en niet deze van htc te herbruiken. Een goede, precieze delay is niet zo moeilijk om te schrijven. Je moet nagaan hoeveel tijd er in elke instructie 'verloren' gaat (klokcycli tellen). Hieronder heb je mijn delay routines die geldig zijn voor verschillende klokfrequenties (opgelet klok is niet gelijk aan kristal):
delay.h
#ifndef __DELAY_H__
#define __DELAY_H__
#ifndef CLK_FREQ
#define CLK_FREQ 4000000
#endif
extern unsigned char delayus_variable;
#if CLK_FREQ == 4000000
#define DelayDivisor 4
#define WaitFor1Us asm("nop")
#define JumpBack asm("goto $-4")
#elif CLK_FREQ == 8000000
#define DelayDivisor 2
#define WaitFor1Us __asm__("nop")
#define JumpBack __asm__("goto $-4")
#elif CLK_FREQ == 12000000
#define DelayDivisor 1.5
#define WaitFor1Us __asm__("nop")
#define JumpBack __asm__("goto $-4")
#elif CLK_FREQ == 16000000
#define DelayDivisor 1
#define WaitFor1Us __asm__("nop")
#define JumpBack __asm__("goto $-4")
#elif CLK_FREQ == 20000000
#define DelayDivisor 1
#define WaitFor1Us __asm__("nop\nnop")
#define JumpBack __asm__("goto $-6")
#elif CLK_FREQ == 32000000
#define DelayDivisor 1
#define WaitFor1Us __asm__("nop\nnop\nnop\nnop\nnop")
#define JumpBack __asm__("goto $-12")
#elif CLK_FREQ == 40000000
#define DelayDivisor 1
#define WaitFor1Us __asm__("nop\nnop\nnop\nnop\nnop\nnop\nnop")
#define JumpBack __asm__("goto $-16")
#elif CLK_FREQ == 48000000
#define DelayDivisor 1
#define WaitFor1Us asm("nop\nnop\nnop\nnop\nnop\nnop\nnop\nnop\nnop\n")
#define JumpBack asm("goto $-20")
#else
#error delay.h - please define CLK_FREQ corectly or add more supported clock frequencies
#endif
#define DelayShortUs(x) {\
delayus_variable=(unsigned char)(x/DelayDivisor); \
asm("movlb (_delayus_variable)");\
WaitFor1Us; }\
asm("decfsz (_delayus_variable),f");\
JumpBack;
void DelayUs(unsigned int us);
void DelayMs(unsigned int ms);
#endif/*__DELAY_H__*/
delay.c
#include "delay.h"
void DelayMs(unsigned int ms) {
unsigned char i = 4;
while (ms-- > 0) {
i = 4;
while (i-- > 0) {
DelayShortUs(250);
}
}
}
void DelayUs(unsigned int us) {
unsigned char quartz = us >> 8;
while (quartz-- > 0) {
DelayShortUs(0xff);
}
DelayShortUs(us & 0xff);
}
Vooral de delay.h zal je wat kopzorgen bezorgen, maar deze is zo optimaal mogelijk gemaakt met compiler directieven. Dit is nodig omdat floating point operaties zeer kostelijk zijn op de PIC12/PIC16/PIC18, daarom heb ik m'n meest voorkomende klokfrequenties hierin gedefinieerd. De jouwe van 5MHz zit er niet tussen, dat laat ik aan jou over om correct uit te rekenen. Hint, 't is kleiner dan 16MHz, dus 1 NOP en een divisor >1 gebruiken.
Als je timing in de delays goed zit, moet m'n LCD routine ook werken. Vergeet niet om m'n 8bit interface om te zetten naar 4 bit. Tijdens de initialisatie moet je LCDCommand(0x38) vervangen door LCDCommand(0x28). En je moet de LCDCommand en LCDPut routines wat herschrijven: 4 bits per keer doorsturen door telkens de LCD_E aan en uit te toggelen na elke 4 bits.
Citaat van: Sattrickske op 25 januari 2014, 00:20:00 AM
...Dus je moest _XTAL_FREQ op 5000000 zetten...
Citaat van: Sattrickske op 25 januari 2014, 00:20:00 AM
...opgelet klok is niet gelijk aan kristal...
Ik denk dat we hier toch op een verschillende golflengte zitten: volgens mij moet _XTAL_FREQ ingesteld staan op de werkelijke klokfrequentie dus op 20000000. 4 klokcycli per instructie is inderdaad zo en is de verwerkingstijd van de instructies dus 1/4° van de klokfrequentie maar de constante moet wel degelijk op de werkelijke klokfrequentie staan...
De klokfrequentie wordt wel degelijk op volle snelheid benut voor de periferie (ADC, timers, ...).
Citaat van: Sattrickske op 25 januari 2014, 00:20:00 AM
...Als je quartz kristal effectief 20MHz is, dan draait je interne klok op 5MHz (zonder PLL)...
Zijn er PIC16 met een PLL (http://nl.wikipedia.org/wiki/Phase-locked_loop)? Ik heb enkel weet van de 18F serie met USB interface (18F2455, 2550, 4455 en 4550). Een PIC16 met PLL zou me wel interesseren. Voor sommige toepassingen kom ik net wat klok te kort...
Citaat van: conducteur op 22 januari 2014, 14:11:59 PM
ps: (n)iemand goesting om eens op een zaterdag of zondagnamiddag in februari me even op weg te helpen met dit project?
Ja! Er rijden treinen van Blankenberge naar Deinze (via Gent) en van het station is het 3 minuten en 22 seconden te voet tot bij mij thuis. ...Maar C heb ik al een ganse tijd achter mij gelaten en is ondertussen al heel roest geworden...
Hitech C heb ik hier staan en ik wil wel een poging wagen.
Als je het boek van Bert Van Dam ondertussen al hebt doorgenomen, wordt het JAL.
Graag afspreken via PM.
Citaat van: PeterC op 25 januari 2014, 01:15:30 AM
Citaat van: Sattrickske op 25 januari 2014, 00:20:00 AM
...Dus je moest _XTAL_FREQ op 5000000 zetten...
Citaat van: Sattrickske op 25 januari 2014, 00:20:00 AM
...opgelet klok is niet gelijk aan kristal...
Ik denk dat we hier toch op een verschillende golflengte zitten: volgens mij moet _XTAL_FREQ ingesteld staan op de werkelijke klokfrequentie dus op 20000000. 4 klokcycli per instructie is inderdaad zo en is de verwerkingstijd van de instructies dus 1/4° van de klokfrequentie maar de constante moet wel degelijk op de werkelijke klokfrequentie staan...
De klokfrequentie wordt wel degelijk op volle snelheid benut voor de periferie (ADC, timers, ...).
Je zou kunnen gelijk hebben. Ik weet het niet meer zeker, ik gebruik al een hele tijd XC8 of SDCC en zeker niet meer de 'ingebouwde' delay functies. Dus hoe het juist zat met die goeie ouwe Hi-Tech, weet ik niet meer. En om alle verwarring uit te schakelen (werd heel lastig als je verschillende types µC door mekaar gebruikt en niet alleen PIC), gebruik ik mijn delay.h enkel de 'CPU klok' of 'instructie cyclus' als je wil; dus de effectieve tijd die er nodig is om één instructie uit te voeren. Maar soit da's een gans ander verhaal.
Maar als Rian zegt dat z'n ledje 4x te traag knippert, is dit wel de quick en dirty oplossing ;). Maar hij zal wel op langere termijn moeten nakijken waarom ie 4x te traag is. De PIC16F877 heeft geen speciale setup voor de klok, dus verkeerd kristal?
Citaat van: PeterC op 25 januari 2014, 01:15:30 AM
Citaat van: Sattrickske op 25 januari 2014, 00:20:00 AM
...Als je quartz kristal effectief 20MHz is, dan draait je interne klok op 5MHz (zonder PLL)...
Zijn er PIC16 met een PLL (http://nl.wikipedia.org/wiki/Phase-locked_loop)? Ik heb enkel weet van de 18F serie met USB interface (18F2455, 2550, 4455 en 4550). Een PIC16 met PLL zou me wel interesseren. Voor sommige toepassingen kom ik net wat klok te kort...
Neen, niet dat ik weet, enkel een paar PIC18F, de PIC24 en PIC32. Microcontrollers werken heel goed met kwartsen tot 40-48MHz (afhankelijk van het type), daarboven worden ze onstabiel en schakelen ze over naar lagere frequenties voor het kristal en combineren ze dat met een PLL. M'n STM32F407 draait met een kristal van 8 MHz een klok van 168 MHz (!).
Ik heb deze middag wat tijd...
Ik zal effe jouw configuratie voor de LCD1602 aan m'n test bord met PIC16F877 hangen. Als je me via PM je e-mail adres doorgeeft, zal ik je ten laatste tegen maandagavond een MPLab X project doorsturen met daarin:
- main.c (hoofd programma)
- board.h (configuratie de gebruikte schakeling)
- delay.h (delay headers)
- delay.c (delay implementatie)
- lcd.h (LCD headers)
- lcd.c (LCD implementatie)
De gebruikte compiler is XC8 (free version). Op deze manier heb je dan een volledig correcte configuratie van PIC16F C project en kan je dan verder met het aanmaken van andere bibliotheken in dezelfde zin als m'n delay en lcd.
In de voorbeeldprogramma's die we in de lessen gebruikt hebben staat wel degelijk
#define _XTAL_FREQ 19660800 // oscillator frequency for _delay() dus 19,6608 MHz... Dus moet ik met een 20MHz kristal toch 20 000 000 invullen?
KIEKENMODUS ON
Ik denk dat het kristal op de verkeerde pins aangesloten is, hoe ik dat gedaan heb, geen idee...
Eens veranderen als ik tijd heb, maar eerst Java leren voor examens...
KIEKENMODUS OFF
JAL: ik heb het boek in de boekhandel besteld, omdat ik nog een cadeaubon gekregen heb bij m'n attest hogere graad deeltijds kunstonderwijs afdeling muziek, omdat ik vorig jaar het laatste jaar cello gevolgd heb aan de muziekschool. Maar ik heb de indruk dat de drukpers nog moet ingesteld worden, nog steeds geen boek...
Citaat van: conducteur op 25 januari 2014, 11:47:24 AM
KIEKENMODUS ON
...
KIEKENMODUS OFF
:) :) :) Uit je fouten moet je leren ;)
Mail mij eens je schema; ik zal in Hi tech eens kijken of ik het roest nog van mijn C krijg...
Ik heb geen 887 op voorraad, maar wel nog enkele 877's liggen. Zal daar eens mee proberen voor je LCD.
Dan schakelt de pic automatisch over naar een interne oscillator, als er toch geen kristal is aangesloten?
De PIC schakelt niet automatisch over naar de interne oscillator. Welke oscillator de PIC gebruikt (kristal, RC, intern...) wordt hardwarematig ingesteld (__CONFIG in assembler)
Geert
Neen je PIC kiest niet zomaar een klok, daarvoor moet je de fuses aanpassen. Je PIC klok draaide op interferentie, kan soms werken, maar is zo onstabiel als de pest.
Maar ik heb ondertussen je projectje klaar in een zip bestandje (http://patrickleyman.be/projects/modelrailroad/software/lcd1602/lcdtest.zip)
Het enige wat je dient aan te passen, is de board_16F877A.h file en er jouw schema op koppelen. Als alles correct werkt, zou je dit moet krijgen:
(http://i1236.photobucket.com/albums/ff460/Sattrickske/ModelRailroad/EOS5DMarkIII-101-2016_zps1cdf153f.jpg)
EDIT: vergeten bij te zeggen, dat de timing in 4-bit heel belangrijk is. Kijk naar de LCDInit, vooral de eerste 4 instructies zijn cruciaal. En controleer ook of je contrast wel goed is, anders krijg je steeds een blank scherm te zien.
Het klok probleem is ondertussen opgelost... Het ledje pinkt aan de juiste snelheid met
#define _XTAL_FREQ 20000000 // oscillator frequency for _delay() .
straks eens naar je zipje kijken, bedankt ervoor, maar eerst nog wat JAVA
Citaat van: conducteur op 25 januari 2014, 17:33:30 PM
Het klok probleem is ondertussen opgelost... Het ledje pinkt aan de juiste snelheid met
#define _XTAL_FREQ 20000000 // oscillator frequency for _delay() .
straks eens naar je zipje kijken, bedankt ervoor, maar eerst nog wat JAVA
Goed dat je het ontdekt hebt!!
En met de input van Patrick zal de aansturing van het display ook wel in orde komen...
Geert
Patrick,
Mooi dat je Rian zo op weg zet, in C is stap voor stap gaan sowieso de beste leerschool.
@Rian: Nu proberen om iedere regel van Patrick zijn voorbeelcode te begrijpen...
Een werken display is ook, en vooral, bij het debuggen heel interessant!!
Geert
/*
* File: board_16F877A.h
* Author: Patrick
*
* Created on 25 januari 2014, 11:38
*/
#ifndef BOARD_16F877A_H
#define BOARD_16F877A_H
#pragma config FOSC = HS, LVP = OFF, CP = OFF, WDTE = OFF, BOREN = OFF
#define CLK_FREQ 20000000
#define CONFIGURE_CHIP TRISC &= ~0x80;ADCON1=0X07
#define LCD_DATA PORTD
#define LCD_DATA_TRIS TRISD
#define LCD_CTRL_TRIS TRISD &= ~0x0E
#define LCD_RS PORTDbits.RD4
#define LCD_E PORTDbits.RD5
#define LCD_RW PORTAbits.RD2
#endif /* BOARD_16F877A_H */
Klopt dit?
DB4-DB7 van lcd op RD0-RD3,RS op RD4, E op RD5
en dan in main.c het project compileren? Dan krijg ik die error die in delay.h staat, hoewel voor zo ver ik het begrijp de #define CLK_FREQ 20000000 juist gedefineerd is en ook in delay.h staat...
compiler:
#error delay.h - please define CLK_FREQ corectly or add more supported clock frequencies
De LCD_RW lijk jij niet te gebruiken, dan moet je 'm ook overal uit de lcd1602.c verwijderen. Hoe heb je de LCD_RW verbonden? Aan de massa?
De mask voor LCD_CTRL_TRIS is niet juist; deze dient voor LCD controle lijnen (LCD_RW/LCD_RS/LCD_E), in jouw geval enkel LCD_RS en LCD_E. De correcte mask om de TRISD te resetten is TRISD &= ~0x30 Hoe kom ik daaraan? LCD_RS = RD4 en LCD_E = RD5. RD4 = 0x10 op PORTD en RD = 0x20 op PORTD, tel die op en je krijgt 0x30. We willen RD4 en RD5 als uitgang configureren, dan moet TRISD voor die pinnetjes = 0 zijn: TRISD &= ~0x30. Dit commando zet enkel bits 4 en 5 op het TRISD register op nul, van de rest blijft ie af.
Dan in lcd1602.c gebruikte ik de hoogste 4 bits van PORTD, jij gebruikt de laagste 4 bits. Dus moet je in LCDInitWrite, LCDCommand en LCDPut de nibbles zetten op de laagste 4 bits van je poort in de LCD_DATA = ... instructies. Ik gebruikte telkens de hoogste 4 bits (high nibble)
Dus bv. LCD_DATA = data & 0xf0; wordt dan LCD_DATA = (data & 0xf0) >> 4;. En LCD_DATA = cmd << 4; wordt dan LCD_DATA = cmd & 0x0f;
De CLK_FREQ moet gedefinieerd zijn voor de delay16.h aangeroepen wordt. Dat werkt perfect in MPLab X IDE 1.95 met XC8. Ik vermoed dat jij MPLab 4.x gebruikt met de oude Hi-Tech C compiler. Daar gaat dat niet werken, een noodoplossing is om de #define CLK_FREQ 20000000 bovenaan de delay16.h te stoppen als volgt:
#ifndef CLK_FREQ
#define CLK_FREQ 20000000
#endif
Let wel dat je delay16.h aanroept en niet delay.h (deze is voor PIC18). Je gaat nog een paar andere problemen tegenkomen met de oude Hi-Tech C, de asm("...") instructies gaat ie niet begrijpen. Ik denk dat je best de modernere XC8 gebruikt (downloaden bij Microchip). Als de trouwens de volledige MPLab X IDE download, wordt die automatisch mee geïnstalleerd. Die nieuwe IDE is trouwens veel gebruiksvriendelijker dan de oude.
LCD_RW hangt idd aan massa, moet ik de niet gebruikte datalijnen in 4-bitmode van het lcd ook met massa verbinden? Nu hangen die gewoon los?
MPlab X V1.90 staat hier op de pc, en de xc8 compiler gedownload en geïnstalleerd...
Citaat van: conducteur op 26 januari 2014, 10:53:17 AM
moet ik de niet gebruikte datalijnen in 4-bitmode van het lcd ook met massa verbinden? Nu hangen die gewoon los?
Laten loshangen; worden niet gebruikt. Bij de initialisatie van het display worden eerst de hoogste 4 bits gebruikt. De eerste instructies die naar het display worden geschreven (zowel in 4 bit als in 8 bit mode) verlopen via die 4 hoogste bits. Tijdens één van die initialisatie instructies wordt de 4/8 bits modus geselecteerd.
Inderdaad, dat zijn de eerste 4 LCDInitWrite instructies in de LCDInit methode (3x 0x30 en 1x 0x20).
(http://www.treinbaanrian.be//images/eindwerk/stappenmotorsturingv2.JPG)
Stappenmotorsturing versie 2.0 bijna klaar, hopelijk werkt ie van de eerste keer (in tegenstelling tot versie 1 waar we even hebben op zitten zoeken om enkele foutjes eruit te halen). Mankeer enkele kleine condensatoren om het af te werken en te testen...
Printje aangevuld met de vermogensweerstanden die de stroom meten, paar condensatortjes aangekocht van waarden die ik niet meer had voor hier.
Ik sluit alles aan, stel de voeding in, alles gaat goed.... Ik kan de stroom regelen met de trimpot op de print... tot op een bepaald ogenblik de magic smoke er uit komt. elektronica werkt op rook, als de rook er uitkomt, werkt het niet meer. :( En had blijkbaar geen reserve van dit ("dure") ic....
(dom dat ik de eerste heb afgebroken voor ik deze kon testen :( )
Citaat van: conducteur op 05 februari 2014, 18:40:11 PM
... dit ("dure") ic....
L298 (http://www.benl.ebay.be/itm/251323735479?ru=http%3A%2F%2Fwww.benl.ebay.be%2Fsch%2Fm.html%3Fitem%3D330881079803%26pt%3DLH_DefaultDomain_0%26hash%3Ditem4d0a0c99fb%26_ssn%3Dchipworld%26_sacat%3D0%26_from%3DR40%26_nkw%3D251323735479%26_rdc%3D1) als 'goedkoper' alternatief?
Ik ga er nog even over nadenken, de ebay module of een nieuwe l6208. Het ene is zeker goedkoper dan de L6208, waar ik al wat ervaring mee heb. (en vereist slechts 2 stuurlijnen!). Ik heb ergens nog een referentie nodig die het nulpunt vastlegt in het systeem. Zijn van die microswitches voldoende nauwkeurig genoeg? Ik ben een beetje aan het zoeken en vind hier "differenzweg, vorlaufweg max, nachlaufweg min" als eigenschappen van de switches. Differenzweg lijkt me het verschil te zijn tussen het punt waarop de schakelaar inschakelt en waarop hij weer uitschakelt, maar moet ik dat dan ook zien als nauwkeurigheid van de positie?
Microswitches zijn zeer nauwkeurig als je er steeds in dezelfde richting overloopt. Dus om je nulpunt te zoeken moet je steeds in dezelfde richting bewegen.
Meestal (in een CNC bv.) wordt het volgende principe gehanteerd:
- laat je mechaniek teruglopen richting switch
- wacht tot de switch dicht is en stop de motor
- loop traag in de andere richting, tot de switch terug opengaat, dit is je nulpunt.
Softwarematig kan je dan een aantal stappen naar je stappenmotor sturen om perfect op het punt te staan waar je 'm wil hebben, dat heet dan ijking of calibratie. Deze laatste stap is nodig als je de switch niet perfect op de juiste plaats krijgt, wat meestal het geval is.
Bedankt! Dan moet ik dus niet meer verder zoeken...
Ik heb de L6208 een kans gegeven en samen met een microswitch enkele reserve driver-ic's aangekocht. Als ik er niet in slaag om met die 3 stuks de motor te doen draaien voor ze allen beginnen te roken zal ik op zoek moeten gaan naar iets anders. Met een beetje geluk morgen al in de bus (reichelt levert erg snel).
bedankt om me te depanneren met het nieuwe/oude display, Peter. De USB-RS232 kabel blijkt jammergenoeg toch (voorlopig) niet te werken. Ik moet dus verder zoeken.
(http://www.treinbaanrian.be/images/eindwerk/lcdtest.jpg)
Vandaag testen testen en testen van de l6208 stappenmotorsturing... voorzichtig te werk gaan om geen ic's in rook te doen opgaan. Hopelijk rap een oplossing voor de kabel usb-serieel zodanig we verder met het programma kunnen doen (bedankt Peter voor je hulp vorige week!)
Yes! Ik heb de indruk dat het ding het doet :D
Citaat van: conducteur op 15 februari 2014, 17:40:05 PM
...bedankt Peter voor je hulp vorige week!
Graag gedaan!
Nu stap voor stap verder!
Ik heb gelijk de indruk dat de eerste tests met de minder krachtige stappenmotor die ik heb gekregen goed lukken, maar dat de sturing niet degelijk genoeg is voor de 2,5NM motor aan te sturen... Hij krijgt de stroombegrenzing op 2,5 Ampere niet stabiel. Met als gevolg dat de stappenmotor staat te trillen of door te draaien. Tijd voor iets degelijker?
Gedaan met prutsen, nu een Leadshine driver gekocht (DM442)
Ben het al een tijdje afgeleerd om te proberen met prutsen of met goedkopere en dikwijls kwalitatief mindere oplossingen. Veelal verlies je hopeloos veel tijd en moet je uiteindelijk toch uitwijken naar kwaliteit en heb je meer uitgegeven dan nodig was.
De driver kun je verbinden met een pc (gelukkig had pa nog een rs232 poort op z'n pc staan :D ). En het ding draait fantastisch (tot 2000 tr/min zonder belasting aan, en volgens mij bij wat tragere beweging (ik heb aan enkele omwentelingen per seconde voldoende) voldoende koppel om het spel te doen draaien...
Ik denk de oplossing te hebben gevonden! Blijkbaar is de pickit 2 ook in te schakelen als rs 232 terminal, geen specifiek usb kabeltje nodig! Zeker dit weekend eens te testen!
Yes! het werkt!!!
Het display en de knoppen communiceren al via rs 232 met de computer... Dit deel werkt dus al! http://www.treinbaanrian.be/html/16f887_6_Serial_tekst_commando.htm werkt...
(met dank aan Peter die me nogal wat geholpen heeft voor dit deel)...
Op naar de 2de microcontroller, die de sturing verzorgt voor oa de stappenmotor en al de rest :D
leuk te lezen dat er vooruitgang wordt geboekt... Nu nog foto's van het "ding" als het werkt met locomotieven er op... ;)
Foto's?? Filmpje !!
Geert
(http://www.treinbaanrian.be/images/eindwerk/uart.png)
rs 232 terminal...
toelichting:
Rx: telkens de microcontroller een verandering detecteert (indrukken en loslaten) van de drukknoppen stuurt hij dat door via rs 232
Tx: Als bit 7 geset is is het een "commando"..., C0 wist display, A0-AF plaatst de cursor op de eerste rij, waarbij de low_nibble duid op welke kolom de cursor moet staan. Idem voor B0-BF maar dan voor de tweede rij... De rest zijn strings gecodeerd in hex code
Dit zijn de enige boodschappen die in de µC "ingebakken" zitten, en bij opstart even weergegeven worden, de rest zal via rs232 komen.
(http://www.treinbaanrian.be/images/eindwerk/lcd1.jpg)
De pickit 2 programmer dient als omzetter usb-rs232, boodschap verstuurd en op de juiste plaats gezet op de display
hex: (A1 48 65 6C 6C 6F 20 53 65 72 69 61 6C 20 57 6F 72 6C 64 ) (A1= eerste rij 1/2de kolom (afhankelijk van hoe je begint te tellen))
(http://www.treinbaanrian.be/images/eindwerk/lcd2.jpg)
(http://www.treinbaanrian.be/images/eindwerk/lcd3.jpg)
C0: display gewist
(http://www.treinbaanrian.be/images/eindwerk/lcd4.jpg)
omdat jullie het zo vriendelijk vragen ;)
Leuk dat er in die electronica leven komt, Rian !
Eens die dingen met mekaar babbelen, ben je vertrokken !
Dan wordt het wat logisch denken en structureren, en vlieg je vooruit !
Goeie moed ;)
Rian,
Dat display... ...Is dat er eentje uit de tijd van '14 - 18'? :) :) :)
De chinaman levert er binnenkort een tiental nieuwe en ik zal je er eentje opsturen (om je foto's wat moderner te maken ;) ).
Je code: kuis het commentaar eens op. Wat niets (of niets meer) met je prog te maken heeft: weg ermee!
Benieuwd naar het vervolg!
[Edit1] Ondertussen, dankzij jou, al zodanig aan die PICKit verkocht dat ik mijn PICStart Plus van de hand ga doen ;)
[Edit2] Zeg niet dat je alle ASCII codes als hex in geeft: probeer eens MicTerm, RealTerm of Termite als terminal.
Citaat van: PeterC op 24 februari 2014, 22:50:45 PM
Rian,
Dat display... ...Is dat er eentje uit de tijd van '14 - 18'? :) :) :)
De chinaman levert er binnenkort een tiental nieuwe en ik zal je er eentje opsturen (om je foto's wat moderner te maken ;) ).
Je code: kuis het commentaar eens op. Wat niets (of niets meer) met je prog te maken heeft: weg ermee!
Benieuwd naar het vervolg!
[Edit1] Ondertussen, dankzij jou, al zodanig aan die PICKit verkocht dat ik mijn PICStart Plus van de hand ga doen ;)
[Edit2] Zeg niet dat je alle ASCII codes als hex in geeft: probeer eens MicTerm, RealTerm of Termite als terminal.
-Dat display is nog maar 10 jaar ze (http://www.nieuwsblad.be/article/detail.aspx?articleid=DMF20140111_028).
-Bedankt alvast voor het nieuwe exemplaar
-commentaar verwijderen, doe ik zeker :)
-Het vervolg komt er zeker ;)
-Pickit: ik was me maar half bewust dat deze voorzien was van de UART, en er zou blijkbaar ook een primitieve 3 kanaals logic-analyzer inzitten. Die eerste ben ik blij dat ik die gevonden heb, de logic analayzer nog niet gebruikt :p allicht zullen die ook in V3 zitten?
-ASCII code: http://www.swingnote.com/tools/texttohex.php heeft al veel geholpen (de terminal van de pickit 2 kan of strings of Hex aan, en met die eerste kun je niet zo simpel de "commando's " doorsturen
@Jean: bedankt
Citaat van: conducteur op 24 februari 2014, 23:12:33 PM
...de terminal van de pickit 2 kan of strings of Hex aan, en met die eerste kun je niet zo simpel de "commando's " doorsturen ...
Als je een ASCII karakter met een waarde groter dan 128 (decimaal) wil doorsturen vb 0xC0, dan zet je dat getal naar decimaal om (192 in dit geval) en typ dit in je terminal met de 'Alt' toets ingedrukt. Met de 'alt' toets ingedrukt kan je elk mogelijk karakter typen (als je de ASCII code kent).
Ook de 2de µC gaat vooruit. De stappenmotor draait toch al, aangestuurd door de µC. Ik zorg wel nog voor een uitgebreid verslag in de loop van de vakantie als ik wat verder gevorderd ben.
http://www.treinbaanrian.be/html/main.htm
Stap voor stap nu het programma testen en de fouten eruit halen, maar deze vind ik niet direct:
De motor loopt bij het aanzetten richting nulpunt, activeert microswitch en zet positie op nul (staat normaal al op nul) en start in de andere richting. (tot hier werkt het al)
Dan kijk ik per spoor of er een trein aanwezig is. Je zou dit ook kunnen opslaan in het geheugen maar als je een trein bijplaatst/wegneemt in het systeem klopt die info niet meer, dus verkies ik het om bij het opstarten dit eens te controleren.
De posities per spoor staan in een array (die ik tijdelijk in een soort random volgorde heb gezet, om het probleem op te sporen) en één voor één worden deze waarden uit de array gehaald en in de variabele "eindpositie" gezet. De procedure berekent dan hoeveel stappen gezet moeten worden tot aan de te bereiken positie en in welke draaizin dit moet gebeuren. (de driver staat op 800 stappen per omwenteling, dit geeft een vloeiende loop met nog voldoende kracht en snelheid). Echter lijkt het alsof de richting altijd op "1" blijft staan...
Eerst had ik een versie van de procedure waarbij het verschil tussen "positie" (=waar de plaat nu staat, op x stappen van het nulpunt) en eindpositie(=de te bereiken positie) in een variabele werd gestopt en gekeken werd of deze groter dan of kleiner dan 0 is, en dacht dat het probleem zat in het verschil tussen een signed word en een word, maar dat lijkt niet volledig de oorzaak te zijn?
In je programma declareer je 2 variabelen: positie en eindpositie
;-------------------------------------------------------------------------------
;variabelen voor programma
;-------------------------------------------------------------------------------
var word eindpositie
var word positie
Iets verder declareer je 2 variabelen in je procedure: positie en eindpositie
procedure verplaatsen (word in positie, word in eindpositie) is
2 keer dezelfde variabelen. Weet jij welke wordt gebruikt? De compiler vermoedelijk ook niet...
Gebruik ofwel andere namen voor je globale variabelen ofwel voor die in de procedure.
Een ander probleem zie ik niet direct...
ga ik eens testen ze ;)
...ben benieuwd...
procedure verplaatsen (word in Ppositie, word in Peindpositie) is
var word stappen ;
if Ppositie> Peindpositie then
stappen=Ppositie-Peindpositie
direction=0
else
direction=1
stappen=Peindpositie-Ppositie
end if
for stappen loop
step=!step
delay_10us(25)
end loop
Peindpositie=positie
end procedure
In de procedure gewoon de variabelen veranderd van naam, de p van procedure ervoor geplaatst maar de if statement blijft false opleveren (draaizin is "1")
Nieuwe poging:
Na elke aanroep van je procedure je huidige positie aanpassen:
...
verplaatsen(positie, eindpositie)
positie = eindpositie
...
In je procedure zelf zit je ander met een mix van lokale en globale variabelen (niet zo netjes).
probeer eens te tracken of je wel de juiste variabelen mee stuurt vanuit je hoodprogramma, ik heb de indruk dat die verloren gaan
dit
" Peindpositie=positie " (laatste regel van je sub ) zal er ook geen deugd aan doen natuurlijk.
Yes het werkt, na de oproep de positie en eindpositie gelijk stellen en ik zie de motor al in de twee richtingen draaien :p
--------------------------------------------------------------------------------
; procedure verplaatsing
;direction=off/0 ==> richting nulpunt
;direction=onn/1 ==> van nulpunt weg
--------------------------------------------------------------------------------
procedure verplaatsen (word in Ppositie, word in Peindpositie) is
var word stappen ;
if Ppositie> Peindpositie then
stappen=Ppositie-Peindpositie
direction=0
else
direction=1
stappen=Peindpositie-Ppositie
end if
for stappen loop
step=!step
delay_10us(25)
end loop
end procedure
;--------------------------------------------------------------------------------
;initialisatie start
const byte initstart[]="start initialisatie"
print_string(serial_hw_data, initstart)
;--------------------------------------------------------------------------------
; zoek nulpunt (schakelaar=microswitch nulpunt)
;--------------------------------------------------------------------------------
relais=off
relaisinrij=off
direction=off
while !schakelaar loop
step=!step
delay_10us(25)
end loop
positie=0
delay_1ms(1250)
;--------------------------------------------------------------------------------
; controle 8 sporen vrij/ bezet in array bezet en terug naar nulpunt
;--------------------------------------------------------------------------------
for 8 using teller loop
eindpositie= spoor[teller]
verplaatsen(positie, eindpositie)
positie=eindpositie
bezet[teller]=lichtsluis
delay_1ms(1000)
end loop
delay_1ms(1250)
eindpositie=0
verplaatsen(positie, eindpositie)
Citaat van: dani op 05 maart 2014, 11:50:42 AM
...probeer eens te tracken of je wel de juiste variabelen mee stuurt vanuit je hoodprogramma, ik heb de indruk dat die verloren gaan...
Onmisbaar tijdens het debuggen. Je hebt de mogelijkheid om een variabele naar je LCD of naar je terminal te sturen.
Even iets anders dan programmeren, een "bug" uit het mechanische gedeelte halen
(http://www.treinbaanrian.be/images/eindwerk/steunmotor.png)
De stappenmotor is op het aluminium frame gemonteerd met deze houder. (2 boutjes in de onderste gleuf in het frame; de vier kleinere gaten en het grote gat zijn afgestemd op de afmetingen van nema23 motoren. Een domme fout om die gleuf horizontaal te maken, want horizontaal kan ik die afregelen met de gleuven in het profiel. Verticaal niet, en het is belangrijk dat de as op een mooie lijn met de stappenmotoras ligt. Een oplossing dus zoeken:
(http://www.treinbaanrian.be/images/eindwerk/samenstelling.png)
(http://www.treinbaanrian.be/images/eindwerk/moermontage.png)
(http://www.pctoytoy.be/2014/20140311_1.jpg)
De chinaman is eindelijk langs geweest ;)
haha, van een innovatieve manier van communiceren gesproken !!!
Citaat van: dani op 11 maart 2014, 16:45:54 PM
haha, van een innovatieve manier van communiceren gesproken !!!
Zijn tamtam was in panne gevallen. ;D
Citaat van: doomslu op 11 maart 2014, 20:20:34 PM
Citaat van: dani op 11 maart 2014, 16:45:54 PM
haha, van een innovatieve manier van communiceren gesproken !!!
Zijn tamtam was in panne gevallen. ;D
Blijkbaar komt mijn bericht niet goed over: Rian heeft een tijdje geleden een (heel oud) display van mij gekregen om verder te kunnen werken omdat er iets mis was met zijn display. Ik had hem een nieuw beloofd zodra die geleverd werden. Twee maand geleden in China besteld maar nu pas toegekomen. Het doosje is blijkbaar vrij lang in handen geweest van de douane (gecontroleerd en terug dichtgeplakt met een 'douane controle' tape)...
...Maar zonder adres kan ik niets opsturen...
Wees gerust Peter, we hadden het door, maar we zijn nu eenmaal een beetje gek (een heel klein beetje, hé dani ;))
Citaat van: doomslu op 11 maart 2014, 20:44:27 PM
Wees gerust Peter, we hadden het door, maar we zijn nu eenmaal een beetje gek (een heel klein beetje, hé dani ;))
...Ik was wel mee, maar toch... ...Op eieren lopen hé ;)
Jaja Peter ik had het verhaal wel gevolgd hoor!
Il vond het een heel originele manier om uit de hoek te komen van jou, zo veel leuker dan gewoon een tekstje te tikken in dit draadje. Je moet er maar op komen!
En tof van jou dat je de jeugd zo belangeloos helpt.
Mijn persoonlijk record met een pakje van bij de chinees is 14 weken :-)
@luc : klein beetje gek ? Ikke ?
Men zegt soms van iemand dat er een hoekje af is, wel .... Ik ROL overal naartoe :-p
Niet gezien dat er zoveel activiteit was in dit draadje, wellicht méér dan een jaar geleden :p
Mijn adres hier in the White Mountains toon ik niet openbaar op een display, dus PM... :p :)
Zoek de fout (hoe ik er in geslaagd ben, géén idee :p)
(http://www.treinbaanrian.be/images/eindwerk/moermontage.png)
(http://www.treinbaanrian.be/images/eindwerk/samenstelling.png)
Zes gaten in de flens en acht in de steun...
Onoplettend geweest zeker ;)
Ik wou het monteren, maar er pastte iets niet goed ::)
Oeps :o ::)
Gelukkig dat toch twee gaten passen ... anders moest je opnieuw beginnen ;D ;D ;D
Met de CNC machine dat opnieuw maken is maar een kleine moeite, dus ik denk dat ik het hopelijk nu 100% juist ga hermaken. Voor de zekerheid nog eens alles nameten (diameter van de cirkel waarop de gaten staan bv). Op deze moer komt de volledige duwkracht van de motor te staan en moet dus proper vast te zitten. Maar eerst eens naar school gaan nu :D
Je display is gearriveerd, Peter. Ik zet er zo snel mogelijk de connector aan. Bedankt!
Ik krijg de foto jammer genoeg niet recht, sorry voor de stijve nek...
(http://www.treinbaanrian.be/images/eindwerk/peterlcd.jpg)
Eenvoudige manier (http://www.wikihow.com/Turn-Your-Computer-Screen-Upside-Down) om Rian's tekst te lezen ;)
Rian, graag gedaan!
Nu nog de achtergrondverlichting deftig aansluiten :p die was niet voorzien voor het oude display
Citaat van: conducteur op 21 maart 2014, 19:38:46 PM
Nu nog de achtergrondverlichting deftig aansluiten :p die was niet voorzien voor het oude display
Als je de backlight bedoelt, dit kan via een potmetertje, heel simpel. Of via een state-of-the-art PWM gestuurd via je micro controller.
Ja, is in orde hoor :p Er staat een connector op het printje, maar die was voorzien voor het 14 pins display uit de oertijd dat ik heb gekregen van Peter ter vervanging van m'n kapotte display.
De weerstand van 47 ohm was voorzien maar dus niet aangesloten via deze connector. Twee draadjes en het euvel was al verholpen :p.
Beetje bij beetje maken we vorderingen, gisteren mij bezig gehouden met het programma verder te testen en uit te breiden met de nodige boodschappen die per rs232 naar de terminal gestuurd worden. Werkt schitterend. Vandaag vlug eens de lichtsluis geprobeerd (nog definitief te monteren), kabelgootje gezaagd, om nog wat kabeltjes in orde te krijgen aan de spoor.
Elke dag beetje uitbreiden (dingen die nog definitief moeten gemonteerd worden, of aangesloten worden, en dan dat deel testen in het programma) en beetje bij beetje gaat het wel vooruit. Ik heb er een positief gevoel bij, de laatste tijd heb ik elke keer de volle goesting om er aan voort te doen (al is het maar iets klein, na school en niet altijd evenveel tijd. In de afgelopen 1,5 jaar zijn er wel momenten geweest waarbij ik het ding door het raam wou smijten. Maar iemand zij me ooit, elke mislukking is er gekomen door één keer te weinig te proberen, en heb geleerd dat dit geen halve waarheid is.
Zover staan we nu, tot +/- de helft werkt alles al 100% zoals het moet. De rest moet ik nog verder testen en uitproberen (zie programma):
;
-------------------------------------------------------------------------------
;programma GIP
;Controller = PIC 16F887
;-------------------------------------------------------------------------------
include 16f887
pragma target OSC HS -- internal crystal or resonator
pragma target clock 20_000_000 -- oscillator frequency
pragma target WDT disabled -- WDT off
pragma target LVP disabled -- no low voltage programming
pragma target MCLR external -- re3/mclr pin function select bit
include delay
include print
include format
--
;Volledig digitale IO (analoge ingangen uitgeschakeld)
enable_digital_io()
--------------------------------------------------------------------------------
;aliassen en direction
--------------------------------------------------------------------------------
;Led op poort A1
alias direction is pin_C0
alias step is pin_C1
alias schakelaar is pin_C2
alias lichtsluis is pin_b2
alias relais is portd
alias relaisinrij is pin_b1
alias inrij is pin_b0
portd_direction=output
pin_C0_direction = output
pin_C1_direction = output
pin_C2_direction = input
pin_b0_direction = input
pin_b1_direction = output
pin_b2_direction = input
pin_c3_direction = output
;-------------------------------------------------------------------------------
;arrays voor programma
;-------------------------------------------------------------------------------
const word spoor[8] = { 8000, 16000, 24000,32000,40000,48000,56000,64000}
;const word spoor[8] = { 64000, 40000, 56000,32000,16000,48000,24000,8000} --
;random array voor test verandering van richting
--array spoor: aantal vanaf oorsprong
-- driver op 800 stappen per omwenteling,
--waarden nog af te regelen op exacte waarden
var byte bezet[8]
const byte leeg[]=" "
const byte spoorop[]="verplaatsen"
const byte bereikt[]="bereikt"
const byte zoeknul[]="zoek nulpunt"
const byte oprijden[]="oprijden"
const byte afrijden[]="afrijden"
const byte initstart[]="initialisatie"
const byte nulpunt[]="nulpunt bereikt"
const byte zoekspoor[]="zoekt vrij spoor"
const byte einde[]="Einde "
const byte init[]="Initialisatie"
const byte nulpunt2[]="naar nulpunt"
const byte cfr1 [] = "1"
;-------------------------------------------------------------------------------
;variabelen voor programma
;-------------------------------------------------------------------------------
var word eindpositie
var word positie
;var sword verplaatsing (in procedure of hier?)
;var sword stappen
var byte teller
var byte teller2
var bit vrijbezet
var bit i
var bit display
var byte serialcommand
var byte char
;-------------------------------------------------------------------------------
;Seriële poort
;9600 Baud
;------------------------------------------------------------------------------
const serial_hw_baudrate = 9600
include serial_hardware
serial_hw_init()
--------------------------------------------------------------------------------
; procedure verplaatsing
;direction=off/0 ==> richting nulpunt
;direction=onn/1 ==> van nulpunt weg
--------------------------------------------------------------------------------
procedure verplaatsen (word in Ppositie, word in Peindpositie) is
var word stappen ;
if Ppositie> Peindpositie then
stappen=Ppositie-Peindpositie
direction=0
else
direction=1
stappen=Peindpositie-Ppositie
end if
for stappen loop
step=!step
delay_10us(25)
end loop
end procedure
--------------------------------------------------------------------------------
;display clear procedures
-------------------------------------------------------------------------------
procedure leeg1() is
serial_hw_data=160
delay_100ms(5)
print_string(serial_hw_data, leeg)
delay_100ms(5)
end procedure
procedure leeg2() is
serial_hw_data=176
delay_100ms(5)
print_string(serial_hw_data, leeg)
delay_100ms(5)
end procedure
procedure cleardisplay() is
serial_hw_data=192
delay_100ms(5)
end procedure
--------------------------------------------------------------------------------
;procedure voor vrij spoor zoeken
--------------------------------------------------------------------------------
procedure vrijspoor() is
i=1
leeg2()
serial_hw_data=176
print_string(serial_hw_data, zoekspoor)
while i loop
teller=teller+1
if bezet[teller]==1 then
eindpositie=spoor[teller]
verplaatsen(positie,eindpositie)
positie=eindpositie
i=0
end if
end loop
teller=0
end procedure
--------------------------------------------------------------------------------
;wachten op einde opstartboodschap terminal
--------------------------------------------------------------------------------
delay_100ms(50)
;-------------------------------------------------------------------------------
;initialisatie start
cleardisplay() ; wis display
print_string(serial_hw_data, initstart)
cleardisplay()
print_string(serial_hw_data, zoeknul)
;--------------------------------------------------------------------------------
; zoek nulpunt (schakelaar=microswitch nulpunt)
;--------------------------------------------------------------------------------
relais=off
relaisinrij=off
direction=off
while schakelaar loop
step=!step
delay_10us(25)
end loop
positie=0
delay_1ms(250)
cleardisplay()
delay_1ms(250)
print_string(serial_hw_data, nulpunt)
delay_1ms(1250)
cleardisplay()
print_string(serial_hw_data, zoekspoor)
;--------------------------------------------------------------------------------
; controle 8 sporen vrij/ bezet in array bezet en terug naar nulpunt
;--------------------------------------------------------------------------------
for 8 using teller loop
eindpositie= spoor[teller]
verplaatsen(positie, eindpositie)
positie=eindpositie
bezet[teller]=lichtsluis
delay_1ms(1000)
end loop
delay_1ms(1250)
eindpositie=500
cleardisplay()
print_string(serial_hw_data, nulpunt2)
verplaatsen(positie, eindpositie)
positie=eindpositie
--------------------------------------------------------------------------------
;;terugmelding array bezet via rs232 op lcd
;--------------------------------------------------------------------------------
cleardisplay()
serial_hw_data=165
delay_1ms(250)
print_string(serial_hw_data,einde)
serial_hw_data=176
print_string(serial_hw_data,init)
delay_100ms(20)
cleardisplay()
serial_hw_data=160
for 8 using teller loop
if bezet[teller]>0 then
print_string(serial_hw_data,cfr1 )
delay_1ms(250)
else
serial_hw_data=32
delay_1ms(250)
end if
end loop
Tot hier programma al volledig foutloos, verder nog niet voldoende kunnen testen, maar al gemerkt dat bepaalde elementen min of meer werken... :p
Daarvoor moet ik eerst wat onderdelen terug permanent aansluiten. (lichtsluis en stroomdetectie inrijspoor)
--------------------------------------------------------------------------------
;einde initalisatie, start programma (afrijden, trein verlaat fiddle yard)
;--------------------------------------------------------------------------------
display=1
forever loop
relaisinrij=off
teller=128
if true then
display=0
const byte gereed[]="gereed"
leeg2()
serial_hw_data=176 ; R1K1
delay_1ms(250)
print_string(serial_hw_data, gereed)
end if
if (serial_hw_read(char)) then
leeg2()
serial_hw_data=176
print_string(serial_hw_data,oprijden)
for 8 using teller2 loop
if char==teller then
eindpositie=spoor[teller2]
leeg2()
serial_hw_data=176
print_string(serial_hw_data, spoorop)
verplaatsen(positie, eindpositie)
leeg2()
serial_hw_data=176
print_string(serial_hw_data, bereikt)
positie=eindpositie
teller=teller/2
serial_hw_data= (160+teller2)
relais=teller
while lichtsluis loop
delay_100ms(15)
end loop
relais=0
display=1
serial_hw_data=32
else
teller=teller/2
end if
end loop
end if
;--------------------------------------------------------------------------------
;oprijden
;--------------------------------------------------------------------------------
if inrij ==1 then ; indien wachtende trein
leeg2()
serial_hw_data=176
print_string(serial_hw_data,oprijden)
teller=0
i=1
while i loop
teller=teller+1
if bezet[teller]==1 then
;staat normaal al op vrij spoor maar toch voor veiligheid zoeken naar vrij spoor
eindpositie=spoor[teller]
leeg2()
serial_hw_data=176
print_string(serial_hw_data, spoorop)
verplaatsen(positie, eindpositie)
positie=eindpositie
leeg2()
serial_hw_data=176
print_string(serial_hw_data, bereikt)
i=0
display=0
end if
end loop
while lichtsluis==0 loop
relaisinrij=1
relais=teller
end loop
relaisinrij=0
relais=0
;--------------------------------------------------------------------------------
;terug vrij spoor zoeken
;------------------------------------------------------------------------------
vrijspoor()
end if
end loop
Ik hoop dit project toch stilaan te kunnen afronden, dus nu het zomer is tijd om daar aan voort te werken.
http://www.treinbaanrian.be/elektronica/backlash%20test.htm (http://www.treinbaanrian.be/elektronica/backlash%20test.htm)
Van Peter had ik een meetklokje in bruikleen gekregen met magnetische voet, maar dat blijft niet goed plakken op aluminium frames ::) , wat het wat "moeilijk" maakte om backlash te meten op mijn as. Dan maar een klein programma gemaakt (op basis van het "hoofdprogramma") om dit op te meten.
1)Stappenmotor gaat naar nulpunt
2)verplaatst 2000 stappen
3)gaat terug naar nulpunt, en telt aantal stappen
4)nu kan ik uitrekenen hoeveel stappen extra ik moet doen om van richting te veranderen en weergeven op mijn LCD.
Dat zou dus ook voldoende nauwkeurig moeten werken hoop ik...
edit: Ik moet het nog uitproberen, maar volgens mij is dit niet nauwkeurig genoeg? Ik ga naar het nulpunt, verander van richting (backlash is niet gecompenseerd) en zet zgn 2000 stappen. Dan draai je weer van richting (backlash), heffen beide spelingen elkaar niet op?
CiteerVan Peter had ik een meetklokje in bruikleen gekregen met magnetische voet, maar dat blijft niet goed plakken op aluminium frames
Kan je niet enkele bouten/moeren in de gleuven van je frames bevestigen? Het hoeft maar tijdelijk vast te zitten. Of een blok ijzer of boorklem die zwaar genoeg is. Zo'n meetklok loopt soepel, zolang je niet "door de stoppen" gaat zal een stevige voet niet verschuiven.
Citeeredit: Ik moet het nog uitproberen, maar volgens mij is dit niet nauwkeurig genoeg? Ik ga naar het nulpunt, verander van richting (backlash is niet gecompenseerd) en zet zgn 2000 stappen. Dan draai je weer van richting (backlash), heffen beide spelingen elkaar niet op?
Denk het ook. Dat is nl wat je doet als je met een draaibank/freesmachine werkt om zeker te zijn dat je geen last hebt van de backlash (die is er altijd wel). Als je naar een nieuwe positie gaat werk je altijd in dezelfde richting: terugdraaien en instellen.
Ja... Ik zal wel iets moeten vinden om dat te proberen op te meten met die meetklok. Mijn oplossing was te mooi om waar te zijn.
...Met die meetklok heb ik toch exact hetzelfde probleem?
1) Het systeem loopt aan tot aan het nulpunt
2) verandert van richting (speling)
3) gaat 2000 stappen vooruit, en verandert weer van richting (speling) en 2000 stappen achteruit en dan zou ik moeten proberen het verschil in afgelegde weg opmeten, maar opnieuw compenseert deze speling zich toch?
Edit: die eerste speling kan ik mogelijk opvangen, maar hoe het dan verder moet weet ik niet zo zeer. Nu ligt het nulpunt daar waar de schakelaar ingedrukt wordt. Als ik nu eens aanloop naar de schakelaar, en dan traag heel even terug vooruit ga tot die niet meer ingedrukt is? Dan kan ik direct terug vooruit zonder speling..., dan 2000 stappen (bv) vooruit, richting veranderen. Maar als ik dan terug naar de schakelaar aanloop, weet ik nooit waar dat nulpunt nu juist lag... (ik moet dan het aantal stappen tellen tussen schakelaar ingedrukt en schakelaar niet ingedrukt tellen zeker?)
Neen, dat kan:
- je gaat weg van de meetklok en stopt: dus nu heb je weg van de meetklok geen spelling
- je zet de meetklok tegen je slede en duwt die er tegen totdat je bvb 1mm induwt (met een klok van 10mm): dit is je nulpunt
- nu laat je de slede naar de meetklok toe bewegen voor bvb 8mm theroretisch berekend met de spoed van je draadstang, eventuele vertraging etc (1 puls = x mm verplaatsing --> 8 mm = yyy pulsen)
- je gaat naar de meetklok toe, dus moet je mechanisme eerste backlash opheffen en dan pas komt je slede in beweging.
- als nu je meetklok 8.65 mm meet na je pulsen dan is de totale verplaatsing (8.65 - 1) = 7.65 mm en heb je 0.35 mm backlash in je opstelling. Die 1 mm komt omdat je nulpunt 1 mm was.
Je kan bij de meeste meetklokken echter je nul instellen door aan de schijf te draaien, maar de kleine wijzer blijft wel op 1 staan. Hangt uiteraard van meetklok af.
Ja, kan ik proberen
Succes!
Er steekt al een programma in de µC om dit op te meten. Nu nog de meetklok ergens op zien te monteren
forever loop
wacht ;... wachten tot knop ingedrukt is om verder te gaan (routine in rest van programma)
verplaatsen(0,4000); ga 2 cm weg (van positie 0 naar 4000)
wacht ; meetklok goed zetten
verplaatsen(4000,4800) ; ga 4mm vooruit (800 stappen per toer ) (oproep routine in rest programma)
wacht ; wacht
verplaatsen(4800,4000); ga terug
wacht; aflezen
verplaatsen(4000,0) ;indien opnieuw te meten
end loop
... eerst eens de as deftig uitgelijnd, het was nodig.
edit: achterzijde van een oude defecte cd speler uit metaal kan dienen als basis voor de meetklok
Ik heb er lang over nagedacht, maar na het zien van Olivier's berichtje elders op het forum dat hij met z'n BelleVue stopt, ook de knoop doorgehakt om hiermee op te houden.
IK heb er héél veel van geleerd, hoe stappenmotoren in elkaar zitten, mijn ervaring met 3d-tekenen op de pc is er door vooruit gegaan, ik heb dankzij Peter die me daarvoor een hele dag geholpen heeft JAL geleerd en kan nu véél meer dan met mijn beperkte ervaring C/flowcode. (oa 16*2 lcd,rs232....), ook met de CNC kunnen werken voor dit project, waar ik ook heb "bijgeleerd". De moeilijkheidsgraad van dit project lag dan misschien een beetje boven mijn kunnen, maar dat zag ik als een uitdaging, en heb er dus als ik nu terug kijk veel aan bijgeleerd.
Ik ben al, de periodes waarin niet veel heb kunnen doen (examens, periode na overlijden mama edm) en tijd voor voorbereiding meer dan 2 jaar bezig geweest aan dit project, en heb er wel véél tijd in gestoken. Ik ben vrij ver geraakt, maar ik had al maanden het gevoel dat het bijna af zou zijn, maar telkens ik een van de laatste problemen had opgelost voor ik definitief kon beginnen met testrijden kwam er minstens een probleem bij, en heb geen goesting om nog lang te moeten "wachten" vooraleer ik eindelijk alle problemen zou hebben opgelost, en verder te kunnen doen met de bouw van de rest van een baan om eindeijk eens te kunnen rijden met m'n eigen materiaal. (in de treinclub zijn alle H0 projecten voorlopig op 3-rail).
Daarom start ik met de bouw van een eenvoudig baantje op de oppervlakte die ik heb met
gewone opstelsporen om hopelijk binnen afzienbare tijd te kunnen testrijden.
Ik hoop zoveel mogelijk materialen te kunnen recupereren, maar dat zal mij wel lukken.
Allemaal bedankt aan zij die mij hebben geholpen/gesteund/.... Ik ben zéér blij de kans te hebben gekregen om dit aan te nemen als school project, en heb er zoals al geschreven veel aan bijgeleerd, maar als ik nu zie wat er allemaal bij komt kijken was ik er misschien niet aan begonnen...
Citaat van: conducteur op 01 augustus 2014, 22:55:35 PM
...ook de knoop doorgehakt om hiermee op te houden...
Rian,
Neem eens een flinke adempauze. Zet je project een tijd(je) in de wachtrij. Bekijk alles eens vanop afstand en ik ben er zeker van dat je na een bezinningsperiode er weer volle bak tegenaan gaat!
Je bent goed op weg en het is van de technische problemen (tegenslagen?) dat je veel opsteekt - dat is het leven.
Een project van 2 jaar is in jouw perspectief van levensjaren al vrij lang, maar hoe ouder je wordt, hoe korter een jaar wordt...
Die twee jaren dat je er mee bezig bent geweest, ga je daar een schat aan informatie en kennis mee hebben verzameld. Beschouw het als een leerschool (elke stap in je leven is een leerschool).
Gooi niets weg. De 'goesting' komt wel terug!
In elk geval ben ik blij dat ik een deel(tje) van mijn kennis heb kunnen overdragen aan the-next-generation. En je bent nog altijd welkom om te brainstormen of een reëel probleem uit te werken!
Ging ik net ook schrijven, Peter.
Rian, geef niet op !
Je bent al zo ver, en aan de problemen komt zeker een eind ;-)
Ik treed Peter en Jean bij.
Struikelen en vallen is geen probleem, zolang je niet blijft liggen maar opstaat en er terug tegen aangaat.
Zet het even gewoon aan de kant, begin aan je baantje dat je in gedachten had, weliswaar een stukje kleiner omwille van heet ontbreken van, maar je zal weer andere ervaringen opdoen en uiteindelijk terug aan je "uitdaging" verder werken.
Citaat van: SuSke op 02 augustus 2014, 00:21:03 AMStruikelen en vallen is geen probleem, zolang je niet blijft liggen maar opstaat en er terug tegenaan gaat.
Knap geformuleerd, en helemaal terecht ;)
Het duurde me net allemaal iets te lang, Ik heb wel enorm veel geduld maar... Ik heb het al voor 90 % gedemonteerd... De schat aan informatie en kennis die ik heb opgedaan neem ik mee naar volgende (iets kleinschaligere ) projecten waar het nuttig gebruikt zal worden . Zie het als een soort "oefening" nu....
dat is nu blijkbaar tzo typerend voor de jeugd van tegenwoordig. Als alles niet snel gaat en van de eerste keer lukt, dan gaat het weg en begint men aan iets anders.
Neem het niet persoonlijk, Rian, maar ik zie dat meer en meer bij de jonge mensen de dag van vandaag .
Ik heb ook projectjes (op de treinbaan) die niet vlotten zoals ik het zou willen, maar die blijven dan gewoon even liggen en komen een poos (soms 2 jaar) later van onder het stof.
Jammer dat je de zaak hebt afgebroken. Maar anderzijds hoop ik dat je 1 belangrijke les geleerd hebt : START SMALL ! Begin met iets simpel en werk van daaruit verder. Dat gaat je in de toekomst veel frustratie en kopzorgen besparen.
Greetz
Dani
Spijtig om te lezen, 'k had het wel eens werkend willen zien, maar ja als het blijft tegenslaan, dan kan je er op den duur wel genoeg van krijgen ...
Het hele verhaal begon als een G.I.P., dus een schoolopdracht. Hoe zit het daarmee? Is je project door de school wel als voldoende beoordeeld, ondanks het feit dat het niet voltooid is?
Dit bouwen was niet echt een deel van de schoolopdracht, dat heb ik er maar zelf bij genomen. Enkel het dossier moest af zijn:
http://treinbaanrian.be/downloads/dossier.pdf
fijn dossier ... ik zal dat es op 't gemakje moeten doornemen :-)
Wel Rian, jammer dat je het begraaft. Hopelijk vis (of graaf ;)) je het ooit terug op...
Je had inderdaad niet één van de makkelijkste projecten genomen en er kwam heel wat bij kijken. De omstandigheden waren zoals je al liet verstaan ook niet ideaal; dus ik kan je begrijpen. Hopelijk blijf je wel modelsporen, en kan je nog vele mooie dingen laten zien.
Dani z'n tip -begin klein- zou ik zeker niet niet negeren; zoals met alles, leer eerst stappen voor je probeert te sprinten. Met programmeren is het niet anders; maak eens paar kleinere projectjes met microcontrollers en bouw zo stilletjes op naar de zwaardere. Je hebt al het materiaal nu in huis, 't zou zonde zijn om dit nu allemaal te liggen.
Stoppen met treinen en/of elektronica/techniek doe ik zeker niet. En verder zullen we links of rechts wel nog eens een technische uitdaging zoeken, maar dan kleinschaligere (neven)projecten...
That's the spirit!
Ik heb me vroeger ook zo'n een paar keer laten vangen aan de complexiteit van een aantal projecten. De ervaring komt altijd later en eens je die hebt, kan je nog niet altijd doen wat je wil; maar je zal wel sneller beseffen hoe complex sommige materie wel is en wat er allemaal bij komt kijken. Ik wijt het dikwijls aan het 'jeugdig enthousiasme'; ik zie het vandaag de dag nog maar al te vaak (op het werk). Soms moet je eens wat afstand nemen, te rade gaan bij anderen en je werk een beetje beter plannen/analyzeren.
Maar in elk geval, nog veel succes toegewenst met je toekomstige projectjes.