/*
 * Copyright (c) 2006-2021, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2024-05-06     lijian       the first version
 */
#include <inout.h>

IO_t IO;

//输入端口列表
rt_base_t input_pins[] = { GET_PIN(C, 2),
                            GET_PIN(C, 3),
                            GET_PIN(A, 5),
                            GET_PIN(A, 6),
                            GET_PIN(A, 7),
                            GET_PIN(C, 4),
                            GET_PIN(A, 8),
                            GET_PIN(C, 9),

};

//输出端口列表
rt_base_t output_pins[] = {

//    GET_PIN(B, 12), //4
//    GET_PIN(B, 13), //5
//    GET_PIN(B, 14), //6
//    GET_PIN(B, 15), //7
//    GET_PIN(C, 6),  //8
//    GET_PIN(C, 7),  //3
//    GET_PIN(C, 8),   //2
//    GET_PIN(A, 11), //1

        GET_PIN(A, 11), //1
        GET_PIN(C, 8),   //2
        GET_PIN(C, 7),  //3
        GET_PIN(B, 12), //4
        GET_PIN(B, 13), //5
        GET_PIN(B, 14), //6
        GET_PIN(B, 15), //7
        GET_PIN(C, 6),  //8
        };

/**
 * 端口中断回调函数
 * @param args
 */
void gpio_irq_callback(void *args)
{
    rt_base_t pin = (rt_base_t) (uintptr_t) args; // 获取触发中断的引脚号
   // rt_kprintf("pin: %#x", pin , IO.IO_Data[0].Temp_Count);
    switch (pin)
    {
    case IN0:
        IO.IO_Data[0].Temp_Count++;
        if (IO.IO_Flag.log) {
            rt_kprintf("Pin0:%d\n", IO.IO_Data[0].Temp_Count);
        }

        break;
    case IN1:
        IO.IO_Data[1].Temp_Count++;
        if (IO.IO_Flag.log) {
            rt_kprintf("Pin1:%d\n", IO.IO_Data[1].Temp_Count);
        }

        break;
    case IN2:
        IO.IO_Data[2].Temp_Count++;
        if (IO.IO_Flag.log) {
            rt_kprintf("Pin2:%d\n", IO.IO_Data[2].Temp_Count);
        }

        break;
    case IN3:
        IO.IO_Data[3].Temp_Count++;
        if (IO.IO_Flag.log) {
            rt_kprintf("Pin3:%d\n", IO.IO_Data[3].Temp_Count);
        }

        break;
    case IN4:
        IO.IO_Data[4].Temp_Count++;
        if (IO.IO_Flag.log) {
            rt_kprintf("Pin4:%d\n", IO.IO_Data[4].Temp_Count);
        }

        break;
    case IN5:
        IO.IO_Data[5].Temp_Count++;
        if (IO.IO_Flag.log) {
            rt_kprintf("Pin5:%d\n", IO.IO_Data[5].Temp_Count);
        }

        break;
    case IN6:
        IO.IO_Data[6].Temp_Count++;
        if (IO.IO_Flag.log) {
            rt_kprintf("Pin6:%d\n", IO.IO_Data[6].Temp_Count);
        }

        break;
    case IN7:
        IO.IO_Data[7].Temp_Count++;
        if (IO.IO_Flag.log) {
            rt_kprintf("Pin7:%d\n", IO.IO_Data[7].Temp_Count);
        }

        break;
    default:
        break;
    }
}

//配置输入引脚
void configure_inpin(rt_base_t pin)
{
    // 设置引脚模式为上拉输入
    rt_pin_mode(pin, PIN_MODE_INPUT_PULLUP);

    rt_kprintf(" pin: %d  %#x\r\n", pin, pin);
    /* 绑定中断，下降沿模式，回调函数名为 */
    rt_pin_attach_irq(pin, PIN_IRQ_MODE_FALLING, gpio_irq_callback, (void *) (uintptr_t) pin);
    /* 使能中断 */
    rt_pin_irq_enable(pin, PIN_IRQ_ENABLE);
}

/**
 * 输入引脚初始化
 */
void gpio_input_init(void)
{
    rt_kprintf(" IN pin list:\r\n");

    for (rt_uint8_t var = 0; var < INPUT_NUM; var++)
    {
        configure_inpin(input_pins[var]);
    }
}

/**
 * 输出引脚默认为高电平
 * @param pin
 */
void configure_outpin(rt_base_t pin)
{
    // 设置引脚模式为输出模式
    rt_pin_mode(pin, PIN_MODE_OUTPUT);
    // 默认为高电平
    rt_pin_write(pin, PIN_HIGH);
}

