Using Detect and running a very basic program on the Raspberry Pi 3, will result in the whole Raspberry Pi locking up (and needing a forced restart). This only happens on a pin with very many rises/falls, currently I am using this for a RF receiver, so there are quite a lot of rises/falls.

The code I am using is this ...

package main

import (
	"fmt"
	"time"

	rpio "github.com/stianeikeland/go-rpio"
)

// This program is just going to be
// a POC of the sender working.
// This should and WILL be cleaned up
// I do not care, I will not fucking
// write the report without having
// the time to do this properly

// Raspberry Pi 3 GPIO
// https://i.imgur.com/PPFf2ul.png
const rx_pin_nr = 2

var preamble = [8]int{1, 0, 1, 0, 1, 0, 1, 0}
var sfd = [8]int{1, 0, 1, 0, 1, 0, 1, 1}
var rx_pin rpio.Pin

func main() {
	// initialize go-rpio
	err := rpio.Open()

	if err != nil {
		fmt.Println(err)
	}

	// set our pin as a output
	rx_pin = rpio.Pin(rx_pin_nr)
	rx_pin.Input()
	rx_pin.Detect(rpio.RiseEdge)

	for {
		// sendData(test)
		fmt.Println("Running stuff")
		time.Sleep(100 * time.Millisecond)
	}
}

func check_sync() {

}

Not even doing anything with it. I don't know what the solution would be, but I think that we could get the interrupt etc. if we used such a system as epoll (http://man7.org/linux/man-pages/man7/epoll.7.html), I know it is uses for another Go system for GPIO interaction here - https://godoc.org/github.com/kidoman/embd

As requested, a pull request for my changes to support Pi4. Note that this is a bit different than the patch I attached to be bug in that it encapsulates error checking in the readBase() helper function.

Tested on Raspberry Pi Zero W OS Version: RASPBIAN STRETCH LITE (Release Date: 2018-06-27) Kernel Version: Linux raspberrypi 4.14.52+ #1123 Wed Jun 27 17:05:32 BST 2018 armv6l GNU/Linux Go Version: go1.10.3 linux/arm Problems: I connect to pi via ssh, system freeze after initialize GPIO, but the same code works well on Raspberry Pi 3 which has the same OS Version, Kernel Version and Go Version. sample code:

const (
	io1    = uint8(5)
	rst    = uint8(13)
	intIn  = uint(26)
	intOut = uint(21)
)
var outPin rpio.Pin
var inPin rpio.Pin
func startGPIO() {
	err := rpio.Open()
	if err != nil {
		log.Fatal(err)
	}
	log.Info("open rpio successfully")
	io1Pin := rpio.Pin(io1)
	io1Pin.Output()
	io1Pin.Low()

	rstPin := rpio.Pin(rst)
	rstPin.Output()
	rstPin.High()

	outPin = rpio.Pin(intOut)
	outPin.Input()
	outPin.Detect(rpio.FallEdge)

	inPin = rpio.Pin(intIn)
	inPin.Output()
	inPin.High()
}

Looking at SetDutyCycle() the use of mark/space is hard-coded. Is there a reason the default algorithm is being overridden? Would it be possible to add support for explicitly setting which algorithm should be used?

I know this has been mentioned in several other issues but I am putting it here for a specific issue.

I'm running on a RPI 4 Model B. Running output on Pin 18 and setting the pin to High works. Setting the same Pin 18 to PWM and setting it to a 100% duty cycle does not work.

I'm running the program as root.

There has been suggestions made that the PWM functionality was fixed for the RPI 4. This does not appear to be the case.

I'm having a very strange issue here, hopefully someone can shed some light on the subject.

go 1.14, raspberry pi 4 B+

using the blinker.go example:

./blinker works just fine sudo ./blinker makes nothing happen.

Why is this? Normally that would be fine, except that I'm trying to use rpio along with a dht11 library that requires root access to run. I find it perplexing that running rpio with heightened privileges causes it to not work.

I'm running this code (just experimenting for now) and after some time (about 1 minute) device is going to be stuck. (I did the same actions with another languages: python, nodejs, but nothing, everything works stable and great, but when running this go application - I have a stuck and need just manually disconnect device from power supply and enable again).

I have Raspberry Pi 3 Model B. Hardware : BCM2835 Revision : a22082

Kernel: 4.19.58-v7+

Distributor ID: Raspbian Description: Raspbian GNU/Linux 10 (buster) Release: 10 Codename: buster

package main

import (
	"fmt"
	"github.com/stianeikeland/go-rpio"
	"log"
	"time"
)

func main() {
	err := rpio.Open()
	if err != nil {
		log.Fatal(err)
	}

	ch := make(chan struct{})

	pin := rpio.Pin(10)
	pin.Input()
	pin.PullUp()
	pin.Detect(rpio.FallEdge)

	lastTime := time.Now().UnixNano() / 1000000

	go func() {
		for {
			if pin.EdgeDetected() {
				now := time.Now().UnixNano() / 1000000
				diff := now - lastTime
				lastTime = now
				fmt.Println("Heyhey!", diff)
			}
			time.Sleep(time.Millisecond * 10)
		}
	}()
	fmt.Println("init")

	<-ch
}

Hi,

I think it would be very useful if you can add a function which measure the frequency a GPIO pin change status. This will allow to interface with a multitude of sensors. Some examples of implementation in C are here: http://abyz.me.uk/rpi/pigpio/examples.html#C_code Arduino core library has a conceptually similar functio called pulseIn: https://www.arduino.cc/reference/en/language/functions/advanced-io/pulsein/

