GoGPIO_AM335x/GoGPIO_AM335x/GPIO.go

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
	}
}