chenxuuu/Program.cs

## mail.lua
--必须在这个位置定义PROJECT和VERSION变量
--PROJECT：ascii string类型，可以随便定义，只要不使用,就行
--VERSION：ascii string类型，如果使用Luat物联云平台固件升级的功能，必须按照"X.X.X"定义，X表示1位数字；否则可随便定义
PROJECT = "LUATBOARD-AIR202-badapple"
VERSION = "1.0.0"
PRODUCT_KEY = ""
-- 日志级别
require "log"
LOG_LEVEL = log.LOGLEVEL_TRACE
require "sys"
require "patch"
-- 看门狗
require "wdt"
wdt.setup(pio.P0_30, pio.P0_31)
require"uartout"
-- 启动系统框架，不启动协议栈
sys.init(1, 0)
sys.run()

## play.lua
module(...,package.seeall)

require"utils"

local i2cid = 2
local i2cslaveaddr = 0x3c

pmd.ldoset(6, pmd.LDO_VMMC)

if i2c.setup(i2cid,i2c.FAST,i2cslaveaddr) ~= i2c.FAST then
    print("testI2c.init1 fail")
    return
end

local function writeCmd(cmd)
    i2c.write(i2cid,0x00,cmd)
end

local function writeData(cmd)
    i2c.write(i2cid,0x40,cmd)
end

writeCmd(0xAE)
writeCmd(0x00)
writeCmd(0x12)
writeCmd(0x00)
writeCmd(0xB0)
writeCmd(0x81)
writeCmd(0xFF)
writeCmd(0xA1)
writeCmd(0xA6)
writeCmd(0xA8)
writeCmd(0x1F)
writeCmd(0xC8)
writeCmd(0xD3)
writeCmd(0x00)
writeCmd(0xD5)
writeCmd(0x80)
writeCmd(0xD9)
writeCmd(0x1F)
writeCmd(0xDA)
writeCmd(0x12)
writeCmd(0xDB)
writeCmd(0x40)
writeCmd(0x8D)
writeCmd(0x14)
writeCmd(0xAF)

--显示画面
function show(data)
    for i=1,4 do
        writeCmd(0xb0+i-1)
        writeCmd(0x00)
        writeCmd(0x12)
        writeData(data[i])
    end
end


## Program.cs
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace luatBadapplePC
{
    class Program
    {
        private static Uart com;
        public static bool wait = true;
        static void Main(string[] args)
        {
            string path = @"C:\Users\chenx\Desktop\luatBadapplePC\pics\";
            com = new Uart
            {
                com = "COM3",
                uartRevHandle = ComRev
            };
            com.IsShowAsHex = false;
            com.OpenCom();

            long init = DateTime.Now.Ticks;
            Task.Delay(50);
            long i = 1;
            while(i < 6573)
            {
                i = (DateTime.Now.Ticks - init) / 330000;
                if (i > 6573)
                    return;
                Bitmap b = new Bitmap(path + i + ".png");
                Bitmap bmp = new Bitmap(64, 32);
                Graphics pic = Graphics.FromImage(bmp);
                pic.FillRectangle(Brushes.Black, 0, 0, 64, 32);
                pic.DrawImage(b, 11, 0, 42, 32);

                for (int page = 0; page < 32; page += 8)//页数据处理
                {
                    for (int row = 0; row < 64; row++)//每列处理
                    {
                        int r1 = 0, r2 = 0;
                        for (int j = 3; j >= 0; j--)
                        {
                            if (bmp.GetPixel(row, page + j).GetBrightness() > 0.5f)
                                r1 += (int)Math.Pow(2, j);
                        }
                        for (int j = 3; j >= 0; j--)
                        {
                            if (bmp.GetPixel(row, page + 4 + j).GetBrightness() > 0.5f)
                                r2 += (int)Math.Pow(2, j);
                        }
                        string r = (r1 + r2 * 16).ToString("X2");
                        com.SendBytesData(r);
                        Console.Write(r);
                    }
                }
                Console.Write("\r\n");
                wait = true;
                while (wait) { Task.Delay(1); }
                //Task.Delay(10);
            }


            Console.ReadLine();
        }

        /// <summary>
        /// 异步接收方法
        /// </summary>
        /// <param name="rev">接收到的数据</param>
        private static void ComRev(string rev)
        {
            wait = false;
        }
    }
}