I tried to use a loop with pin.EdgeDetected() and a microsecond sleep but my RPI freezes all the time.

Thanks

Hi there. I managed to add third pin mode - clock.

It is just clock (using CM_GPnDIV and CM_GPnCTL registers) - no pwm (yet).

Suggestions about better method/function naming are welcomed. I tried to be consistent with current ideology, but not sure if it makes sense.

So this: PinMode(pin, rpio.Clock) <=> pin.Mode(rpio.Clock) <=> pin.Clock() is analogical to: PinMode(pin, rpio.Output) <=> pin.Mode(rpio.Output) <=> pin.Output()

and this: SetFreq(pin, 10000) <=> pin.Freq(10000) <=> ??? is analogical to: WritePin(pin, rpio.High) <=> pin.Write(rpio.High) <=> pin.High()

Also not sure if it might make sense to add more public methods eg. for stopping/resetting clocks.

Please merge this if you like it.

Hi,

Have you considered adding input interrupts? You can get them from the files exposed by sysfs in /sys/class/gpio. I've made a library which does this at https://github.com/brian-armstrong/gpio

sysfs can also expose i2c and spi if you uncomment the modules in /boot/config.txt and then reboot. This might be an easy way for you to add i2c and spi functionality as well.

I tried to build and run the pullup example https://github.com/stianeikeland/go-rpio/blob/master/examples/pullup/pullup.go. But it does not build, see error message:

pi@raspberrypi ~/g/e/pullup> go build
# github.com/stianeikeland/go-rpio/v4/examples/pullup
./pullup.go:26:48: pin.ReadPull undefined (type rpio.Pin has no field or method ReadPull)
./pullup.go:30:50: pin.ReadPull undefined (type rpio.Pin has no field or method ReadPull)
note: module requires Go 1.13~

After I removed the ReadPull() call, I got the following output:

pi@raspberrypi ~/g/e/pullup> ./pullup
PullUp: 0, 0
PullDown: 0, 0

That means PullUp does not work.

Round down cdiv result make real CLK faster than caller expect.

for example:

1. when call SpiSpeed(6000000) // caller want set CLK to 6MHz

cdiv = uint32(250000000 / 6000000) = 41
with setSpiDiv will ignore LSB of cdiv, real cdiv will be 40, which result CLK = 6.25MHz

new implement:
cdiv = uint32((250000000 + 12000000 - 1) / 6000000) = 43
with setSpiDiv will ignore LSB of cdiv, real cdiv will be 42, which result CLK = 5.95MHz

1. when call SpiSpeed(11000000) // caller want set CLK to 11MHz

cdiv = uint32(250000000 / 11000000) = 22
with setSpiDiv will ignore LSB of cdiv, real cdiv will be 22, which result CLK = 11.36MHz

new implement:
cdiv = uint32((250000000 + 22000000 - 1) / 11000000) = 24
with setSpiDiv will ignore LSB of cdiv, real cdiv will be 24, which result CLK = 10.4MHz

1. when call SpiSpeed(500000) // caller want set CLK to 5MHz

cdiv = uint32(250000000 / 5000000) = 50
with setSpiDiv will ignore LSB of cdiv, real cdiv will be 50, which result CLK = 5MHz

new implement:
cdiv = uint32((250000000 + 10000000 - 1) / 5000000) = 51
with setSpiDiv will ignore LSB of cdiv, real cdiv will be 50, which result CLK = 5MHz

1. when call SpiSpeed(1000000) // caller want set CLK to 10MHz

cdiv = uint32(250000000 / 10000000) = 25
with setSpiDiv will ignore LSB of cdiv, real cdiv will be 24, which result CLK = 10.4MHz

new implement:
cdiv = uint32((250000000 + 20000000 - 1) / 10000000) = 26
with setSpiDiv will ignore LSB of cdiv, real cdiv will be 26, which result CLK = 9.6MHz

First of all, I really enjoy this library. However, there were some spelling mistakes in the comments which i corrected. Because I have not changed any real code, this PR should be ready to be merged.

When running go-rpio inside a docker container with only /dev/gpiomem mounted, the library fails (docker run --device /dev/gpiomem). Currently, it only checks whether there is a permission problem with /dev/mem. In this case, however, /dev/mem is not found inside the container leading to a file not found error. In this case, it should also be tried if /dev/gpiomem is available.

I found a small issue with the library. For some reason when rpio is close and EdgeDetect is still enable it will hard lock the rpi. i tested it on both a pi3 and pi4. if i call pin.Detect(rpio.NoEdge) before close nothing locks up and everything is fine. I don't have any logs unfortunately dmsg and the kernel log give no insight.

go version: go1.17 linux/arm64 kernel version (uname-a): Linux XXXX 5.13.0-1013-raspi #15-Ubuntu SMP PREEMPT Fri Jan 7 23:16:57 UTC 2022 aarch64 aarch64 aarch64 GNU/Linux go-rpio version: 4.5.1

I just wrote this function for my printer enclosure, which has 2 DHT22s installed. Works almost every time, sometimes it runs into a timeout, but that's likely due to long wires and the very strict timing requirements of those sensors. Communication protocol from the sensor datasheet, algorithm entirely written by me. Tested on a Raspberry Pi 3 Model B, should work on all variants. Don't forget the resistor (4.7k to 10k) between Data and VCC if your sensor hasn't one built in!