[GPIO] Raspberry Pi

[mcDavid]

Ground moet op ground en 5v op 5v. Moeilijker is het niet. De kant en klare oplossing is gewoon de micro-usb voedingspoort gebruiken.

[Pizza_Boom]

*Meldt zich*

Vandaag voor het eerst, na bijna een jaar in bezit, mijn raspberry GPIO iets laten doen. LED blink, een begin, maar 't is wat. En dat allemaal vanaf mijn laptop.

[CurlyMo]

Als ik een nieuw GPIO platform wil ondersteunen in wiringX en daarmee ook binnen pilight e.d. dan is het enige wat ik moet weten of een LED aan en uit te zetten is en of interrupts werken. Dan doet de rest het ook (lampen schakelen e.d.).

[Raven]

Onlangs heb ik op Ebay een I²C switch (PCA9548A) op een break-out bordje besteld. Na wat geGoogle zou het enablen/disablen van een of meerdere kanalen gedaan moeten kunnen worden m.b.v. een commando zoals:

code:

i2cset -y 0 0x70 0x01

Maar wat als ik dit vanuit een Python script wil doen? Google verwijst naar

Python:

bus.write_byte_data(device-adres,register,data)

Dat commando verwacht echter een register-adres, dat is niet van toepassing hier.

[GeeBee]

Je mag

code:

bus.write_byte(adres, waarde)

gebruiken.

Maar:
De PCA9548A is een I2C switch, waarbij je (als ik het goed heb) beschikt over 8 separate I2C bussen.
Als je dingen wilt aansturen, zou ik beginnen met een PCF8574 waarbij je beschikt over 8 I/O poorten.

[ Voor 61% gewijzigd door GeeBee op 16-10-2015 01:03 ]

[Raven]

Ok, van 't weekend maar eens met Python aan de gang en dat proberen.

Het gaat mij niet om I/O uitbreiding, ik heb hier een zeldzaam geval van 2 identieke sensors met niet te wijzigen identiek I²C adres. M.b.v. die switch kan ik er voor zorgen dat er maar één tegelijk verbonden is met de Pi Op dit moment hangen die sensors via een CD4052B aan een Arduino, maar dat vereist extra pinnen. Die switch wordt via I²C aangestuurd en vereist dus geen extra verbindingen.

[ Voor 23% gewijzigd door Raven op 16-10-2015 10:22 ]

[Siegfried.]

Ik wil aan de slag met mijn Pi, in combinatie met deze PIR-sensor.
Kunnen jullie mij op gang helpen hoe ik deze het best kan aansluiten? Ik kan weinig echt duidelijke uitleg vinden, en wil geen onderdelen opblazen door ze bijvoorbeeld kort te sluiten. Ook geen idee of dat risico reëel is, maar better safe than sorry

De bedoelde toepassing:
Zodra de PIR beweging detecteert moet de Pi een MP3 gaan afspelen. De aansturing wil ik in Python gaan afhandelen.

Heb ik nog een relais, of iets anders nodig?

[mcDavid]

Siegfried. schreef op dinsdag 20 oktober 2015 @ 22:38:
Ik wil aan de slag met mijn Pi, in combinatie met deze PIR-sensor.
Kunnen jullie mij op gang helpen hoe ik deze het best kan aansluiten? Ik kan weinig echt duidelijke uitleg vinden, en wil geen onderdelen opblazen door ze bijvoorbeeld kort te sluiten. Ook geen idee of dat risico reëel is, maar better safe than sorry

De bedoelde toepassing:
Zodra de PIR beweging detecteert moet de Pi een MP3 gaan afspelen. De aansturing wil ik in Python gaan afhandelen.

Heb ik nog een relais, of iets anders nodig?

Dat wordt lastig. Je zult dat ding open moeten maken en kijken of je ergens in kunt breken op de stuurstromen vóór het relais... Maar waarom moet het persé met die pir-module en niet gewoon met zo'n 1 dollar moduletje van ebay?

[Siegfried.]

mcDavid schreef op dinsdag 20 oktober 2015 @ 22:56:
[...]

Dat wordt lastig. Je zult dat ding open moeten maken en kijken of je ergens in kunt breken op de stuurstromen vóór het relais... Maar waarom moet het persé met die pir-module en niet gewoon met zo'n 1 dollar moduletje van ebay?

Het hoeft wat mij betreft niet persé met deze. Maar deze werd in de winkel geadviseerd, omdat ie geschikt zou zijn voor de toepassing. Nu wisten ze me daar te vertellen dat ik een relais nodig had, om em op de GPIO van de Raspberry aan te sluiten. Maar bij thuiskomst zag ik dat de PIR ook al een relais ingebouwd heeft.

Voor wat betreft deze hardware ben ik echt een beginner, dus ik heb gewoon werkelijk geen idee of het met deze sensor kan. Of dat ik inderdaad beter een PIR kan kopen die direct op de GPIO aangesloten kan worden.

[SnowDude]

Ik zou inderdaad een losse module bestellen en dan zo'n soort relais bordje: http://www.ebay.com/itm/4...2180b2:g:jKYAAOSwNgxWDnNI

[Dacuuu]

Heb net een lcd display onder het stof vandaan gehaald.
Deze zeg maar, Maar de mijne is dan DFrobot. Nu kan je deze met de header pins zo op een arduino klikken. Maar welke header pins moet ik gebruiken voor de raspberry? Kan het LCD display wel van de pcb afsolderen, maar dan sloop je het bordje, en dat is volgens mij niet nodig.

[mcDavid]

Siegfried. schreef op woensdag 21 oktober 2015 @ 07:01:
[...]


Het hoeft wat mij betreft niet persé met deze. Maar deze werd in de winkel geadviseerd, omdat ie geschikt zou zijn voor de toepassing. Nu wisten ze me daar te vertellen dat ik een relais nodig had, om em op de GPIO van de Raspberry aan te sluiten. Maar bij thuiskomst zag ik dat de PIR ook al een relais ingebouwd heeft.

Voor wat betreft deze hardware ben ik echt een beginner, dus ik heb gewoon werkelijk geen idee of het met deze sensor kan. Of dat ik inderdaad beter een PIR kan kopen die direct op de GPIO aangesloten kan worden.

Wat een raar advies. Dit is een module speciaal om 230V apparatuur aan te sluiten. Je zal hem vast wel kunnen modden om op stuursignaal niveau te laten werken, of je zou er idd een wisselstroom relais tussen kunnen zetten. Maar dat lijkt me nogal een draconische oplossing, voornamelijk omdat er ook gewoon modules bestaan die je gewoon rechtstreeks aan de GPIO kunt hangen (en vanaf een dollar beschikbaar zijn op ebay).
De enige logische verklaring is dat dit het enige was wat ze hadden liggen en je graag iets wouden aansmeren.

SnowDude schreef op woensdag 21 oktober 2015 @ 09:18:
Ik zou inderdaad een losse module bestellen en dan zo'n soort relais bordje: http://www.ebay.com/itm/4...2180b2:g:jKYAAOSwNgxWDnNI

Waar zou dat relaisbord voor nodig zijn dan? Hij hoeft niets te schakelen.

Dacuuu schreef op woensdag 21 oktober 2015 @ 11:56:
Heb net een lcd display onder het stof vandaan gehaald.
Deze zeg maar, Maar de mijne is dan DFrobot. Nu kan je deze met de header pins zo op een arduino klikken. Maar welke header pins moet ik gebruiken voor de raspberry? Kan het LCD display wel van de pcb afsolderen, maar dan sloop je het bordje, en dat is volgens mij niet nodig.

Er zit een schema bij in die link naar de example software. Als die overeen komt met jouw module kun je daar gewoon de pins op aflezen. Zo niet dan moet je even met je multimeter uitzoeken welke pin waarop zit.

[Dacuuu]

mcDavid schreef op woensdag 21 oktober 2015 @ 12:39:
Er zit een schema bij in die link naar de example software. Als die overeen komt met jouw module kun je daar gewoon de pins op aflezen. Zo niet dan moet je even met je multimeter uitzoeken welke pin waarop zit.

