Init Commit

.idea/GoGPIO_AM335x.iml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="Go" enabled="true">
+    <buildTags>
+      <option name="os" value="linux" />
+      <option name="arch" value="arm" />
+    </buildTags>
+  </component>
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/GoGPIO_AM335x.iml" filepath="$PROJECT_DIR$/.idea/GoGPIO_AM335x.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

Example/BeepTest/BeepTest.go

@@ -0,0 +1,36 @@
+package main
+
+import (
+	"git.swzry.com/zry/GoGPIO_AM335x/GoGPIO_AM335x"
+	"fmt"
+	"time"
+)
+
+func main()  {
+	gdev,err := GoGPIO_AM335x.NewGPIO_Device(GoGPIO_AM335x.GPIO_DefaultDeviceFile)
+	if err != nil{
+		fmt.Println("Failed Open GPIO: ",err.Error())
+		return
+	}
+	beeper := GoGPIO_AM335x.NewGPIO_Pin(1,18,GoGPIO_AM335x.GPIO_PINMODE_OUTPUT,false)
+	fmt.Println("Beeper Init...")
+	err = gdev.InitPin(beeper)
+	if err != nil{
+		fmt.Println("Beeper Init Failed: ",err.Error())
+		return
+	}
+	fmt.Println("Beep...")
+	err = gdev.SetPin(beeper,true)
+	if err != nil{
+		fmt.Println("Beeper Set Failed: ",err.Error())
+		return
+	}
+	time.Sleep(time.Millisecond * 200)
+	fmt.Println("Stop...")
+	err = gdev.SetPin(beeper,false)
+	if err != nil{
+		fmt.Println("Beeper Set Failed: ",err.Error())
+		return
+	}
+	fmt.Println("OK.")
+}

Example/ReadKey/BeepTest.go

@@ -0,0 +1,41 @@
+package main
+
+//TODO: Still Have Bugs Here.
+
+import (
+	"git.swzry.com/zry/GoGPIO_AM335x/GoGPIO_AM335x"
+	"fmt"
+	"time"
+)
+
+func main()  {
+	gdev,err := GoGPIO_AM335x.NewGPIO_Device(GoGPIO_AM335x.GPIO_DefaultDeviceFile)
+	if err != nil{
+		fmt.Println("Failed Open GPIO: ",err.Error())
+		return
+	}
+	key := GoGPIO_AM335x.NewGPIO_Pin(0,6,GoGPIO_AM335x.GPIO_PINMODE_INPUT,false)
+	fmt.Println("Key Init...")
+	err = gdev.InitPin(key)
+	if err != nil{
+		fmt.Println("Key Init Failed: ",err.Error())
+		return
+	}
+	for{
+		v,err :=gdev.GetPin(key)
+		if err != nil{
+			fmt.Println("Key Read Failed: ",err.Error())
+			return
+		}
+		fmt.Println("Key Status: ", Bool2KeyStatus(v))
+		time.Sleep(time.Second)
+	}
+}
+
+func Bool2KeyStatus(b bool) string {
+	if(b){
+		return "Pressed"
+	}else {
+		return "Idle"
+	}
+}

GoGPIO_AM335x/GPIO.go