## uart.cs
using System;
using System.Collections.Generic;
using System.IO.Ports;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;

namespace luatBadapplePC
{
    public delegate void UartRevDelagate(string text);// 委托
    class Uart
    {
        //by 晨旭
        //chenxublog.com
        //m@owo.email
        public bool isOpen = false;
        private SerialPort serialPort1 = new SerialPort();
        public UartRevDelagate uartRevHandle;
        public string com = "";
        public int BaudRate = 115200;
        public bool IsShowAsHex = true;
        public string errormsg = "串口打开失败！检查串口设备是否已连接！";
        public int delay = 250;
        /// <summary>
        /// 开启串口，并开启委托
        /// </summary>
        /// <returns>true/false开启是否成功</returns>
        public bool OpenCom()
        {
            if(com=="")
            {
                //循环获取最后一个串口设备号
                foreach (string s in System.IO.Ports.SerialPort.GetPortNames())
                {
                    com = s;
                }
                try
                {
                    serialPort1.PortName = com;
                }
                catch
                {
                    //MessageBox.Show("串口连接失败！");
                    isOpen = false;
                    return false;
                }
            }
            else
            {
                serialPort1.PortName = com;
            }
            serialPort1.BaudRate = BaudRate;
            serialPort1.Parity = Parity.None;
            serialPort1.StopBits = StopBits.One;
            serialPort1.DataBits = 8;

            try
            {
                serialPort1.Open();
                isOpen = true;
                ReceiveData(serialPort1);//开启接收数据线程
            }
            catch
            {
                //MessageBox.Show(errormsg);
                isOpen = false;
                return false;
            }
            return true;
        }

        /// <summary>
        /// 关闭串口
        /// </summary>
        /// <returns></returns>
        public bool CloseCom()
        {
            try
            {
                serialPort1.Close();
                isOpen = false;
            }
            catch { }
            return isOpen;
        }

        /// <summary>
        /// 用异步接收数据线程
        /// </summary>
        /// <param name="serialPort"></param>
        private void ReceiveData(SerialPort serialPort)
        {
            //用异步接收数据线程
            Thread threadReceiveSub = new Thread(new ParameterizedThreadStart(AsyReceiveData));
            threadReceiveSub.Start(serialPort);
        }

        /// <summary>
        /// 异步读取
        /// </summary>
        /// <param name="serialPortobj"></param>
        private void AsyReceiveData(object serialPortobj)
        {
            SerialPort serialPort = (SerialPort)serialPortobj;
            System.Threading.Thread.Sleep(1);
            while (isOpen)
            {
                try
                {
                    System.Threading.Thread.Sleep(1);
                    if (serialPort.BytesToRead == 0)
                        continue;
                    //System.Threading.Thread.Sleep(delay);
                    int n = serialPort.BytesToRead;// 先记录下来，避免某种原因，人为的原因，操作几次之间时间长，缓存不一致
                    byte[] buf = new byte[n];// 声明一个临时数组存储当前来的串口数据
                                             //received_count += n;// 增加接收计数
                    serialPort.Read(buf, 0, n);// 读取缓冲数据
                                               // 因为要访问 ui 资源，所以需要使用 invoke 方式同步 ui。
                                               //interfaceUpdateHandle = new UartRevDelagate(UpdateTextBox);// 实例化委托对象
                    if (!IsShowAsHex)
                    {
                        uartRevHandle(Encoding.Default.GetString(buf));
                    }
                    else
                    {
                        uartRevHandle(ByteToString(buf, n));
                    }
                }
                catch
                {
                    //MessageBox.Show(e.Message);
                    try
                    {
                        serialPort1.Close();
                        isOpen = false;
                        OpenCom();
                    }
                    catch { }
                    // 处理错误
                    break;
                }
            }
        }