Heb met de multimeter gemeten. Ik weet nu welke pinnen ik moet hebben, alleen snap ik de ground en de +5v nog niet.

Als ik bijvoorbeeld in het rode vakje de VSS meer samen met bovenaan de 6e gele header pin(waar ik bij heb geschreven "Ground?" Dan meet ik dus weerstand, maar dat meet ik ook op elke 5V. Hoe weet ik nu welke ik moet hebben?

[Pizza_Boom]

Iemand ervaring met WiringPi.h library? Ik kwam erachter dat ik in Geany fijn in C kan programmeren, maar ik blijf tegen wiringPi.h aan lopen. Hij zit niet in mijn build van Raspian en ik heb even geen flauw idee hoe ik dat nou eigenlijk moet gaan downloaden en van google word ik niet wijzer.

[CurlyMo]

Zoeken naar install wiringPi levert mij toch direct een tutorial op hoe je wiringPi moet installeren.

[ Voor 7% gewijzigd door CurlyMo op 22-10-2015 22:20 ]

[Dacuuu]

Pizza_Boom schreef op donderdag 22 oktober 2015 @ 22:13:
Iemand ervaring met WiringPi.h library? Ik kwam erachter dat ik in Geany fijn in C kan programmeren, maar ik blijf tegen wiringPi.h aan lopen. Hij zit niet in mijn build van Raspian en ik heb even geen flauw idee hoe ik dat nou eigenlijk moet gaan downloaden en van google word ik niet wijzer.

http://wiringpi.com/download-and-install/

code:

git clone git://git.drogon.net/wiringPi
cd wiringPi
git pull origin
./build

Klaar

[ Voor 8% gewijzigd door Dacuuu op 22-10-2015 22:21 ]

[Pizza_Boom]

Dacuuu schreef op donderdag 22 oktober 2015 @ 22:21:
[...]


http://wiringpi.com/download-and-install/

code:

git clone git://git.drogon.net/wiringPi
cd wiringPi
git pull origin
./build

Klaar

Jij lijkt een aantal stappen over te slaan ten opzichte van de link die je post (die ik overigens ook al gevonden had, maar die nog niet echt duidelijk genoeg was voor mij).

Wellicht een rare gedachtegang, maar zou dit er niet al in moeten zitten als ik met een Python blink sketch wel gewoon leds op mijn GPIO kan laten knipperen?

[CurlyMo]

Nee, python en C modules zijn verschillend van elkaar.

[Pizza_Boom]

Hmm, thnx. Dit is dus gelukt. Nu nog even klooien om die library ook daadwerkelijk te kunnen gebruiken, references goedzetten geloof ik...

[GeeBee]

Ik krijg de GPIO om mijn Pi-2B's niet aan de praat.

Breadboard:
Led met weerstand van 330 Ohm in serie. (oranje, oranje, bruin)

Aangesloten:
Pin 6: -
Pin 16: +

Als ik led aansluit op pin 2 (5V) brandt de led.

Hiermee zou de led moeten knipperen, maar doet dat dus niet.

Python:

import RPi.GPIO as GPIO
import time, os

GPIO.setmode(GPIO.BCM)
GPIO.setup(23,GPIO.OUT)

while True:
  GPIO.output(23,1)
  time.sleep(0.5)
  GPIO.output(23,0)
  time.sleep(0.5)

GPIO23 is pin 16 volgende deze.

Ik heb een tweede Pi geprobeerd, zonder resultaat.
Verkeerd-om aangesloten is ook niet aan de orde, zelfs met twee leds antiparallel gebeurt er niets.
Zie ik nou iets elementairs over het hoofd?

[Pizza_Boom]

GeeBee schreef op vrijdag 23 oktober 2015 @ 18:17:
Ik heb een tweede Pi geprobeerd, zonder resultaat.
Verkeerd-om aangesloten is ook niet aan de orde, zelfs met twee leds antiparallel gebeurt er niets.
Zie ik nou iets elementairs over het hoofd?

Dit is hoe het op mijn B+ is opgelost. Dit werkt. Gewoon de code overgeklopt van internet trouwens.

[Pizza_Boom]

Dacuuu schreef op donderdag 22 oktober 2015 @ 22:21:
[...]


http://wiringpi.com/download-and-install/

code:

git clone git://git.drogon.net/wiringPi
cd wiringPi
git pull origin
./build

Klaar

Ik dacht dat ik onderstaande zelf kon oplossen, maar 't is me nog niet gelukt. Tips?

[Vuikie]

@pizzaboom Je moet de compiler (gcc?) wel vertellen dat ie de WiringPi library moet toevoegen tijdens het builden. -LWiringPi is volgens mij de juiste syntax. Zoek anders ff op de website van Drogon...

Ik schrijf deze reactie op mijn Phone, dus is even lastig zoeken voor me. Als je er echt niet uitkomt zal ik straks wel ff kijken op mijn pc voor de juiste syntax.

[ Voor 29% gewijzigd door Vuikie op 25-10-2015 12:54 ]

[Dacuuu]

Vuikie schreef op zondag 25 oktober 2015 @ 12:52:
@pizzaboom Je moet de compiler (gcc?) wel vertellen dat ie de WiringPi library moet toevoegen tijdens het builden. -LWiringPi is volgens mij de juiste syntax. Zoek anders ff op de website van Drogon...

Ik schrijf deze reactie op mijn Phone, dus is even lastig zoeken voor me. Als je er echt niet uitkomt zal ik straks wel ff kijken op mijn pc voor de juiste syntax.

Deze regel gebruik ik

code:

gcc -o bestandsnaam bestandsnaam.c -l wiringPi

[Pizza_Boom]

Dacuuu schreef op zondag 25 oktober 2015 @ 13:57:
[...]


Deze regel gebruik ik

code:

gcc -o bestandsnaam bestandsnaam.c -l wiringPi

Die had ik ook in LX gebruikt, maar behalve de print functie kreeg ik niks. En de printfunctie ging veel te snel, zelfs bij een delay van 2500...

EDIT:

Vuikie schreef op zondag 25 oktober 2015 @ 12:52:
@pizzaboom Je moet de compiler (gcc?) wel vertellen dat ie de WiringPi library moet toevoegen tijdens het builden. -LWiringPi is volgens mij de juiste syntax. Zoek anders ff op de website van Drogon...

Ik schrijf deze reactie op mijn Phone, dus is even lastig zoeken voor me. Als je er echt niet uitkomt zal ik straks wel ff kijken op mijn pc voor de juiste syntax.

Inmiddels werkt het dus wel. Deze, op de printcommando's na, exact overgenomen en hij doet het. Alleen gebruik ik geen gertboard, dus ik zoek nu even naar een overzichtje voor de GPIO van alle 40 pinnen zoals de wiringPi.h lib die heeft ingedeeld, 0 zit immers op 17...



Vraag ik mij nu nog steeds af of builden/compilen in Geany niet stiekem ook gewoon mogelijk zou moeten zijn met de build en compile knoppen.

[ Voor 61% gewijzigd door Pizza_Boom op 25-10-2015 15:30 ]

[Klein_Kipje]

Ik ben bezig met een squuezebox boom te maken via een Rasp B. Hier horen ook een aantal drukknoppen via de GPIO bij voor oa pauze/play.

Via https://www.raspberrypi.o...iewtopic.php?f=91&t=77070 krijg ik het wel voor elkaar om via een druk knop een letter op mijn scherm te krijgen

Aangesloten:



Alleen bij het loslaten van de drukknop blijft de letter terugkomen. Onderzoek leert mij dat dit wellicht bouncing zou kunnen zijn en is op te lossen door een condensator in serie te zetten tussen de gpiopin en de gnd.

Iemand dit al meegemaakt en opgelost ?

[ Voor 19% gewijzigd door Klein_Kipje op 27-10-2015 15:07 ]

[Pizza_Boom]

Hoe lang blijft die letter terugkomen?

[Klein_Kipje]

Tot ik er weer op druk, dus eigenlijk oneindig

[Pizza_Boom]

Dan zou ik het eerder in je programma zoeken dan in de knop. Als je nou de knop er tussen vandaan haalt en daar een jumperwire plaatst en die een keer kort sluit en daarna weer los maakt?

[Klein_Kipje]

goed plan, ga ik even proberen, thks

[Pizza_Boom]

Succes! Laat maar horen.

Zo'n RPi blijft een fantastisch leuk ding. Met een handleiding/tutorial nu de GPIO bedienbaar via het netwerk... Nu doorbouwen.

[Klein_Kipje]

Bleek een foute pin te zijn, heb het nu gewoon fatsoenlijk werkend.

[Siegfried.]

mcDavid schreef op woensdag 21 oktober 2015 @ 12:39:
[...]

Wat een raar advies. Dit is een module speciaal om 230V apparatuur aan te sluiten. Je zal hem vast wel kunnen modden om op stuursignaal niveau te laten werken, of je zou er idd een wisselstroom relais tussen kunnen zetten. Maar dat lijkt me nogal een draconische oplossing, voornamelijk omdat er ook gewoon modules bestaan die je gewoon rechtstreeks aan de GPIO kunt hangen (en vanaf een dollar beschikbaar zijn op ebay).
De enige logische verklaring is dat dit het enige was wat ze hadden liggen en je graag iets wouden aansmeren.


[...]

Waar zou dat relaisbord voor nodig zijn dan? Hij hoeft niets te schakelen.

Simpele PIR gekocht, en het werkt inmiddels helemaal naar behoren, thanks

[Pizza_Boom]

Iemand die dit herkend? Aan pin 4 (wiringPi 7, logische nummering 7) hangt een LED. Op het moment dat ik de pi aan zet, staat deze LED heel zwakjes aan. Alsof er een hele kleine lekstroom over de pin heen vloeit. Zodra ik dan een webpage open die alle pinnen bedient, vliegt ie keurig naar 0 en staat ie uit. Gaat om een RPI B+ trouwens.

[ Voor 4% gewijzigd door Pizza_Boom op 31-10-2015 18:01 ]

[Klein_Kipje]

Ik heb een 3.2"schermpje er op aangesloten wat verder wel naar behoren werk maar als de Pi uitstaat blijft de backlight van het scherm werken.

Zou het een optie zijn om de 5 volt naar het scherm toe te schakelen met behulp van een GPIO pin die gelijkt inschakelt bij het opstarten ?

[Pizza_Boom]

Iemand hier ervaring met het gebruik van wiringpi in python sketches? Werkt dat een beetje? PHP en C werken ook met de wiringpi, dus ik wilde eigenlijk graag 1 layout blijven gebruiken, omdat deze programmas simultaan zullen draaien.

[ Voor 48% gewijzigd door Pizza_Boom op 13-11-2015 09:56 ]

[!null]

Ik heb nu een Cyble sensor V2, die zet je op de watermeter en gaat dan pulsen genereren. Als ik het goed begrijp werkt hij meer als een reed switch, met andere woorden, zelf op 1 draad 3.3V aanbrengen, en de andere kant uitlezen.
Als ik het goed begrijp is het maar 1 puls per liter, in ieder geval geen hoge snelheden die de RPi niet aan zou kunnen.

Ik zie dat er heel vaak naar allerlei extra extensie boardjes wordt gegrepen voor pulse counters etc. Maar ik geloof niet dat mijn eisen heel hoog zijn, dat ik zo'n extra boardje nodig heb.

Ik zou graag bij het binnenkomen van de pulse een klein programmaatje starten dat iets wegschrijft, ik denk zelfs naar de /tmp ramdisk. Zo heb ik een kortdurend programmaatje wat vaak aangeroepen kan worden. Later haal ik dan met een cronjob de data op en zet het in een database.

Iemand een richtlijn hoe ik een programmaatje kan starten op het binnen komen van een pulse?

Anders kan ik altijd nog een C programma schrijven die op een interrupt wacht. Maar ik wil liever alles als losse programmatjes / scriptjes die op tijdsbasis of interrupt basis gaan. Maar ik vraag me af of het OS een script kan starten bij het ontvangen van een interrupt.

[ Voor 13% gewijzigd door !null op 23-11-2015 22:43 ]

[Opifex]

Ik merk nu pas dat ik mijn bericht in het verkeerde topic geplaatst heb. Had de "Let Op" beter moeten lezen
Ik hoop dat ik hier meer succes heb^^

azziplekkus schreef op vrijdag 27 november 2015 @ 13:58:
Heeft er iemand hier ervaring met GPIO programmeren dmv. procfs?
Ik zit me suf te googlen, maar kan nergens documentatie vinden, laat staan een tutorial of voorbeeldcode

[CurlyMo]

Laten we beginnen met wat je wil bereiken.

[ Voor 5% gewijzigd door CurlyMo op 28-11-2015 20:28 ]

[Opifex]

Het is een schoolopdracht, waarbij het de bedoeling is om een gpio driver met procfs te schrijven, welke later gebruikt kan worden in combinatie met een MySQL database en een PHP webpagina.
Dat laatste gaat er waarschijnlijk niet meer van komen wegens een enorm tijdgebrek, maar ik hoop toch nog iets of wat van die driver werkend te krijgen. Maar voorlopig zitten ik (en mijn mede-studenten) echt met onze handen in het haar...

[CurlyMo]

De procfs driver is toch niet het doel, maar een middel om een doel te gebruiken?

[Room42]

CurlyMo schreef op zaterdag 28 november 2015 @ 21:50:
De procfs driver is toch niet het doel, maar een middel om een doel te gebruiken?

Zo werken schoolopdrachten niet

[CurlyMo]

Ik heb nog nooit gehoord van GPIO aansturing via procfs. Zelf wel drivers geschreven die gebruik maken van de sysfs en van memory mapping, vandaar.

[Opifex]

CurlyMo schreef op zaterdag 28 november 2015 @ 22:03:
Ik heb nog nooit gehoord van GPIO aansturing via procfs. Zelf wel drivers geschreven die gebruik maken van de sysfs en van memory mapping, vandaar.

Google is van dezelfde mening... Op uitzondering van een 2-tals scripts op github is er nergens iets te vinden over gpio aansturing met procfs...

Een gelijkaardige opdracht, maar dan met sysfs was de opgave van vorig jaar. Maar dit jaar is sysfs dus geen geldige methode om te gebruiken... (Zoals Evanescent reeds zei: Voor schoolopdrachten is het vaak niet voldoende om een doel te bereiken, maar is het ook belangrijk dat je de richtlijnen volgt. Zoals in dit geval: het gebruik van procfs.)

[CurlyMo]

Zet gelijk die github linkjes hier neer

[Opifex]

Deze had ik al gevonden:
https://github.com/oh1ko/am2301
https://github.com/ppisa/rpi-rt-control
https://github.com/qomo/rasp_ldd
https://github.com/vpcola/drivers

De meeste zijn wel interrupt based, en dat is geen vereiste voor onze opdracht. (En het onnodig complexer maken lijkt me ook niet het slimste om te doen).

[CurlyMo]

Wegen de totale gebrek aan informatie dan toch maar de vraag. Gaat het hier over een kernelspace driver of userspace? Al die github repositories zijn namelijk kernel modules.

[Opifex]

Het gaat over kernelspace. Heb reeds een nieuwe kernel gecompileerd voor de pi om dit mogelijk te maken.

Ik denk dat ik misschien iets gevonden heb:
https://github.com/qomo/r.../master/led_driver3/led.c

Zou ik hier iets mee kunnen?

(Ik ben een rookie programmer, dus ik stel waarschijnlijk vragen die voor jullie heel simpel klinken. Mijn excuses daar alvast voor)

[CurlyMo]

azziplekkus schreef op zaterdag 28 november 2015 @ 22:24:
(Ik ben een rookie programmer, dus ik stel waarschijnlijk vragen die voor jullie heel simpel klinken. Mijn excuses daar alvast voor)

Nee, je geeft vooral 0,0 informatie waardoor er geen antwoorden te geven zijn en geen hulp te bieden is. Dus opnieuw een aanname: je moet een gpio kernel driver schrijven die zichzelf beschikbaar maakt via procfs?

[Opifex]

CurlyMo schreef op zaterdag 28 november 2015 @ 22:26:
[...]

Nee, je geeft vooral 0,0 informatie waardoor er geen antwoorden te geven zijn en geen hulp te bieden is. Dus opnieuw een aanname: je moet een gpio kernel driver schrijven die zichzelf beschikbaar maakt via procfs?

Sorry hiervoor. De informatie die wij zelf krijgen is ook heel karig, wat het er ook niet eenvoudiger op maakt =/

Heb even voor de zekerheid mijn collega geraadpleegd, en je aanname is juist. Dat is inderdaad de opdracht.
(Het deel waarbij we met onze handen in het haar zitten tenminste)

[CurlyMo]

azziplekkus schreef op zaterdag 28 november 2015 @ 22:29:
Sorry hiervoor. De informatie die wij zelf krijgen is ook heel karig, wat het er ook niet eenvoudiger op maakt =/

Maar niet zo karig dat je mijn aannames had kunnen voorkomen door die informatie zelf al te geven

Lees dit eens:
http://derekmolloy.ie/wri...dule-part-1-introduction/

En een paar van mijn kernel modules (o.a. aanpassing van andere modules):
https://github.com/piligh...ule/blob/master/pilight.c
https://github.com/linux4...ng/media/lirc/lirc_gpio.c

Basis zit daar wel in, zoals gpio interfacen.

[Opifex]

CurlyMo schreef op zaterdag 28 november 2015 @ 22:58:
[...]

Maar niet zo karig dat je mijn aannames had kunnen voorkomen door die informatie zelf al te geven

Probleem is dat ik zelf nog nooit van procfs gehoord had, vooraleer de opdracht gegeven werd. Ik heb/had dus geen clue wat het precies is, doet of hoe het gebruikt wordt. Daarom dat het ook moeilijk voor mij is om uit te leggen wat de bedoeling is.

Lees dit eens:
http://derekmolloy.ie/wri...dule-part-1-introduction/

En een paar van mijn kernel modules (o.a. aanpassing van andere modules):
https://github.com/piligh...ule/blob/master/pilight.c
https://github.com/linux4...ng/media/lirc/lirc_gpio.c

Basis zit daar wel in, zoals gpio interfacen.

Ik begin stilaan het plaatje te zien. procfs dient niet om de gpio pinnen aan te sturen, maar is wel een manier om met de kernel module te communiceren. Die kernel module stuurt dan op zijn beurt de gpio aan.

Klinkt dit logisch? Of ben ik wartaal aan het uitkramen?

Hoe dan ook bedankt voor die 3 links! Ben nu die eerste eens goed aan het doorlezen, en ga proberen of ik daar al iets werkend van krijg

[CurlyMo]

procfs is daar simpelweg niet voor bedoeld. Sysfs en devfs wel. Daarom vind ik je opdracht raar

[Opifex]

CurlyMo schreef op zaterdag 28 november 2015 @ 23:14:
procfs is daar simpelweg niet voor bedoeld. Sysfs en devfs wel. Daarom vind ik je opdracht raar

Ik gok dat als ik sysfs gebruik om de gpio's aan te sturen, maar deze dan bestuur via procfs dat het ook wel goed zal zijn...

Anyways, nu ik door heb dat de eerste doelstelling gpio aansturen via de kernel is, heb ik dit geprobeerd (adhv. een paar artikels doorklikken in jouw eerste link), maar nu krijg ik "unkknown symbol in module" als ik deze wil uitvoeren met insmod. Ik ben er achter gekomen dat je meer informatie krijgt als je daarna met dmesg in de kernel log gaat kijken, en daar vind ik dit:

code:

[  128.371717] hello: Unknown symbol gpiod_set_raw_value (err 0)
[  128.371746] hello: Unknown symbol gpiod_export (err 0)
[  128.371766] hello: Unknown symbol gpio_free (err 0)
[  128.371784] hello: Unknown symbol gpiod_unexport (err 0)
[  128.371801] hello: Unknown symbol gpiod_direction_output_raw (err 0)
[  128.371842] hello: Unknown symbol gpio_to_desc (err 0)
[  128.371861] hello: Unknown symbol gpio_request (err 0)
[  551.320094] hello: Unknown symbol gpiod_set_raw_value (err 0)
[  551.320139] hello: Unknown symbol gpiod_export (err 0)
[  551.320161] hello: Unknown symbol gpio_free (err 0)
[  551.320179] hello: Unknown symbol gpiod_unexport (err 0)
[  551.320198] hello: Unknown symbol gpiod_direction_output_raw (err 0)
[  551.320239] hello: Unknown symbol gpio_to_desc (err 0)
[  551.320256] hello: Unknown symbol gpio_request (err 0)

Het lijkt dus alsof linux/gpio.h niet geinclude is. Maar deze is dat wel...

Enig idee wat een andere oorzaak zou kunnen zijn?

edit: code:

code:

#include <linux/init.h>
#include <linux/module.h>   
#include <linux/kernel.h>   
#include <linux/gpio.h>  

static char *name = "world";
module_param(name, charp, S_IRUGO);
MODULE_PARM_DESC(name, "Naam om weer te geven in var/log/kern.log"); 

static unsigned int gpioLED = 11; 
static bool     ledOn = 0;

int init_module(void)
{
    printk(KERN_INFO "init_module() called\n");
    printk(KERN_INFO "Hello %s!", name);
    
    printk(KERN_INFO "GPIO_TEST: Initializing the GPIO_TEST LKM\n");
    ledOn = true;
    gpio_request(gpioLED, "sysfs");          // gpioLED is hardcoded to 49, request it
    gpio_direction_output(gpioLED, ledOn);   // Set the gpio to be in output mode and on
    // gpio_set_value(gpioLED, ledOn);          // Not required as set by line above (here for reference)
    gpio_export(gpioLED, false);             // Causes gpio49 to appear in /sys/class/gpio
    

    return 0;
}
 
void cleanup_module(void)
{
    gpio_set_value(gpioLED, 0);              // Turn the LED off, makes it clear the device was unloaded
    gpio_unexport(gpioLED);                  // Unexport the LED GPIO
    gpio_free(gpioLED);                      // Free the LED GPIO
    printk(KERN_INFO "cleanup_module() called\n");
}

[ Voor 26% gewijzigd door Opifex op 29-11-2015 00:15 ]

[CurlyMo]

Google Startpage is your friend. Eerste hit geeft hier aan wat het probleem is.

[Opifex]

CurlyMo schreef op zondag 29 november 2015 @ 00:34:
Google Startpage is your friend. Eerste hit geeft hier aan wat het probleem is.

Mijn Google skills zijn dan toch niet wat ze moeten zijn, want met de keywords die ik ingeef vind ik niets op de eerste hit =/

Ik heb wel op 2 verschillende hits gelezen dat deze functies niet vanuit een module opgeroepen kunnen worden. Maar dat lijkt me zo raar, aangezien het hier wel kan:
http://derekmolloy.ie/ker...ramming-buttons-and-leds/

[CurlyMo]

Waar zoek je op?

[franssie]

Eh niet bij

#include

Dat # niet weg? Of is dat hier geen commentaar teken?

[CurlyMo]

franssie schreef op zondag 29 november 2015 @ 11:34:
Eh niet bij

#include

Dat # niet weg? Of is dat hier geen commentaar teken?

C != python. De commentaar tekens niet hetzelfde.

C:

//
/* */

Python:

#

[franssie]

Ah ik werk nooit in c, weer wat geleerd

[CurlyMo]

franssie schreef op zondag 29 november 2015 @ 11:39:
Ah ik werk nooit in c, weer wat geleerd

De reden dat het niet werkt is minder voor de hand liggend, maar wel makkelijk te vinden als je op de juiste manier zoekt.

[Opifex]

heb oa deze zoektermen gebruikt

code:

linux/gpio.h unknown symbol in module
unknown symbol in module
Unknown symbol gpio_free
insmod unknown symbol in module
could not insert module unknown symbol

EDIT:
Heb na nog wat zoeken dit gevonden:
http://www.bramschoenmakers.nl/en/node/300.html

Net zoals de persoon op die pagina zegt

I was just lucky to hear it from someone. I couldn't have solved this myself.

Snap ik ook niet echt hoe je dit kan weten zonder dat iemand het je verteld.

[ Voor 52% gewijzigd door Opifex op 29-11-2015 14:16 ]

[CurlyMo]

azziplekkus schreef op zondag 29 november 2015 @ 14:05:
Heb na nog wat zoeken dit gevonden:
http://www.bramschoenmakers.nl/en/node/300.html
[...]
Snap ik ook niet echt hoe je dit kan weten zonder dat iemand het je verteld.

Blijkbaar weet startpage toch ook dat ik C programmeur ben aangezien het mijn eerste resultaat is

Ik vind het wel een goede les van Linux. Toevallig kwam ik gisteren nog een stukje broncode van mezelf tegen in zo'n "universiteitsproject". Niks geen "Because I don't care about the license for a little university project.":
https://github.com/Hypna/Texas-State-IEEE-R5-2015/issues/1

[Opifex]

CurlyMo schreef op zondag 29 november 2015 @ 14:59:
[...]

Blijkbaar weet startpage toch ook dat ik C programmeur ben aangezien het mijn eerste resultaat is

Ik vind het wel een goede les van Linux. Toevallig kwam ik gisteren nog een stukje broncode van mezelf tegen in zo'n "universiteitsproject". Niks geen "Because I don't care about the license for a little university project.":
https://github.com/Hypna/Texas-State-IEEE-R5-2015/issues/1

Zou kunnen, ik programmeer meestal op Windows. Deze Ubuntu gebruik ik zelden, dus misschien vandaar dat hij andere resultaten geeft Ik heb hem pas ergens onderaan op een pagina gevonden.

En tja... ergens begrijp ik hun ook wel hoor. De modules die ik nu schrijf zijn ook maar terwijze van test en experimentatie. Daarom dat ik ook alle niet-essentiële regels code er van tussen laat.
Het enige verschil met hun is dat deze code niet opnieuw gepubliceerd wordt.
Als ik een nieuw programma zou schrijven en op het internet zou zetten, dan zou ik ze er natuurlijk wel weer bijvoegen.

Anyways, mijn collega had dit gevonden:
https://github.com/bartja..._led_module_2/helloled3.c

Ben hier mee aan de slag gegaan, en heb alles draaiend gekregen. (ook het bestand aanmaken, etc.)
Alleen verandert de status van de led niet. Ik dacht eerst dat het een probleem was met de pin nummering, maar nu blijkt dat de status intern ook niet verandert. Dus is het toch ergens een software probleem.


Output is dmesg na het aanzetten van de led, en vervolgens status weer uitlezen:

code:

[ 4703.832347] Put LED on
[ 4707.752054] LED state is off

[ Voor 22% gewijzigd door Opifex op 29-11-2015 15:36 ]

[CurlyMo]

Hoe probeer je nu de status te veranderen vanuit de shell?

[Opifex]

CurlyMo schreef op zondag 29 november 2015 @ 16:07:
Hoe probeer je nu de status te veranderen vanuit de shell?

[code] echo 1 > /dev/helloled3 [/quote]

Dit commando wordt ook wel uitgevoerd, want hij laat het zien in dmesg. Maar de status wijzigt niet. (niet op de led zelf, en niet in /dev/helloled3)

[CurlyMo]

Ik zou de standaard GPIO functies van de kernel zelf gebruiken zoals beschreven in die tutorial (en zoals je in mijn modules kan zien).

[Opifex]

Dat probeer ik al sinds gisteren, maar ik krijg het maar niet werkend =/
Heb de code nu zo aangepast dat ik 2 pins aanstuur. één hoog, en één laag. (Want ik vermoed dat het bordje dat het io-bord actief-laag is).
Zo zou er altijd één led aanmoeten zijn, maar dat gebeurt dus niet.

Doe ik iets fout?

code:

static char *name = "world";
module_param(name, charp, S_IRUGO);
MODULE_PARM_DESC(name, "Naam om weer te geven in var/log/kern.log"); 

static unsigned int gpioLED = 3; 
static unsigned int gpioLED2 = 2; 
//static bool     ledOn = 1;

int init_module(void)
{
    printk(KERN_INFO "init_module() called\n");
    printk(KERN_INFO "Hello %s!", name);
    
    printk(KERN_INFO "GPIO_TEST: Initializing the GPIO_TEST LKM\n");
    
       if (!gpio_is_valid(gpioLED)){
      printk(KERN_INFO "GPIO_TEST: invalid LED GPIO\n");
      return -ENODEV;
   }
   
    //ledOn = true;
    gpio_request(gpioLED, "sysfs");          // gpioLED is hardcoded to 49, request it
    gpio_direction_output(gpioLED, 0);   // Set the gpio to be in output mode and on
    gpio_set_value(gpioLED, 0);          // Not required as set by line above (here for reference)
    gpio_export(gpioLED, false);             // Causes gpio49 to appear in /sys/class/gpio
    printk(KERN_INFO "Led1: 0?\n");

    gpio_request(gpioLED2, "sysfs");          // gpioLED is hardcoded to 49, request it
    gpio_direction_output(gpioLED2, true);   // Set the gpio to be in output mode and on
    gpio_set_value(gpioLED2, true);          // Not required as set by line above (here for reference)
    gpio_export(gpioLED2, true);             // Causes gpio49 to appear in /sys/class/gpio
    printk(KERN_INFO "Led2: 1?\n");

    return 0;
}
 
void cleanup_module(void)
{
    gpio_set_value(gpioLED, 0);              // Turn the LED off, makes it clear the device was unloaded
    gpio_unexport(gpioLED);                  // Unexport the LED GPIO
    gpio_free(gpioLED);                      // Free the LED GPIO
    
    gpio_set_value(gpioLED2, 0);              // Turn the LED off, makes it clear the device was unloaded
    gpio_unexport(gpioLED2);                  // Unexport the LED GPIO
    gpio_free(gpioLED2);                      // Free the LED GPIO
    printk(KERN_INFO "cleanup_module() called\n");
}

[CurlyMo]

Heb je gechecked of het aan- en uitzetten wel werkt via sysfs direct?
Waar is je GPL licentie lijn. De gpio functies werken anders niet, zoals je al had gevonden.

[Opifex]

Hoe controleer ik dat?
En die GPL licentie lijn staat er in. Is maar een stuk van de code. Heb de headers en alles rond die GPL licentie er uit gelaten om geen gigantische stukken code hier te moeten pasten.

[CurlyMo]

Hoe je GPIO aanstuurt via sysfs mag je zelf weer even zoeken.

[Opifex]

Oh, dat bedoel je. Ik dacht dat je bedoelde dat ik dmv. sysfs moest controleren of bovenstaande code de gpio pin aanstuurde. Had het verkeerd begrepen

Ik ga me eens in sysfs verdiepen dan!

[Opifex]

Gisterenmorgen kreeg ik weer leuk nieuws te horen...
Alle code die ik geschreven had mocht ik weer in de prullebak gooien... standaard kernel functies mochten NIET gebruikt worden! Alles GPIO aansturing moest rechtstreeks op de registers gebeuren...

Nuja, na een hele dag github door te spitten is het uiteindelijk toch gelukt om werkende code te krijgen. Zelfs een deel van procfs werkt al! (ik begin eindelijk het concept van procfs door te hebben).

Alleen loop ik nu ergens anders tegenaan.
Voorlopig heb ik de led_write functie zo geschreven dat hij enkel de user input terug stuurt.
echo 1 > /proc/GPIO/led geeft dus "user input: 1" terug in dmesg.
Alleen zit ik met het probleem dat deze entry blijkbaar niet leeggemaakt wordt. De functie led_write blijft opgeroepen worden met dezelfde data.
Kan ik dit bestand op één of andere manier clearen? Of is er iets anders dat ik fout doe?

[CurlyMo]

Het is me niet helemaal duidelijk. Memory mapping was overigens wel te verwachten qua opdracht

[Twam]

Ik ben sinds vorige week met een Zero aan het prutsen, maar krijg de GPIO-/i2c niet voor elkaar. Ik probeer de pHAT DAC en een HDC1008 aan te sluiten, maar ze worden niet herkend.

Tot nu toe heb ik al wel nieuw image geïnstalleerd, evenals aantal verschillende manuals geprobeerd om i2c aan de praat te krijgen. i2cdetect -y 1 geeft echter ook gewoon een output, hoewel zonder adressen erin, dus ik heb het idee dat de software eigenlijk wel klopt.

Hebben er mensen tips om na te gaan of de GPIO-sectie überhaubt werkt? Ik heb helaas geen multimeter...

Op het oog lijkt het soldeerwerk geen sluiting te veroorzaken ofzo, maar het zou natuurlijk kunnen dat ik tijdens het solderen toch iets beschadigd heb ofzo. Los van dit probleem werkt de Zero verder ook keurig, draait als een zonnetje, maar het lijkt me dat die HAT/GPIO toch ook gewoon moet werken.

[CurlyMo]

Een LED aanzetten via GPIO is altijd een goede eerste stap.

[Raven]

Twam schreef op woensdag 17 februari 2016 @ 15:29:
i2cdetect -y 1 geeft echter ook gewoon een output, hoewel zonder adressen erin, dus ik heb het idee dat de software eigenlijk wel klopt.

Aan de kant van de Pi lijkt het inderdaad te kloppen, een overzicht zonder adressen betekend dat je de Pi iig goed ingesteld hebt.

Heb je de adres-pinnen van de HDC1008 wel aangesloten?

Wat betreft de pHAT DAC, wel de modules van de blacklist gehaald? http://learn.pimoroni.com...berry-pi-phat-dac-install

[ Voor 13% gewijzigd door Raven op 17-02-2016 17:58 ]

[u_nix_we_all]

Twam schreef op woensdag 17 februari 2016 @ 15:29:
Tot nu toe heb ik al wel nieuw image geïnstalleerd, evenals aantal verschillende manuals geprobeerd om i2c aan de praat te krijgen. i2cdetect -y 1 geeft echter ook gewoon een output,

Op de Pi 1 moet je i2cdetect -y 0 gebruiken, wellicht dat dat op de zero ook zo is ?

[Raven]

Sinds Pi B rev.1 (die met 256MB RAM) wordt 0 niet meer gebruikt, volgens mij zou het op de Zero net als de andere Pi's 1 moeten zijn. Anders had dit wel een foutmelding opgeleverd (althans, dacht van wel).

[ Voor 18% gewijzigd door Raven op 17-02-2016 18:23 ]

[Twam]

CurlyMo schreef op woensdag 17 februari 2016 @ 16:48:
Een LED aanzetten via GPIO is altijd een goede eerste stap.

Hm, goeie. Had er toevallig nog ergens paar liggen, suf dat ik daar niet aan gedacht had (ik speel de griep-kaart).

Dit lijkt er idd op te wijzen dat sommige pins het wel doen, maar andere niet. Zo doet qua GND alleen pin 39 het, werken beide 5v pins en doet van de 2 3V3 pins alleen 1 het.

Even een paar jumper wires aan die led en direct contact maken met de via's (die idd hier en daar nog zichtbaar waren) duidt erop dat ik toch gefaald heb in het solderen. Er zat soldeer aan alle pinnen, maar ze waren klaarblijkelijk niet allemaal gesoldeerd.

Well, this is awkward... *Mompelt iets over weinig soldeer-oefening*

Raven en u_nix_we_all in ieder geval bedankt voor het meedenken (had trouwens idd blacklist aangepast), en CurlyMo bedankt voor de LED-tip! Ik ga even een hoekje zoeken om me in te schamen.

[Vuikie]

Hallo allemaal,

ik probeer WiringX aan de praat te krijgen op mijn Pi, maar tot op heden lukt dat niet. Ik loop ergens tegen aan, ik zie wss iets simpels over het hoofd, maar weet niet wat.

Ik heb WiringX geïnstalleerd volgens de aanwijzingen op de github pagina. Dat gaat allemaal goed, daarna compile ik de blink.c dmv. de volgende commando:

code:

gcc -Wall -o blink blink.c -lwiringX

Maar als ik dan

code:

sudo ./blink 11

doe dan krijg ik de melding:

code:

./blink: error while loading shared libraries: libwiringX.so: cannot open shared object file: No such file or directory

Ik heb al geprobeerd dmv dpkg -L libwiringX om te kijken of hij wiringX goed heeft geïnstalleerd en dat lijkt er wel op:

code:

/usr
/usr/local
/usr/local/sbin
/usr/local/sbin/wiringx-read
/usr/local/sbin/wiringx-i2c-spi
/usr/local/sbin/wiringx-interrupt
/usr/local/sbin/wiringx-blink
/usr/local/lib
/usr/local/lib/libwiringX.so
/usr/local/lib/libwiringX.a
/usr/local/include
/usr/local/include/wiringX.h

Wie kan mij hier mee helpen?

[CurlyMo]

Zoals je in de lijst ziet worden de voorbeelden al voor je geïnstalleerd. Dus voor blink kan je gewoon dit doen:

# sudo wiringx-blink 11

Om jouw manier te laten werken doe je eerst:

# sudo ldconfig

Daarna werkt het ook via:

# sudo ./blink 11

Mag ik je vragen hoe je bij wiringX komt en niet wiringPi bent gaan gebruiken? Ben wel nieuwsgierig

[Vuikie]

CurlyMo schreef op zondag 21 februari 2016 @ 23:17:
Zoals je in de lijst ziet worden de voorbeelden al voor je geïnstalleerd. Dus voor blink kan je gewoon dit doen:
Om jouw manier te laten werken doe je eerst:

# sudo ldconfig

Daarna werkt het ook via:

# sudo ./blink 11

Mag ik je vragen hoe je bij wiringX komt en niet wiringPi bent gaan gebruiken? Ben wel nieuwsgierig

YAY

 sudo ./blink 11
running on a raspberrypi
Writing to GPIO 11: High
Writing to GPIO 11: Low
enz...

Ik ben bij wiringX uitgekomen, ten eerste omdat ik wiringPi al werkend heb . Maar ik vind de modulaire opzet van wiringX wel mooi. En ik krijg 1 dezer dagen een C.H.I.P. binnen en wil daar ook met wiring kunnen knoeien(Ben een beetje een Arduino-fiel... is dat een woord? )
Ik heb daar op het forum al gevraagd voor wiringX support, maar gezien het antwoord, dacht ik van, hmmm dat wordt dus zelf maken.

Vandaar mijn interesse in wiringX.

[CurlyMo]

Als je een nieuwe module wil schrijven voor wiringX en afhankelijk van je kennis, lijkt het me zinvol om dat alvast in de nieuwe opzet van wiringX te doen. Wat ik namelijk wil is:
1. Herkennen van de SoC en alle GPIO beschikbaar maken.
2. Een template laten selecteren door de gebruiker die aangeeft hoe de GPIO van de SoC fysiek gebruikt kunnen worden door een apparaat.

Zo kunnen we dezelfde module gebruiken voor de BananaPi en PCDuino omdat ze dezelfde SoC gebruiken. De pinning is alleen anders, maar door een template kan je aangeven of je op een BananaPi of een PCDuino werkt.

Hetzelfde idee voor de verschillende versies Raspberry Pi's. Velen gebruiken dezelfde SoC, maar de ene Pi heeft maar een 26 pins header, de andere 40 pins. Door het loskoppelen van de SoC en de mapping wordt het geheel nog modulairder (als dat een werkwoord is ).

[Vuikie]

Dat klinkt interessant. Ik ben nog lerende qua embedded proggen, maar hou wel van een uitdaging.

Maar hoe wil je dit dan doen? Het meegeven van een argument aan wiringXSetup()?

Bijv:

code:

wiringXSetup(BananaPi);

of

code:

wiringXSetup(RaspberryPiB2);

en dan aan de hand daarvan de SOC kiezen en het bijbehorende GPIO template?

[CurlyMo]

Precies. Je geeft op dat het om een RaspberryPi 2 gaat. Dan weet wiringX welke SoC daarbij hoort en hoe de GPIO van de SoC zich vertalen naar de fysiek beschikbaar GPIO van het apparaat.

Zo zou je GPIO 1 van de SoC op de BananaPi fysiek GPIO 6 kunnen zijn, maar op de PCDuino GPIO 3. Of bepaalde GPIO kunnen helemaal niet extern bereikbaar zijn gemaakt.

[Vuikie]

CurlyMo schreef op maandag 22 februari 2016 @ 11:31:
Precies. Je geeft op dat het om een RaspberryPi 2 gaat. Dan weet wiringX welke SoC daarbij hoort en hoe de GPIO van de SoC zich vertalen naar de fysiek beschikbaar GPIO van het apparaat.

Zo zou je GPIO 1 van de SoC op de BananaPi fysiek GPIO 6 kunnen zijn, maar op de PCDuino GPIO 3. Of bepaalde GPIO kunnen helemaal niet extern bereikbaar zijn gemaakt.

Hmm, ik zit een beetje door je code te grasduinen, maar ik snap 1 ding niet helemaal.

in bananapi.c staat het volgende stukje code:

C:

#define SUNXI_GPIO_BASE     (0x01C20800)
//--snip--
        if(wiringBPMode == WPI_MODE_PINS)//wordt gezet in de setup
            pin = pinToGpioR3[pin];//Dit is 272 als we GPIO 6 willen hebben op de BananaPi. Dit is GPIO PI16 op de Allwinner A20 van de BPI
//--snip--
            bank = pin >> 5;//dit is 8
        i = pin - (bank << 5);//dit is 16
        phyaddr = SUNXI_GPIO_BASE + (bank * 36) + 0x10; // +0x10 -> data reg

Maar ik kom er niet uit, als ik dit 'met de hand' uitreken kom ik op een physaddr van 0x1C20930. Kijk ik in de datasheet dan zitten de bitjes van gpio PI16 op bit 0-2 van register PI_CFG2. Deze heeft een offset van 0x128.
Als ik dan deze offset neem van de GPIO_BASE (0x01C20800) kom ik uit op 0x01C20928. Dit is een verschil van 0x08. Dus ik vraag mij een beetje af waar ik de mist in ga...

***edit***
Klein detail, de configure registers in de A20 zijn 16bit. In de Allwinner R8, die op de C.H.I.P. gebruikt wordt zijn deze 32bit.

[ Voor 4% gewijzigd door Vuikie op 23-02-2016 17:26 ]

[CurlyMo]

Op het punt dat ik dit gewoon gekopieerd heb van de code van BananaPi zelf. De enige module die ik echt zelf heb gemaakt is de Hummingboard. Ik zou zelf ook de documentatie in moeten duiken om hier antwoord op te hebben.

[Vuikie]

WOW, jij bent snel

CurlyMo schreef op dinsdag 23 februari 2016 @ 17:25:
Op het punt dat ik dit gewoon gekopieerd heb van de code van BananaPi zelf. De enige module die ik echt zelf heb gemaakt is de Hummingboard. Ik zou zelf ook de documentatie in moeten duiken om hier antwoord op te hebben.

hmmm is wel een leuk excuus om er 1 te bestellen

[ Voor 69% gewijzigd door Vuikie op 23-02-2016 17:29 ]

[Raven]

Als je een Python script wil maken dat alléén een interrupt in de gaten moet houden en a.d.h. daarvan telkens iets moet doen, hoe kun je er dan voor zorgen dat het script tussen de interrupts wel actief blijft maar "niets" doet dat de Pi2 belast?

[CurlyMo]

Raven schreef op maandag 29 februari 2016 @ 13:18:
Als je een Python script wil maken dat alléén een interrupt in de gaten moet houden en a.d.h. daarvan telkens iets moet doen, hoe kun je er dan voor zorgen dat het script tussen de interrupts wel actief blijft maar "niets" doet dat de Pi2 belast?

Precies wat je al zegt eigenlijk Gewoon via een blocking read de interrupt laten lezen. Zolang er geen interrupts zijn, dan zal hij ook geen resources vragen.

[Raven]

CurlyMo schreef op maandag 29 februari 2016 @ 13:21:
[...]

Precies wat je al zegt eigenlijk Gewoon via een blocking read de interrupt laten lezen. Zolang er geen interrupts zijn, dan zal hij ook geen resources vragen.

Korte Google zoektocht later: GPIO.wait_for_edge() ? Het gaat hier overigens alleen om het detecteren van rising edge, niet beide.

[ Voor 8% gewijzigd door Raven op 29-02-2016 13:25 ]

[u_nix_we_all]

Raven schreef op maandag 29 februari 2016 @ 13:25:
[...]

Korte Google zoektocht later: GPIO.wait_for_edge() ? Het gaat hier overigens alleen om het detecteren van rising edge, niet beide.

GPIO.wait_for_edge(<pin>,GPIO.RISING) kun je gebruiken om alleen de rising edge te pakken.
Simpel voorbeeldje hier: http://raspi.tv/2013/how-...raspberry-pi-and-rpi-gpio

[CurlyMo]

Kern is natuurlijk of het dan ook een blocking read is?

[Raven]

u_nix_we_all schreef op maandag 29 februari 2016 @ 13:27:
[...]

GPIO.wait_for_edge(<pin>,GPIO.RISING) kun je gebruiken om alleen de rising edge te pakken.
Simpel voorbeeldje hier: http://raspi.tv/2013/how-...raspberry-pi-and-rpi-gpio

Ah, thanks Daar later maar eens naar kijken. * Raven maakt notitie.

CurlyMo schreef op maandag 29 februari 2016 @ 13:28:
Kern is natuurlijk of het dan ook een blocking read is?

De hele "wait_for_edge" functie lijkt dat te zijn, ongeacht wat er achter staat(?). Althans, dat is wat ik zo gauw kan vinden.

[ Voor 93% gewijzigd door Raven op 29-02-2016 13:29 ]

[CurlyMo]

Vuikie schreef op dinsdag 23 februari 2016 @ 17:22:
Hmm, ik zit een beetje door je code te grasduinen, maar ik snap 1 ding niet helemaal.

Zullen we komende dagen even samen de GPIO van de BananaPi aanpakken? Niet helemaal ontopic in een RPi topic, maar ook wel GPIO genoeg

Documentatie over de A20 vinden we volgens mij hier:
http://www.haoyuelectroni...10%20PIO%20Controller.pdf

Het doel is een zo basis mogelijke aansturing van alle GPIO die de A20 te bieden heeft, dus zonder rekening te houden met het apparaat dat de SoC implementeert.

[Vuikie]

CurlyMo schreef op maandag 29 februari 2016 @ 22:51:
[...]

Zullen we komende dagen even samen de GPIO van de BananaPi aanpakken? Niet helemaal ontopic in een RPi topic, maar ook wel GPIO genoeg

Documentatie over de A20 vinden we volgens mij hier:
http://www.haoyuelectroni...10%20PIO%20Controller.pdf

Het doel is een zo basis mogelijke aansturing van alle GPIO die de A20 te bieden heeft, dus zonder rekening te houden met het apparaat dat de SoC implementeert.

Ik zal kijken of ik daar donderdag tijd voor heb, maar ik zit deze week krap in tijd. Volgende week zit ik 2 weken in Hong Kong voor werk en dat ben ik deze week aan het voorbereiden.

Dat gezegd hebbende, ik heb er ook 1 gekocht op E-bay en die komt:

Geschatte levering : wo. 16 mrt. - ma. 4 apr.

kan ik gelijk kijken of het werkt

Wat de documentatie voor de A20 betreft, ik had de datasheet van GitHub getrokken
https://github.com/allwinner-zh/documents/tree/master/A20

Zo kwam ik erachter dat de A20 16bit registers gebruikt tegenover nieuwere Allwinner SOC's die 32bit registers hebben voor de GPIO.

[ Voor 13% gewijzigd door Vuikie op 01-03-2016 08:50 ]

[CurlyMo]

Eerste paar GPIO van de Allwinner A10 heb ik uitgezocht vanuit de PCDuino 1:

C:

#include <sys/mman.h>
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>

#define PAGE_SIZE       (4*1024)
#define BASE_ADDR   0x01C20000
#define PIO                 0x00000800

struct layout {
    char *name;
    struct {
        unsigned long offset;
        unsigned long bit;
    } configure;
    struct {
        unsigned long offset;
        unsigned long bit;
    } data;
} layout[] = {
    { "PI18_SELECT",    { 0x128,    8       }, { 0x130, 18  } },    // PCDuino GPIO 1
    { "PI3_SELECT",     { 0x120,    12  }, { 0x130, 3       } },    // PCDuino GPIO 6
    { "PI10_SELECT",    { 0x124,    8       }, { 0x130, 10  } }     // PCDuino GPIO 10
};  
    
int main(void) {
    int fd = 0;
    if((fd = open("/dev/mem", O_RDWR | O_SYNC )) < 0) {
        printf("error\n");
        return -1;
    }   
    printf("%d\n", fd);
    const char *b = NULL;
    
    void *gpio = (unsigned char *)mmap(0, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, BASE_ADDR);
    
    struct layout *pin = &layout[0];

    printf("%s\n", pin->name);

    *((unsigned long *)(gpio + PIO + pin->configure.offset)) = *((unsigned long *)(gpio + PIO + pin->configure.offset)) | (1 << pin->configure.bit);
    *((unsigned long *)(gpio + PIO + pin->configure.offset)) = *((unsigned long *)(gpio + PIO + pin->configure.offset)) & ~(1 << (pin->configure.bit+1));
    *((unsigned long *)(gpio + PIO + pin->configure.offset)) = *((unsigned long *)(gpio + PIO + pin->configure.offset)) & ~(1 << (pin->configure.bit+2));

    /* Write */
    while(1) {
        *((unsigned long *)(gpio + PIO + pin->data.offset)) = *((unsigned long *)(gpio + PIO + pin->data.offset)) | (1 << pin->data.bit);
        usleep(100000);
        *((unsigned long *)(gpio + PIO + pin->data.offset)) = *((unsigned long *)(gpio + PIO + pin->data.offset)) & ~(1 << pin->data.bit);
        usleep(100000);
    }
}

[Vuikie]

CurlyMo schreef op woensdag 02 maart 2016 @ 23:59:
Eerste paar GPIO van de Allwinner A10 heb ik uitgezocht vanuit de PCDuino 1:

C:

#include <sys/mman.h>
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>

#define PAGE_SIZE       (4*1024)
#define BASE_ADDR   0x01C20000
#define PIO                 0x00000800

struct layout {
    char *name;
    struct {
        unsigned long offset;
        unsigned long bit;
    } configure;
    struct {
        unsigned long offset;
        unsigned long bit;
    } data;
} layout[] = {
    { "PI18_SELECT",    { 0x128,    8       }, { 0x130, 18  } },    // PCDuino GPIO 1
    { "PI3_SELECT",     { 0x120,    12  }, { 0x130, 3       } },    // PCDuino GPIO 6
    { "PI10_SELECT",    { 0x124,    8       }, { 0x130, 10  } }     // PCDuino GPIO 10
};  
    
int main(void) {
    int fd = 0;
    if((fd = open("/dev/mem", O_RDWR | O_SYNC )) < 0) {
        printf("error\n");
        return -1;
    }   
    printf("%d\n", fd);
    const char *b = NULL;
    
    void *gpio = (unsigned char *)mmap(0, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, BASE_ADDR);
    
    struct layout *pin = &layout[0];

    printf("%s\n", pin->name);

    *((unsigned long *)(gpio + PIO + pin->configure.offset)) = *((unsigned long *)(gpio + PIO + pin->configure.offset)) | (1 << pin->configure.bit);
    *((unsigned long *)(gpio + PIO + pin->configure.offset)) = *((unsigned long *)(gpio + PIO + pin->configure.offset)) & ~(1 << (pin->configure.bit+1));
    *((unsigned long *)(gpio + PIO + pin->configure.offset)) = *((unsigned long *)(gpio + PIO + pin->configure.offset)) & ~(1 << (pin->configure.bit+2));

    /* Write */
    while(1) {
        *((unsigned long *)(gpio + PIO + pin->data.offset)) = *((unsigned long *)(gpio + PIO + pin->data.offset)) | (1 << pin->data.bit);
        usleep(100000);
        *((unsigned long *)(gpio + PIO + pin->data.offset)) = *((unsigned long *)(gpio + PIO + pin->data.offset)) & ~(1 << pin->data.bit);
        usleep(100000);
    }
}

Die kloppen als een bus. Ik heb hier de datasheet van de A10.

Op de github van Allwinner kan denk ik al veel info vanaf worden gehaald

edit Ik heb hier een Olimex A10-OlinuXino-LIME hier voor mij liggen. Ook maar eens mee gaan knoeien

[ Voor 3% gewijzigd door Vuikie op 03-03-2016 14:48 ]

[CurlyMo]

Ik heb alle Digitale GPIO op de PCDuino 1 nu uitgezocht. Wat ik niet helemaal kan vinden is hoe het zit met de Analoge IO. Of dit nu aangestuurd wordt door de A10 of door een aparte ADC.

Ook de mapping:

C:

struct layout {
    char *name;
    struct {
        unsigned long offset;
        unsigned long bit;
    } configure;
    struct {
        unsigned long offset;
        unsigned long bit;
    } data;
} layout[] = {
    { "PB2_SELECT",     { 0x24, 8       }, { 0x34,  2       }   }   // PCDuino GPIO 5
    { "PH5_SELECT",     { 0xFC, 20  }, { 0x10C, 5       }   },  // PCDuino GPIO 9
    { "PH6_SELECT",     { 0xFC, 24  }, { 0x10C, 6       }   },  // PCDuino GPIO 3
    { "PH7_SELECT",     { 0xFC, 28  }, { 0x10C, 7       }   },  // PCDuino GPIO 2
    { "PH8_SELECT",     { 0x100, 0  }, { 0x10C, 8       }   },  // PCDuino GPIO 4
    { "PH9_SELECT",     { 0x100, 4  }, { 0x10C, 9       }   },  // PCDuino GPIO 7
    { "PH10_SELECT",    { 0x100, 8  }, { 0x10C, 10  }   },  // PCDuino GPIO 8
    { "PH11_SELECT",    { 0x100, 12 }, { 0x10C, 11  }   },  // PCDuino GPIO 14
    { "PH12_SELECT",    { 0x100, 16 }, { 0x10C, 12  }   },  // PCDuino GPIO 15
    { "PH13_SELECT",    { 0x100, 20 }, { 0x10C, 13  }   },  // PCDuino GPIO 16
    { "PH14_SELECT",    { 0x100, 24 }, { 0x10C, 14  }   },  // PCDuino GPIO 17
    { "PH15_SELECT",    { 0x100, 28 }, { 0x10C, 15  } },    // PCDuino TX LED
    { "PH16_SELECT",    { 0x104, 0  }, { 0x10C, 16  }   },  // PCDuino RX LED
    { "PI3_SELECT",     { 0x120, 12 }, { 0x130, 3       } },    // PCDuino GPIO 6
    { "PI9_SELECT",     { 0x124, 4  }, { 0x130, 11  } },    // PCDuino GPIO 13
    { "PI10_SELECT",    { 0x124, 8  }, { 0x130, 10  } },    // PCDuino GPIO 10
    { "PI12_SELECT",    { 0x124, 16 }, { 0x130, 12  } },    // PCDuino GPIO 11
    { "PI13_SELECT",    { 0x124, 20 }, { 0x130, 13  }   },  // PCDuino GPIO 12
    { "PI18_SELECT",    { 0x128, 8  }, { 0x130, 18  } },    // PCDuino GPIO 1
};  

[ Voor 80% gewijzigd door CurlyMo op 03-03-2016 23:08 ]