@@ -0,0 +1,140 @@
+package GoGPIO_AM335x
+
+import (
+	"unsafe"
+	"errors"
+)
+
+type GPIO_PIN_MODE int
+
+const(
+	GPIO_DefaultDeviceFile  = "/dev/am335x_gpio"
+	i_GPIO_IOC_MAGIC = 'G'
+	i_SizeOfInt      = 4
+	GPIO_PINMODE_INPUT GPIO_PIN_MODE = 0
+	GPIO_PINMODE_OUTPUT GPIO_PIN_MODE = 1
+)
+
+type GPIO_Struct struct {
+	Pin int
+	Value int
+}
+
+type GPIO_Pin struct {
+	GPIO_OpStr GPIO_Struct
+	Mode GPIO_PIN_MODE
+}
+
+type GPIO_Device struct {
+	fd int
+}
+
+func NewGPIO_Device(devpath string) (*GPIO_Device,error) {
+	gdev := GPIO_Device{}
+	fd,err := sysopen(devpath)
+	if err != nil{
+		return nil,err
+	}
+	gdev.fd = fd
+	return &gdev,nil
+}
+
+func (this *GPIO_Device)Close() error {
+	return sysclose(this.fd)
+}
+
+func (this *GPIO_Device)InitPin(Pin *GPIO_Pin) error {
+	switch Pin.Mode {
+	case GPIO_PINMODE_INPUT:
+		err := ioctl(uintptr(this.fd),uintptr(ifn_IOCTL_GPIO_SETINPUT()),uintptr(unsafe.Pointer(&Pin.GPIO_OpStr)))
+		if err != nil{
+			return err
+		}
+		return nil
+		break
+	case GPIO_PINMODE_OUTPUT:
+		err := ioctl(uintptr(this.fd),uintptr(ifn_IOCTL_GPIO_SETOUTPUT()),uintptr(unsafe.Pointer(&Pin.GPIO_OpStr)))
+		if err != nil{
+			return err
+		}
+		return nil
+		break
+	default:
+		return errors.New("Unknown Pin Mode.")
+	}
+	return errors.New("Unknown Error.")
+}
+
+func (this *GPIO_Device)GetPin(Pin *GPIO_Pin) (bool,error) {
+	err := this.ReadPin(Pin)
+	if err != nil{
+		return false,err
+	}
+	if(Pin.GPIO_OpStr.Value == 0){
+		return false,nil
+	}else {
+		return true,nil
+	}
+}
+
+func (this *GPIO_Device)SetPin(Pin *GPIO_Pin, Val bool) error {
+	Pin.GPIO_OpStr.Value = iuf_Bool2Int(Val)
+	return this.WritePin(Pin)
+}
+
+func (this *GPIO_Device)ReadPin(Pin *GPIO_Pin) error {
+	err := ioctl(uintptr(this.fd),uintptr(ifn_IOCTL_GPIO_GETVALUE()),uintptr(unsafe.Pointer(&Pin.GPIO_OpStr)))
+	if err != nil{
+		return err
+	}
+	return nil
+
+	//TODO: Still Have Bugs Here.
+}
+
+func (this *GPIO_Device)WritePin(Pin *GPIO_Pin) error {
+	err := ioctl(uintptr(this.fd),uintptr(ifn_IOCTL_GPIO_SETVALUE()),uintptr(unsafe.Pointer(&Pin.GPIO_OpStr)))
+	if err != nil{
+		return err
+	}
+	return nil
+}
+
+func NewGPIO_Pin(BankNum int,PinNum int, PinMode GPIO_PIN_MODE, DefaultLevel bool) *GPIO_Pin {
+	gpin := GPIO_Pin{
+		GPIO_OpStr:GPIO_Struct{
+			Pin:ifn_GPIO_TO_PIN(BankNum,PinNum),
+			Value:iuf_Bool2Int(DefaultLevel),
+		},
+		Mode:PinMode,
+	}
+	return &gpin
+}
+
+func ifn_GPIO_TO_PIN(BankNum int,PinNum int) int{
+	return 32 * (BankNum) + (PinNum)
+}
+
+func ifn_IOCTL_GPIO_SETOUTPUT() uint32 {
+	return ifn_IOW(i_GPIO_IOC_MAGIC, 0,i_SizeOfInt )
+}
+
+func ifn_IOCTL_GPIO_SETINPUT() uint32 {
+	return ifn_IOW(i_GPIO_IOC_MAGIC, 1,i_SizeOfInt )
+}
+
+func ifn_IOCTL_GPIO_SETVALUE() uint32 {
+	return ifn_IOW(i_GPIO_IOC_MAGIC, 2,i_SizeOfInt )
+}
+
+func ifn_IOCTL_GPIO_GETVALUE() uint32 {
+	return ifn_IOW(i_GPIO_IOC_MAGIC, 3,i_SizeOfInt )
+}
+
+func iuf_Bool2Int(B bool) int {
+	if(B){
+		return 1
+	}else {
+		return 0
+	}
+}