        /// <summary>
        /// 发送串口数据
        /// </summary>
        public void SendBytesData(string sendData)
        {
            if (!isOpen)
            {
                return;
            }
            byte[] bytesSend = HexStringToByte(sendData);
            serialPort1.Write(bytesSend, 0, bytesSend.Length);
        }

        /// <summary>
        /// 字节数组转 16 进制字符串
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        private string ByteToString(byte[] InBytes, int len)
        {
            string StringOut = "";
            for (int i = 0; i < len; i++)
            {
                StringOut = StringOut + String.Format("{0:X2}", InBytes[i]);
            }
            return StringOut;
        }

        private static bool ShowWarning = true;
        /// <summary>
        /// 把 16 进制字符串转换成字节数组
        /// </summary>
        /// <param name="hex"></param>
        /// <returns></returns>
        public static byte[] HexStringToByte(String hex)
        {
            int len = (hex.Length / 2);
            byte[] result = new byte[len];
            char[] achar = hex.ToCharArray();
            for (int i = 0; i < len; i++)
            {
                int pos = i * 2;
                result[i] = (byte)(ToByte(achar[pos]) << 4 | ToByte(achar[pos + 1]));
            }
            ShowWarning = true;
            return result;
        }

        private static int ToByte(char c)
        {
            byte b = (byte)"0123456789ABCDEF".IndexOf(c);
            if (b == (byte)"0".IndexOf('c') && ShowWarning)
            {
                //MessageBox.Show("16进制仅限1234567890abcdef这些字符！（大小写均可）");
                ShowWarning = false;
            }
            return b;
        }

        public static string PickUp(string input, int count)
        {
            string result = "";
            count--;
            try
            {
                result = input[count * 2].ToString() + input[count * 2 + 1].ToString();
            }
            catch { }
            return result;
        }
    }
}

## uartout.lua

module(...,package.seeall)

require"utils"
require"pm"
require"play"

local UART_ID = 1

local buf = ""
local imgbuf = {}
--[[
函数名：proc
功能  ：处理从串口读到的数据
参数  ：
        data：当前一次从串口读到的数据
返回值：无
]]
local function proc(data)
    buf = buf..data
    if buf:len()==64*4 then
        imgbuf[1] = buf:sub(1,64)
        imgbuf[2] = buf:sub(65,128)
        imgbuf[3] = buf:sub(129,192)
        imgbuf[4] = buf:sub(193,256)
        play.show(imgbuf)
        imgbuf = {}
        buf = ""
        write("/")
    end
    if buf:len()>=64*4 then
        buf = ""
        write("/")
    end
end

--[[
函数名：read
功能  ：读取串口接收到的数据
参数  ：无
返回值：无
]]
local function read()
local data = ""
--底层core中，串口收到数据时：
--如果接收缓冲区为空，则会以中断方式通知Lua脚本收到了新数据；
--如果接收缓冲器不为空，则不会通知Lua脚本
--所以Lua脚本中收到中断读串口数据时，每次都要把接收缓冲区中的数据全部读出，这样才能保证底层core中的新数据中断上来，此read函数中的while语句中就保证了这一点
while true do
    data = uart.read(UART_ID,"*l")
    if not data or string.len(data) == 0 then break end
    proc(data)
end
end


--[[
函数名：write
功能  ：通过串口发送数据
参数  ：
        s：要发送的数据
返回值：无
]]
function write(s)
    log.info("testUartTask.write",s)
    uart.write(UART_ID,s)
end

local function writeOk()
    log.info("testUartTask.writeOk")
end

