rtu_linux_modules/camera/camera.go

package camera

import (
	"errors"
	"fmt"
	"net"
	"os"
	"os/exec"
	"strings"
	"syscall"
	"time"

	"github.com/vishvananda/netlink"

	"hnyfkj.com.cn/rtu/linux/baseapp"
	"hnyfkj.com.cn/rtu/linux/dh_takephoto"
	"hnyfkj.com.cn/rtu/linux/hk_takephoto"
)

// 相机模块的名称
const MODULE_NAME = "Camera"

// 图像类型
const (
	IMG_TYPE_BMP = 1 // 拍照输出"bmp"图像
	IMG_TYPE_JPG = 2 // 拍照输出"jpg"图像
)

// 图像水印
type SImgMark struct {
	CamModelName    string  // 相机型号名
	CamSerialNum    string  // 相机序列号
	ImgExposureTime float64 // 曝光时间值
	ImgWidth        uint    // 图像的宽度
	ImgHeight       uint    // 图像的高度
}

// 配置连接网口相机的网卡ip
func SetupEth1ForGigeCamera(cidr string) error {
	link, err := netlink.LinkByName("eth1")
	if err != nil {
		return err
	}

	if err = netlink.LinkSetUp(link); err != nil {
		return err
	}

	addr, err := netlink.ParseAddr(cidr)
	if err != nil {
		return err
	}

	if err = netlink.AddrAdd(link, addr); err != nil && err != syscall.EEXIST {
		return err
	}

	return nil
}

func Gpio22PowerControl(on bool) error {
	return PowerOnGigeCamera(on)
}

// 打开或关闭网口相机的电源
func PowerOnGigeCamera(on bool) error {
	_ = os.WriteFile("/sys/class/gpio/unexport", []byte("22"), 0644)
	if err := os.WriteFile("/sys/class/gpio/export", []byte("22"), 0644); err != nil {
		return err
	}
	time.Sleep(50 * time.Millisecond)
	if err := os.WriteFile("/sys/class/gpio/gpio22/direction", []byte("out"), 0644); err != nil {
		return err
	}
	val := "0"
	if on {
		val = "1"
	}
	if err := os.WriteFile("/sys/class/gpio/gpio22/value", []byte(val), 0644); err != nil {
		return err
	}
	return nil
}

// 取网口相机电源的开关状态
func GetGigeCameraPowerCtrl() (bool, error) {
	data, err := os.ReadFile("/sys/class/gpio/gpio22/value")
	if err != nil {
		return false, err
	}

	value := strings.TrimSpace(string(data))

	return value == "1", nil
}

func PingOnce(host string, timeoutSec int) error {
	cmd := exec.Command("ping", "-c", "1", "-W", fmt.Sprint(timeoutSec), host)
	return cmd.Run()
}

func CidrEqualSemantic(a, b string) (bool, error) {
	_, na, err := net.ParseCIDR(a)
	if err != nil {
		return false, err
	}
	_, nb, err := net.ParseCIDR(b)
	if err != nil {
		return false, err
	}

	onesA, bitsA := na.Mask.Size()
	onesB, bitsB := nb.Mask.Size()

	return na.IP.Equal(nb.IP) && onesA == onesB && bitsA == bitsB, nil
}