GoGPIO_AM335x/ioctl.go

@@ -0,0 +1,80 @@
+package GoGPIO_AM335x
+
+import (
+	"syscall"
+)
+
+const (
+	i_IOC_NRBITS = 8
+	i_IOC_TYPEBITS = 8
+	i_IOC_SIZEBITS = 14
+	i_IOC_DIRBITS = 2
+	i_IOC_NRMASK = ((1 << i_IOC_NRBITS)-1)
+	i_IOC_TYPEMASK = ((1 << i_IOC_TYPEBITS)-1)
+	i_IOC_SIZEMASK = ((1 << i_IOC_SIZEBITS)-1)
+	i_IOC_DIRMASK = ((1 << i_IOC_DIRBITS)-1)
+	i_IOC_NRSHIFT = 0
+	i_IOC_TYPESHIFT = (i_IOC_NRSHIFT+i_IOC_NRBITS)
+	i_IOC_SIZESHIFT = (i_IOC_TYPESHIFT+i_IOC_TYPEBITS)
+	i_IOC_DIRSHIFT = (i_IOC_SIZESHIFT+i_IOC_SIZEBITS)
+	i_IOC_NONE = 0
+	i_IOC_WRITE = 1
+	i_IOC_READ = 2
+	i_IOC_IN = (i_IOC_WRITE << i_IOC_DIRSHIFT)
+	i_IOC_OUT = (i_IOC_READ << i_IOC_DIRSHIFT)
+	i_IOC_INOUT = ((i_IOC_WRITE | i_IOC_READ) << i_IOC_DIRSHIFT)
+	i_IOCSIZE_MASK = (i_IOC_SIZEMASK << i_IOC_SIZESHIFT)
+	i_IOCSIZE_SHIFT = i_IOC_SIZESHIFT
+)
+
+func ifn_IOC(Dir uint32, Type uint32, Nr uint32, Size uint32) uint32 {
+	return (((Dir)  << i_IOC_DIRSHIFT) | ((Type) << i_IOC_TYPESHIFT) | ((Nr)   << i_IOC_NRSHIFT) | ((Size) << i_IOC_SIZESHIFT))
+}
+
+func ifn_IO(Type uint32, Nr uint32) uint32 {
+	return ifn_IOC(i_IOC_NONE,(Type),(Nr),0)
+}
+
+func ifn_IOR(Type uint32, Nr uint32, Size uint32) uint32 {
+	return ifn_IOC(i_IOC_READ,(Type),(Nr),Size)
+}
+
+func ifn_IOW(Type uint32,Nr uint32,Size uint32) uint32 {
+	return ifn_IOC(i_IOC_WRITE,(Type),(Nr),Size)
+}
+
+func ifn_IOWR(Type uint32,Nr uint32,Size uint32) uint32 {
+	return ifn_IOC(i_IOC_READ | i_IOC_WRITE,(Type),(Nr),Size)
+}
+
+func ifn_IOR_BAD(Type uint32, Nr uint32, Size uint32) uint32 {
+	return ifn_IOC(i_IOC_READ,(Type),(Nr),Size)
+}
+
+func ifn_IOW_BAD(Type uint32,Nr uint32,Size uint32) uint32 {
+	return ifn_IOC(i_IOC_WRITE,(Type),(Nr),Size)
+}
+
+func ifn_IOWR_BAD(Type uint32,Nr uint32,Size uint32) uint32 {
+	return ifn_IOC(i_IOC_READ | i_IOC_WRITE,(Type),(Nr),Size)
+}
+
+func ioctl(fd, req, arg uintptr) error {
+	_,_,err :=syscall.Syscall(syscall.SYS_IOCTL,fd,req,arg)
+	if err != 0 {
+		return syscall.Errno(err)
+	}
+	return nil
+}
+
+func sysopen(devpath string) (int,error) {
+	if fd, err := syscall.Open(devpath, syscall.O_RDWR, 0777); err != nil {
+		return fd, err
+	} else {
+		return fd, nil
+	}
+}
+
+func sysclose(fd int) error {
+	return syscall.Close(fd)
+}