pm.wake("uart")
uart.on(UART_ID,"receive",read)
uart.on(UART_ID,"sent",writeOk)
--配置并且打开串口
uart.setup(UART_ID,115200,8,uart.PAR_NONE,uart.STOP_1)
	--必须在这个位置定义PROJECT和VERSION变量
	--PROJECT：ascii string类型，可以随便定义，只要不使用,就行
	--VERSION：ascii string类型，如果使用Luat物联云平台固件升级的功能，必须按照"X.X.X"定义，X表示1位数字；否则可随便定义
	PROJECT = "LUATBOARD-AIR202-badapple"
	VERSION = "1.0.0"
	PRODUCT_KEY = ""
	-- 日志级别
	require "log"
	LOG_LEVEL = log.LOGLEVEL_TRACE
	require "sys"
	require "patch"
	-- 看门狗
	require "wdt"
	wdt.setup(pio.P0_30, pio.P0_31)
	require"uartout"
	-- 启动系统框架，不启动协议栈
	sys.init(1, 0)
	sys.run()
	module(...,package.seeall)

	require"utils"

	local i2cid = 2
	local i2cslaveaddr = 0x3c

	pmd.ldoset(6, pmd.LDO_VMMC)

	if i2c.setup(i2cid,i2c.FAST,i2cslaveaddr) ~= i2c.FAST then
	print("testI2c.init1 fail")
	return
	end

	local function writeCmd(cmd)
	i2c.write(i2cid,0x00,cmd)
	end

	local function writeData(cmd)
	i2c.write(i2cid,0x40,cmd)
	end

	writeCmd(0xAE)
	writeCmd(0x00)
	writeCmd(0x12)
	writeCmd(0x00)
	writeCmd(0xB0)
	writeCmd(0x81)
	writeCmd(0xFF)
	writeCmd(0xA1)
	writeCmd(0xA6)
	writeCmd(0xA8)
	writeCmd(0x1F)
	writeCmd(0xC8)
	writeCmd(0xD3)
	writeCmd(0x00)
	writeCmd(0xD5)
	writeCmd(0x80)
	writeCmd(0xD9)
	writeCmd(0x1F)
	writeCmd(0xDA)
	writeCmd(0x12)
	writeCmd(0xDB)
	writeCmd(0x40)
	writeCmd(0x8D)
	writeCmd(0x14)
	writeCmd(0xAF)

	--显示画面
	function show(data)
	for i=1,4 do
	writeCmd(0xb0+i-1)
	writeCmd(0x00)
	writeCmd(0x12)
	writeData(data[i])
	end
	end
	using System;
	using System.Collections.Generic;
	using System.Drawing;
	using System.Linq;
	using System.Text;
	using System.Threading.Tasks;

	namespace luatBadapplePC
	{
	class Program
	{
	private static Uart com;
	public static bool wait = true;
	static void Main(string[] args)
	{
	string path = @"C:\Users\chenx\Desktop\luatBadapplePC\pics\";
	com = new Uart
	{
	com = "COM3",
	uartRevHandle = ComRev
	};
	com.IsShowAsHex = false;
	com.OpenCom();

	long init = DateTime.Now.Ticks;
	Task.Delay(50);
	long i = 1;
	while(i < 6573)
	{
	i = (DateTime.Now.Ticks - init) / 330000;
	if (i > 6573)
	return;
	Bitmap b = new Bitmap(path + i + ".png");
	Bitmap bmp = new Bitmap(64, 32);
	Graphics pic = Graphics.FromImage(bmp);
	pic.FillRectangle(Brushes.Black, 0, 0, 64, 32);
	pic.DrawImage(b, 11, 0, 42, 32);

	for (int page = 0; page < 32; page += 8)//页数据处理
	{
	for (int row = 0; row < 64; row++)//每列处理
	{
	int r1 = 0, r2 = 0;
	for (int j = 3; j >= 0; j--)
	{
	if (bmp.GetPixel(row, page + j).GetBrightness() > 0.5f)
	r1 += (int)Math.Pow(2, j);
	}
	for (int j = 3; j >= 0; j--)
	{
	if (bmp.GetPixel(row, page + 4 + j).GetBrightness() > 0.5f)
	r2 += (int)Math.Pow(2, j);
	}
	string r = (r1 + r2 * 16).ToString("X2");
	com.SendBytesData(r);
	Console.Write(r);
	}
	}
	Console.Write("\r\n");
	wait = true;
	while (wait) { Task.Delay(1); }
	//Task.Delay(10);
	}


	Console.ReadLine();
	}

	/// <summary>
	/// 异步接收方法
	/// </summary>
	/// <param name="rev">接收到的数据</param>
	private static void ComRev(string rev)
	{
	wait = false;
	}
	}
	}
	using System;
	using System.Collections.Generic;
	using System.IO.Ports;
	using System.Linq;
	using System.Text;
	using System.Threading;
	using System.Threading.Tasks;
	using System.Windows;

	namespace luatBadapplePC
	{
	public delegate void UartRevDelagate(string text);// 委托
	class Uart
	{
	//by 晨旭
	//chenxublog.com
	//m@owo.email
	public bool isOpen = false;
	private SerialPort serialPort1 = new SerialPort();
	public UartRevDelagate uartRevHandle;
	public string com = "";
	public int BaudRate = 115200;
	public bool IsShowAsHex = true;
	public string errormsg = "串口打开失败！检查串口设备是否已连接！";
	public int delay = 250;
	/// <summary>
	/// 开启串口，并开启委托
	/// </summary>
	/// <returns>true/false开启是否成功</returns>
	public bool OpenCom()
	{
	if(com=="")
	{
	//循环获取最后一个串口设备号
	foreach (string s in System.IO.Ports.SerialPort.GetPortNames())
	{
	com = s;
	}
	try
	{
	serialPort1.PortName = com;
	}
	catch
	{
	//MessageBox.Show("串口连接失败！");
	isOpen = false;
	return false;
	}
	}
	else
	{
	serialPort1.PortName = com;
	}
	serialPort1.BaudRate = BaudRate;
	serialPort1.Parity = Parity.None;
	serialPort1.StopBits = StopBits.One;
	serialPort1.DataBits = 8;

	try
	{
	serialPort1.Open();
	isOpen = true;
	ReceiveData(serialPort1);//开启接收数据线程
	}
	catch
	{
	//MessageBox.Show(errormsg);
	isOpen = false;
	return false;
	}
	return true;
	}

	/// <summary>
	/// 关闭串口
	/// </summary>
	/// <returns></returns>
	public bool CloseCom()
	{
	try
	{
	serialPort1.Close();
	isOpen = false;
	}
	catch { }
	return isOpen;
	}

	/// <summary>
	/// 用异步接收数据线程
	/// </summary>
	/// <param name="serialPort"></param>
	private void ReceiveData(SerialPort serialPort)
	{
	//用异步接收数据线程
	Thread threadReceiveSub = new Thread(new ParameterizedThreadStart(AsyReceiveData));
	threadReceiveSub.Start(serialPort);
	}

	/// <summary>
	/// 异步读取
	/// </summary>
	/// <param name="serialPortobj"></param>
	private void AsyReceiveData(object serialPortobj)
	{
	SerialPort serialPort = (SerialPort)serialPortobj;
	System.Threading.Thread.Sleep(1);
	while (isOpen)
	{
	try
	{
	System.Threading.Thread.Sleep(1);
	if (serialPort.BytesToRead == 0)
	continue;
	//System.Threading.Thread.Sleep(delay);
	int n = serialPort.BytesToRead;// 先记录下来，避免某种原因，人为的原因，操作几次之间时间长，缓存不一致
	byte[] buf = new byte[n];// 声明一个临时数组存储当前来的串口数据
	//received_count += n;// 增加接收计数
	serialPort.Read(buf, 0, n);// 读取缓冲数据
	// 因为要访问 ui 资源，所以需要使用 invoke 方式同步 ui。
	//interfaceUpdateHandle = new UartRevDelagate(UpdateTextBox);// 实例化委托对象
	if (!IsShowAsHex)
	{
	uartRevHandle(Encoding.Default.GetString(buf));
	}
	else
	{
	uartRevHandle(ByteToString(buf, n));
	}
	}
	catch
	{
	//MessageBox.Show(e.Message);
	try
	{
	serialPort1.Close();
	isOpen = false;
	OpenCom();
	}
	catch { }
	// 处理错误
	break;
	}
	}
	}

	/// <summary>
	/// 发送串口数据
	/// </summary>
	public void SendBytesData(string sendData)
	{
	if (!isOpen)
	{
	return;
	}
	byte[] bytesSend = HexStringToByte(sendData);
	serialPort1.Write(bytesSend, 0, bytesSend.Length);
	}

	/// <summary>
	/// 字节数组转 16 进制字符串
	/// </summary>
	/// <param name="bytes"></param>
	/// <returns></returns>
	private string ByteToString(byte[] InBytes, int len)
	{
	string StringOut = "";
	for (int i = 0; i < len; i++)
	{
	StringOut = StringOut + String.Format("{0:X2}", InBytes[i]);
	}
	return StringOut;
	}

	private static bool ShowWarning = true;
	/// <summary>
	/// 把 16 进制字符串转换成字节数组
	/// </summary>
	/// <param name="hex"></param>
	/// <returns></returns>
	public static byte[] HexStringToByte(String hex)
	{
	int len = (hex.Length / 2);
	byte[] result = new byte[len];
	char[] achar = hex.ToCharArray();
	for (int i = 0; i < len; i++)
	{
	int pos = i * 2;
	result[i] = (byte)(ToByte(achar[pos]) << 4 \| ToByte(achar[pos + 1]));
	}
	ShowWarning = true;
	return result;
	}

	private static int ToByte(char c)
	{
	byte b = (byte)"0123456789ABCDEF".IndexOf(c);
	if (b == (byte)"0".IndexOf('c') && ShowWarning)
	{
	//MessageBox.Show("16进制仅限1234567890abcdef这些字符！（大小写均可）");
	ShowWarning = false;
	}
	return b;
	}

	public static string PickUp(string input, int count)
	{
	string result = "";
	count--;
	try
	{
	result = input[count * 2].ToString() + input[count * 2 + 1].ToString();
	}
	catch { }
	return result;
	}
	}
	}

	module(...,package.seeall)

	require"utils"
	require"pm"
	require"play"

	local UART_ID = 1

	local buf = ""
	local imgbuf = {}
	--[[
	函数名：proc
	功能：处理从串口读到的数据
	参数：
	data：当前一次从串口读到的数据
	返回值：无
	]]
	local function proc(data)
	buf = buf..data
	if buf:len()==64*4 then
	imgbuf[1] = buf:sub(1,64)
	imgbuf[2] = buf:sub(65,128)
	imgbuf[3] = buf:sub(129,192)
	imgbuf[4] = buf:sub(193,256)
	play.show(imgbuf)
	imgbuf = {}
	buf = ""
	write("/")
	end
	if buf:len()>=64*4 then
	buf = ""
	write("/")
	end
	end

	--[[
	函数名：read
	功能：读取串口接收到的数据
	参数：无
	返回值：无
	]]
	local function read()
	local data = ""
	--底层core中，串口收到数据时：
	--如果接收缓冲区为空，则会以中断方式通知Lua脚本收到了新数据；
	--如果接收缓冲器不为空，则不会通知Lua脚本
	--所以Lua脚本中收到中断读串口数据时，每次都要把接收缓冲区中的数据全部读出，这样才能保证底层core中的新数据中断上来，此read函数中的while语句中就保证了这一点
	while true do
	data = uart.read(UART_ID,"*l")
	if not data or string.len(data) == 0 then break end
	proc(data)
	end
	end


	--[[
	函数名：write
	功能：通过串口发送数据
	参数：
	s：要发送的数据
	返回值：无
	]]
	function write(s)
	log.info("testUartTask.write",s)
	uart.write(UART_ID,s)
	end

	local function writeOk()
	log.info("testUartTask.writeOk")
	end

	pm.wake("uart")
	uart.on(UART_ID,"receive",read)
	uart.on(UART_ID,"sent",writeOk)
	--配置并且打开串口
	uart.setup(UART_ID,115200,8,uart.PAR_NONE,uart.STOP_1)