//输出引脚初始化
void gpio_output_init(void)
{

    for (rt_uint8_t var = 0; var < OUTPUT_NUM; var++)
    {
        configure_outpin(output_pins[var]);
    }
}

//获取端口电平触发次数
rt_uint32_t get_IO_count(rt_uint8_t io)
{
    return IO.IO_Data[io].Temp_Count;
}

//获取端口电平值
rt_uint8_t get_IO_Value()
{
    return IO.IO_Flag.Value;
}

rt_uint8_t get_IO_NeedleCountUpdateFlag()
{
    return IO.IO_Flag.NeedleCountUpdateFlag;
//    return IO.IO_Data[IO.IO_Flag.Needle_io].Temp_Count;
}

void set_IO_NeedleCountUpdateFlag(rt_uint8_t flag)
{
    IO.IO_Flag.NeedleCountUpdateFlag = flag;
}


void set_IO_Needle_io(rt_uint8_t io)
{
    IO.IO_Flag.Needle_io = io;
}

rt_uint32_t get_IO_NeedleCount_sum()
{
    return IO.IO_Data[IO.IO_Flag.Needle_io].Temp_Count;
//    return IO.IO_Data[IO.IO_Flag.Needle_io].NeedleCount_Sum;
}

void set_IO_NeedleCount_sum(rt_uint8_t count)
{
    IO.IO_Data[IO.IO_Flag.Needle_io].NeedleCount_Sum = count;
}

/**
 * @brief 确认端口电平.当端口从高电平变为低电平代表次数+1
 * @param none
 * @return: None
 */
void updateKeyValue(void)
{

    //#define IN0 0x22 //1
    //#define IN1 0x23  //2 锁1状态
    //#define IN2 0x5  //3 锁2状态
    //#define IN3 0x6  //4 锁3状态
    //#define IN4 0x7  //5 右盖板检测
    //#define IN5 0x24 //6 左盖板检测
    //#define IN6 0x8  //7 启停
    //#define IN7 0x29  //8 主轴

    IO.IO_Flag.Value |= rt_pin_read(IN0) << 0;
    IO.IO_Flag.Value |= rt_pin_read(IN1) << 1;
    IO.IO_Flag.Value |= rt_pin_read(IN2) << 2;
    IO.IO_Flag.Value |= rt_pin_read(IN3) << 3;
    IO.IO_Flag.Value |= rt_pin_read(IN4) << 4;
    IO.IO_Flag.Value |= rt_pin_read(IN5) << 5;
    IO.IO_Flag.Value |= rt_pin_read(IN6) << 6;
    IO.IO_Flag.Value |= rt_pin_read(IN7) << 7;
    IO.IO_Flag.Value = ~IO.IO_Flag.Value;

//    rt_uint8_t i = 0;
//
//    for (i = 0; i < INPUT_NUM; i++)
//    {
//        //跳过转速和针数口
//        if (i == IO.IO_Flag.Speed_io || i==IO.IO_Flag.Needle_io)
//        {
//            continue;
//        }
//
//
//        if (rt_pin_read(input_pins[i]) == 0)
//        {
//            rt_thread_mdelay(10);
//            if (rt_pin_read(input_pins[i]) == 0)
//            {
//                IO.IO_Data[i].Key = 1;
//                IO.IO_Data[i].Key_Flag = 1;
//            }
//        }
//        else
//        {
//            //rt_kprintf("\n");
//           // rt_kprintf("key 0 \n");
//            IO.IO_Data[i].Key = 0;
//        }
//    }
//
//
//    for (i = 0; i < INPUT_NUM; i++)
//    {
//        if (IO.IO_Data[i].Key_Flag == 1)
//        {
//            if (IO.IO_Data[i].Key == 0)
//            {
//                IO.IO_Data[i].Count += 1;
//                IO.IO_Data[i].Key_Flag = 0;
//
//                rt_kprintf("\n", IO.IO_Data[i].Count);
//                if (IO.IO_Flag.log) {
//                    rt_kprintf("Count: %d , temp count %d\n", IO.IO_Data[i].Count, IO.IO_Data[i].Temp_Count);
//                }
//            }
//        }
//    }
}


/**
 * @brief 计算转速，500毫秒的中断次数乘2为1秒次数，1秒次数乘60为rpm单位转速
 * @param none
 * @return: None
 */