func ModuleInit(supportsGige bool, eth1AddrCIDR, gigeAddrCIDR string) bool {
	if !hk_takephoto.ModuleInit() {
		return false
	}

	if !dh_takephoto.ModuleInit() {
		return false
	}

	if !supportsGige {
		return true
	}

	var err error
	var gigeCameraIP net.IP

	if equal, err := CidrEqualSemantic(eth1AddrCIDR, gigeAddrCIDR); !equal {
		baseapp.Logger.Errorf("[%s] 网口相机初始化失败: 设备与主机-网段不匹配: %v!!", MODULE_NAME, err)
		return false
	}

	if err := SetupEth1ForGigeCamera(eth1AddrCIDR); err != nil {
		baseapp.Logger.Errorf("[%s] 网口相机初始化失败: 设置\"eth1\"地址失败: %v!!", MODULE_NAME, err)
		return false
	}

	gigeCameraIP, _, err = net.ParseCIDR(gigeAddrCIDR)
	if err != nil {
		baseapp.Logger.Errorf("[%s] 网口相机初始化失败: 解析网口-相机地址失败: %v!!", MODULE_NAME, err)
		return false
	}

	err = PingOnce(gigeCameraIP.String(), 1)
	if err == nil {
		return true
	}

	PowerOnGigeCamera(false)
	err = PowerOnGigeCamera(true)
	if err != nil {
		baseapp.Logger.Errorf("[%s] 网口相机初始化失败: 通过 GPIO22 上电失败: %v!!", MODULE_NAME, err)
		return false
	}

	for range 15 {
		if baseapp.IsExit1() {
			return false
		}
		err = PingOnce(gigeCameraIP.String(), 1)
		if err == nil {
			break
		}
		time.Sleep(1 * time.Second)
	}

	if err != nil {
		baseapp.Logger.Errorf("[%s] 网口相机初始化失败: 连通性检测(ping)失败: %v!!", MODULE_NAME, err)
		return false
	}

	return true
}

func GetHKCameraCount() int {
	return hk_takephoto.GetHKCameraCount()
}

func GetDHCameraCount() int {
	return dh_takephoto.GetDHCameraCount()
}

func GetSupportedCameraCount() int {
	return GetHKCameraCount() + GetDHCameraCount()
}

// 单次拍照时, 如果相机处于自动曝光模式, 是否等待曝光稳定后再拍照
// 参数: waitAE: 0=不等待, 1=等待(默认)
func SetWaitAEDoneForTakePhoto(waitAE int) int {
	hk_takephoto.SetWaitAEDoneForTakePhoto(waitAE)
	dh_takephoto.SetWaitAEDoneForTakePhoto(waitAE)
	return 0
}

// 单次执行相机拍照, 并保存到文件, 成功返回: 本次拍照图像的水印信息, 失败返回: 错误原因和空的水印信息
// 参数说明:
// "imgType"     - 图像保存类型: 1-".bmp", 2-".jpg"
// "saveImgPath" - 保存的文件名: 根据所选保存图像的类型, 程序会自动校检和处理文件的扩展名(智能)
// "timeout"     - 等待超时时间, 单位：秒: < 0 表示无超时; 无论超时怎么设置, 首次尝试拍照一定会
// 执行, 但时间不确定; 拍照成功、超时(相机持续无数据的时间)或发生错误时会自动结束任务.
func TakePhoto(imgType int, saveImgPath string, timeout int) (SImgMark, error) {
	var errs []error

	if (imgType != IMG_TYPE_BMP && imgType != IMG_TYPE_JPG) || len(saveImgPath) == 0 {
		return SImgMark{}, fmt.Errorf("invalid arguments")
	}

	if GetHKCameraCount() > 0 {
		hkMark, err := hk_takephoto.TakePhoto(imgType, saveImgPath, timeout)
		if err == nil {
			return SImgMark{
				CamModelName:    hkMark.CamModelName,
				CamSerialNum:    hkMark.CamSerialNum,
				ImgExposureTime: hkMark.ImgExposureTime,
				ImgWidth:        hkMark.ImgWidth,
				ImgHeight:       hkMark.ImgHeight,
			}, nil
		}
		errs = append(errs, fmt.Errorf("HK: %w", err))
	}

	if GetDHCameraCount() > 0 {
		dhMark, err := dh_takephoto.TakePhoto(imgType, saveImgPath, timeout)
		if err == nil {
			return SImgMark{
				CamModelName:    dhMark.CamModelName,
				CamSerialNum:    dhMark.CamSerialNum,
				ImgExposureTime: dhMark.ImgExposureTime,
				ImgWidth:        dhMark.ImgWidth,
				ImgHeight:       dhMark.ImgHeight,
			}, nil
		}
		errs = append(errs, fmt.Errorf("DH: %w", err))
	}

	if len(errs) == 0 {
		return SImgMark{}, fmt.Errorf("no camera available")
	} else {
		return SImgMark{}, errors.Join(errs...)
	}
}