void updateSpeed(void)
{
    rt_uint16_t tmp_start = 0;
    rt_uint16_t tmp_end = 0;
    //rt_tick_t   tick_start      =  0;
    //rt_tick_t   tick_end        =  0;
    rt_uint16_t temp = 0;

    temp = IO.IO_Data[IO.IO_Flag.Speed_io].Speed;
    tmp_start = IO.IO_Data[IO.IO_Flag.Speed_io].Temp_Count;

    //tick_start = rt_tick_get_millisecond();
    rt_thread_mdelay(500);
    //tick_end = rt_tick_get_millisecond();

    tmp_end = IO.IO_Data[IO.IO_Flag.Speed_io].Temp_Count;

    if (tmp_end < tmp_start)
    {
        IO.IO_Data[IO.IO_Flag.Speed_io].Speed = (tmp_end + 65535 - tmp_start) * 120;
    }
    else
    {
        IO.IO_Data[IO.IO_Flag.Speed_io].Speed = (tmp_end - tmp_start) * 120;
    }

    if (IO.IO_Flag.log)
    {
        rt_kprintf("Speed: %d %d\n", IO.IO_Flag.Speed_io + 1, IO.IO_Data[IO.IO_Flag.Speed_io].Speed);
    }

    //            if(tmp_end < tmp_start){
    //                IO.IO_Data[i].Temp_Speed = (tmp_end + 65535 - tmp_start) / ((tick_end - tick_start) / 1000);
    //            }
    //            else {
    //                IO.IO_Data[i].Temp_Speed = (tmp_end - tmp_start) / ((tick_end - tick_start) / 1000);
    //            }

    if (temp != IO.IO_Data[IO.IO_Flag.Speed_io].Speed)
    {
        IO.IO_Flag.SpeedUpdateFlag = 1;
    }
    else
    {
        IO.IO_Flag.SpeedUpdateFlag = 0;
    }

}


/**
 * @brief 计算针数，500毫秒的中断次数，NeedleCount为临时针数，会清零，NeedleCount_Sum为针数总和
 * @param none
 * @return: None
 */
void updateNeedleCount(void)
{
//

    if (IO.IO_Data[IO.IO_Flag.Needle_io].Count!=IO.IO_Data[IO.IO_Flag.Needle_io].Temp_Count) {
        IO.IO_Data[IO.IO_Flag.Needle_io].Count = IO.IO_Data[IO.IO_Flag.Needle_io].Temp_Count;
        IO.IO_Flag.NeedleCountUpdateFlag = 1;
    }

    return;
    //DATU需求


//    rt_thread_mdelay(500);
//    rt_uint32_t tempCount = 0;
//    if ((IO.IO_Data[IO.IO_Flag.Needle_io].Temp_Count - tempCount))
//    {
//        IO.IO_Data[IO.IO_Flag.Needle_io].NeedleCount = IO.IO_Data[IO.IO_Flag.Needle_io].Temp_Count - IO.IO_Data[IO.IO_Flag.Needle_io].NeedleCount_last;
//        IO.IO_Data[IO.IO_Flag.Needle_io].NeedleCount_Sum += IO.IO_Data[IO.IO_Flag.Needle_io].NeedleCount;
//        IO.IO_Flag.NeedleCountUpdateFlag = 1;
//        //微工厂需求针数要没有变化清零，下列注释，NeedleCount_Sum+=变为=
//        IO.IO_Data[IO.IO_Flag.Needle_io].NeedleCount = 0;
//        IO.IO_Data[IO.IO_Flag.Needle_io].NeedleCount_last = IO.IO_Data[IO.IO_Flag.Needle_io].Temp_Count;
//        if (IO.IO_Flag.log) {
//            rt_kprintf("NeedleCount: %d %d\n", IO.IO_Data[IO.IO_Flag.Needle_io].NeedleCount_Sum, IO.IO_Flag.Needle_io);
//        }
//    }
//    else
//    {
//        IO.IO_Flag.NeedleCountUpdateFlag = 0;
//        IO.IO_Data[IO.IO_Flag.Needle_io].NeedleCount = 0;
//        IO.IO_Data[IO.IO_Flag.Needle_io].NeedleCount_last = IO.IO_Data[IO.IO_Flag.Needle_io].Temp_Count;
//
//    }

}


//控制台更改电平
void IO_key(int argc, char**argv)
{

    rt_uint8_t var = atoi(argv[1]);
    rt_uint8_t var2 = atoi(argv[2]);
    if (var2)
    {
        rt_pin_write(output_pins[var], PIN_HIGH);
    }
    else
    {
        rt_pin_write(output_pins[var], PIN_LOW);
    }
}

MSH_CMD_EXPORT(IO_key, <0-7> <0-1>);


void set_IO_log(rt_uint8_t log){
    IO.IO_Flag.log = log;
}
