21ic电子技术开发论坛 › 单片机与嵌入式系统 › 新唐MCU › 新唐单片机无线解码程序
返回列表 发新帖我要提问

[文档下载] 新唐单片机无线解码程序

[复制链接]
1426|8
 楼主| albertaabbot 发表于 2024-3-11 17:44 | 显示全部楼层 |阅读模式
解码, 无线解码, 无线, 新唐, 单片机
复制
  1. #include "N76E003.h"
    

  2. #include "Main.h"
    

  3. #include "Definition.h"
    

  4. #include "menu.h"
    

  5. #include "Buzzer.h"
    

  6. #include "Function_define.h"
    

  7. #include "SFR_Macro.h"
    

  8. #include "receive.h"
    

  9. #include "flash_eeprom.h"
    


  10. 

  11. void MCU_IO_Port_init(void);
    

  12. void Timer0Initial(void);
    

  13. void Timer1Initial(void);
    

  14. void CheckInPut(void);
    

  15. void Check_KeyCode(void);
    


  16. 

  17. extern bit BIT_TMP;
    

  18. G_TIME_RAM g_Time_ram;
    

  19. G_SYSTEM_RAM g_System_ram;
    

  20. struct Work_Register WRC;
    


  21. 

  22. INT8U idata powerOnBti;
    

  23. INT8U enableBit;
    

  24. /*
    

  25. INT8U read_APROM_BYTE_(INT16U code *u16_addr)
    

  26. {
    

  27.         INT8U rdata;
    

  28.         rdata = *u16_addr>>8;
    

  29.         return rdata;
    

  30. }
    

  31. */
    


  32. 

  33. void MCU_IO_Port_init(void)
    

  34. {
    

  35.         P00_Input_Mode;
    

  36.         P02_Quasi_Mode;
    

  37.         P03_Input_Mode;
    

  38.         P10_Input_Mode;
    

  39.         P11_Input_Mode;
    

  40.         P12_Input_Mode;
    

  41.         P13_Input_Mode;
    

  42.         P14_Input_Mode;
    

  43.         P15_Input_Mode;
    


  44. 

  45.     P01_PushPull_Mode;
    

  46.         P04_PushPull_Mode;
    

  47.         P05_PushPull_Mode;
    

  48.         P06_PushPull_Mode;
    

  49.         P07_PushPull_Mode;
    

  50.         P17_PushPull_Mode;
    

  51.         P30_PushPull_Mode;
    


  52. 


  53. 

  54.         P_LampOut = IO_OFF;
    

  55.         P_MidLockOut = IO_OFF;
    

  56.         P_MidOpenOut = IO_OFF;
    

  57.         P_LedOut = IO_OFF;
    

  58.         P_BUZZER_OUT = IO_OFF;
    

  59.         P_TrunkOut = IO_OFF;
    

  60.         P_EngineOffOut = IO_OFF;       
    

  61.        
    

  62. }
    

  63. /************************************************************************************************************
    

  64. *    Main function
    

  65. ************************************************************************************************************/
    

  66. void main (void)
    

  67. {
    

  68.     static INT8U SysStatusTemp = 0;
    

  69.     static INT8U MidLockBit = 0,MidUnLockBit = 0;
    

  70.    
    

  71.         TMOD = 0XFF;
    

  72.         clr_T0M;
    

  73.         clr_T1M;
    

  74.         set_EA;  
    

  75.                
    

  76.     MCU_IO_Port_init();
    

  77.     Timer0Initial();// 100us
    

  78.     Timer1Initial();// 1ms
    


  79. 

  80.     ////////////////////////////上电读取eeprom的数据///////////////
    

  81.     UserReadData();
    

  82.    
    

  83.     if (g_System_ram.SysStatus == SYS_DISARMMODE)
    

  84.     {
    

  85.         WRC.SecondRelockBit = 1;
    

  86.         p_MenuMode = DisarmMode;
    

  87.         g_System_ram.Initial = TRUE;
    

  88.         P_EngineOffOut = FALSE;
    

  89.         P_LedOut = FALSE;
    

  90.     }
    

  91.     else if ((g_System_ram.SysStatus == SYS_ARMMODE)||(g_System_ram.SysStatus == SYS_AnitHiJack))
    

  92.     {
    

  93.         p_MenuMode = ArmMode;
    

  94.         g_System_ram.Initial = TRUE;
    

  95.         WRC.MidStatusBit = 1;
    

  96.         enableBit = 1;
    

  97.     }
    

  98.     else
    

  99.     {
    

  100.         p_MenuMode = powerOn;
    

  101.         g_System_ram.Initial = FALSE;
    

  102.     }
    

  103.    
    

  104.     powerOnBti = TRUE;
    

  105.     WRC.Save_LockTypeBit = 1;
    

  106.     WRC.Save_BrakeBit = 1;
    

  107.     WRC.Save_ShockBit = 1;
    

  108.    
    

  109.         if (!P_ResetIn)
    

  110.     {
    

  111.         p_MenuMode = TestMode;
    

  112.         g_System_ram.Initial = FALSE;
    

  113.     }
    


  114. 

  115.     if (P_Jump1)
    

  116.     {
    

  117.         WRC.Jump1InBit = 1;
    

  118.     }
    

  119.     else
    

  120.     {
    

  121.         WRC.Jump1InBit = 0;
    

  122.     }
    

  123.         ///////////////////////////////////////////////////////////////////////////
    

  124.         while (1)
    

  125.         {
    

  126.             CheckInPut();
    

  127.             Check_KeyCode();
    

  128.             
    

  129.         if (!WRC.Jump1InBit)//插上跳线时,取消自动设防功能
    

  130.         {
    

  131.             WRC.AutoRelock = 0;
    

  132.         }
    

  133.         if ((!P_EngineOffOut)&&(p_MenuMode != ArmMode)&&(p_MenuMode != TestLockMode)
    

  134.             &&(p_MenuMode != TestMode))
    

  135.         {
    

  136.                 if (WRC.ManualLock)
    

  137.                 {
    

  138.                     if (!MidLockBit)
    

  139.                     {
    

  140.                     g_Time_ram.TimeForEleLock_100ms = 0;
    

  141.                     g_Time_ram.TimeForAirLock_100ms = 0;
    

  142.                     P_MidLockOut = TRUE;
    

  143.                     P_MidOpenOut = FALSE;
    

  144.                     WRC.MidStatusBit = 1;
    

  145.                     MidLockBit = 1;
    

  146.                     enableBit = 0;
    

  147.                 }
    

  148.                 }
    

  149.                 else
    

  150.                 {
    

  151.                 MidLockBit = 0;
    

  152.                 }
    

  153.                 if (WRC.ManualUnLock)
    

  154.                 {
    

  155.                     if (!MidUnLockBit)
    

  156.                     {
    

  157.                     g_Time_ram.TimeForEleLock_100ms = 0;
    

  158.                     g_Time_ram.TimeForAirLock_100ms = 0;
    

  159.                     P_MidOpenOut = TRUE;
    

  160.                     P_MidLockOut = FALSE;
    

  161.                     WRC.MidStatusBit = 0;
    

  162.                     MidUnLockBit = 1;
    

  163.                 }
    

  164.                 }
    

  165.                 else
    

  166.                 {
    

  167.                 MidUnLockBit = 0;
    

  168.                 }
    

  169.             }
    

  170.             /////////////////////////////////////////////////////////////////////////
    

  171.             if ((WRC.AccInBit)&&(!WRC.DoorInBit_N))
    

  172.             {
    

  173.                 if (WRC.RestInHiGoingEdgeBit)//紧急解除
    

  174.             {
    

  175.                 if ((p_MenuMode == AlarmMode)||(p_MenuMode == AlarmForShockMode)
    

  176.                 ||(p_MenuMode == ArmMode))
    

  177.                 {
    

  178.                     P_EngineOffOut = FALSE;
    

  179.                     P_LedOut = FALSE;
    

  180.                     g_Time_ram.CheckResetInTime = 0;
    

  181.                     p_MenuMode = DisarmMode;
    

  182.                     WRC.AccInLowGoingEdgeBit = 0;
    

  183.                     g_System_ram.Initial = FALSE;
    

  184.                     WRC.RestInHiGoingEdgeBit = 0;
    

  185.                     WRC.TriggerCount++;
    

  186.                     
    

  187.                     if (!WRC.SilenceBit)
    

  188.                     {
    

  189.                         Buzzer_Bz_Bz();
    

  190.                     }
    

  191.                 }
    

  192.             }
    

  193.         }
    

  194.         /////////////////////////////////////////////////////////////////////////
    

  195.         ///////////////////写码开始//////////////////////////////////////////////
    

  196.             if ((WRC.AccInBit)&&(WRC.DoorInBit_N))
    

  197.             {
    

  198.             if (WRC.RestBit)
    

  199.             {
    

  200.                 if (g_Time_ram.TimeForWriteCode_100ms >= 50)
    

  201.                 {
    

  202.                     if ((p_MenuMode != LearnCodeMode)&&(p_MenuMode != AlarmMode)
    

  203.                     &&(p_MenuMode != ArmMode)&&(p_MenuMode != TestLockMode)
    

  204.                     &&(p_MenuMode != PanicMode))
    

  205.                     {
    

  206.                         p_MenuMode = LearnCodeMode;
    

  207.                         g_System_ram.Initial = FALSE;
    

  208.                         WRC.ClearCodeBit = 1;
    

  209.                         P_LampOut = TRUE;
    

  210.                         P_LedOut = TRUE;
    

  211.                     }
    

  212.                 }
    

  213.             }
    

  214.             else
    

  215.             {
    

  216.                 g_Time_ram.TimeForWriteCode_100ms = 0;
    

  217.             }
    

  218.             }
    

  219.             else
    

  220.         {
    

  221.             g_Time_ram.TimeForWriteCode_100ms = 0;
    

  222.         }
    

  223.             /////////////////////写码结束////////////////////////////////////////////
    

  224.             p_MenuMode();  /////////主菜单/////////
    

  225.             /////////////////////中控锁的断开输出////////////////////////////////////
    

  226.             if ((p_MenuMode != TestUnLockMode)&&(p_MenuMode != TestLockMode))
    

  227.             {
    

  228.                 if(WRC.Save_LockTypeBit)
    

  229.                 {
    

  230.                 if (g_Time_ram.TimeForEleLock_100ms >= 5)//电锁输出 0.5s
    

  231.                 {
    

  232.                     P_MidLockOut = FALSE;
    

  233.                     P_MidOpenOut = FALSE;
    

  234.                 }
    

  235.             }
    

  236.             else
    

  237.             {
    

  238.                 if (g_Time_ram.TimeForAirLock_100ms >= 40)
    

  239.                 {
    

  240.                     P_MidLockOut = FALSE;
    

  241.                     P_MidOpenOut = FALSE;
    

  242.                 }
    

  243.             }
    

  244.         }
    

  245.         /////////////////////////////////////////////////////////////////////////
    

  246.         /////////////////////行李箱开启开始//////////////////////////////////////
    

  247.         if ((WRC.KeyCode == REWORD12_L)||(WRC.KeyCode == REWORD4_L))
    

  248.         {
    

  249.             g_Time_ram.TimeForTrunk_100ms = 0;
    

  250.             P_TrunkOut = IO_ON;
    

  251.         }
    

  252.         if (g_Time_ram.TimeForTrunk_100ms >= 8)
    

  253.         {
    

  254.             P_TrunkOut = IO_OFF;
    

  255.         }
    

  256.         //////////////////////行李箱开启结束////////////////////////////////////
    

  257.         
    

  258.         //////////////////////掉电存储状态//////////////////////////////////////
    

  259.         if (SysStatusTemp != g_System_ram.SysStatus) //当状态发生变化的时候再去启动存储功能
    

  260.         {
    

  261.             WriteBuffer[13] = g_System_ram.SysStatus;
    

  262.             WriteBuffer[12] =  WRC.SilenceBit;
    


  263. 

  264.             if (g_Time_ram.TimeForOutage_100ms >= 15)//动作完再存储
    

  265.             {
    

  266.                 if (UserWriteData()== TRUE)
    

  267.                 {
    

  268.                     UserReadData();
    

  269.                     SysStatusTemp = g_System_ram.SysStatus;
    

  270.                 }
    

  271.             }
    

  272.         }
    

  273.         else
    

  274.         {
    

  275.             g_Time_ram.TimeForOutage_100ms = 0;
    

  276.         }
    

  277.         /////////////////////////////////////////////////////////////////////////
    

  278.         if ((p_MenuMode == IdleMode)||(p_MenuMode == DisarmMode)
    

  279.             ||(p_MenuMode == DoorOpenMode))//关闭LED常亮3秒,报警提示状态
    

  280.         {
    

  281.             if (g_Time_ram.TimeForLEDoff_100ms >= 30)
    

  282.             {
    

  283.                 P_LedOut = FALSE;
    

  284.             }
    

  285.         }
    

  286.         /////////////////////////////////////////////////////////////////////////
    

  287.         if (WRC.KeyCode != REWORD4)
    

  288.         {
    

  289.             WRC.KeyCode = FALSE;
    

  290.         }
    

  291.         }
    

  292. }
    


  293. 


  294. 

  295. void CheckInPut(void)
    

  296. {
    

  297.     ///////////////////////////////////////////////////////////////
    

  298.         if ((P_AccIn)&&(g_Time_ram.CheckAccOnPasitiveTime >= 2))
    

  299.     {
    

  300.         WRC.AccInBit = 1;
    

  301.     }
    

  302.     else
    

  303.     {
    

  304.         if (!P_AccIn)
    

  305.         {
    

  306.             g_Time_ram.CheckAccOnPasitiveTime = 0;
    

  307.             WRC.AccInBit = 0;
    

  308.         }
    

  309.     }
    

  310.     //////////////////ACC边沿信号检测//////////////////////////////
    

  311.     if (P_AccIn)
    

  312.     {
    

  313.         if (WRC.AccInStatusTemp)
    

  314.         {
    

  315.             if ((p_MenuMode != AlarmMode)&&(p_MenuMode != AlarmForShockMode)
    

  316.                 &&(p_MenuMode != ArmMode)&&(WRC.DoorInBit_N))
    

  317.             {
    

  318.                 WRC.TriggerCount++;
    

  319.             }
    

  320.             WRC.AccInStatusTemp = FALSE;
    

  321.             WRC.AccInHiGoingEdgeBit = 1;
    

  322.             powerOnBti = FALSE;
    

  323.         }
    

  324.     }
    

  325.     else
    

  326.     {
    

  327.         if (!WRC.AccInStatusTemp)
    

  328.         {
    

  329.             WRC.AccInStatusTemp = TRUE;
    

  330.             
    

  331.             if (!powerOnBti)
    

  332.             {
    

  333.                 WRC.AccInLowGoingEdgeBit = 1;
    

  334.             }
    

  335.             
    

  336.             /*if ((p_MenuMode != AlarmMode)&&(p_MenuMode != AlarmForShockMode)
    

  337.                 &&(p_MenuMode != ArmMode)&&(WRC.DoorInBit_N))
    

  338.             {
    

  339.                 WRC.TriggerCount++;
    

  340.             }*/
    

  341.         }
    

  342.     }
    

  343.    
    

  344.     /////////////////////////////////////////////////////////////
    

  345.     //////////////////边门负检测///////////////////////////////
    

  346.     if ((!P_DoorIn_N)&&(g_Time_ram.CheckDoorNagetiveTime >= 2))
    

  347.     {
    

  348.         WRC.DoorInBit_N = 0;
    

  349.     }
    

  350.     else
    

  351.     {
    

  352.         if (P_DoorIn_N)
    

  353.         {
    

  354.             g_Time_ram.CheckDoorNagetiveTime = 0;
    

  355.             WRC.DoorInBit_N = 1;
    

  356.         }
    

  357.     }
    

  358.     ///////////////边门边沿信号检测///////////////////////////
    

  359.     if (!P_DoorIn_N)
    

  360.     {
    

  361.         if (WRC.DoorInStatus)
    

  362.         {
    

  363.             if ((p_MenuMode != AlarmMode)&&(p_MenuMode != AlarmForShockMode)&&(p_MenuMode != ArmMode))
    

  364.             {
    

  365.                 WRC.TriggerCount++;
    

  366.             }
    

  367.             WRC.DoorInStatus = FALSE;
    

  368.             WRC.DoorInHiGoingEdgeBit = 1;
    

  369.         }
    

  370.     }
    

  371.     else
    

  372.     {
    

  373.         if (!WRC.DoorInStatus)
    

  374.         {
    

  375.             WRC.DoorInStatus = TRUE;
    

  376.             WRC.DoorInLowGoingEdgeBit = 1;
    

  377.             /*if ((p_MenuMode != AlarmMode)&&(p_MenuMode != AlarmForShockMode)&&(p_MenuMode != ArmMode))
    

  378.             {
    

  379.                 WRC.TriggerCount++;
    

  380.             }*/
    

  381.         }
    

  382.     }
    

  383.     /////////////////////////////////////////////////////////////
    

  384.     /////////////////////////////////////////////////////////////
    

  385.     if ((P_BrakeIn)&&(g_Time_ram.CheckBrakeTime >= 2))
    

  386.     {   
    

  387.         WRC.BrakeInBit = 1;
    

  388.     }
    

  389.     else
    

  390.     {
    

  391.         if (!P_BrakeIn)
    

  392.         {
    

  393.             g_Time_ram.CheckBrakeTime = 0;
    

  394.             WRC.BrakeInBit = 0;
    

  395.         }
    

  396.     }
    

  397.     //////////////////脚刹边沿信号检测//////////////////////////////
    

  398.     if (P_BrakeIn)
    

  399.     {
    

  400.         if (WRC.BrakeInStatusTemp)
    

  401.         {
    

  402.             WRC.BrakeInStatusTemp = FALSE;
    

  403.             WRC.BrakeInHiGoingEdgeBit = 1;
    

  404.         }
    

  405.     }
    

  406.     else
    

  407.     {
    

  408.         if (!WRC.BrakeInStatusTemp)
    

  409.         {
    

  410.             WRC.BrakeInStatusTemp = TRUE;
    

  411.             WRC.BrakeInLowGoingEdgeBit = 1;
    

  412.         }
    

  413.     }
    

  414.     /////////////////////////////////////////////////////////////
    

  415.     /////////////////////////////////////////////////////////////
    

  416.     if ((!P_ShockIn)&&(g_Time_ram.CheckShockInTime >= 10))
    

  417.     {
    

  418.         WRC.ShockSensorBit = 1;
    

  419.         g_Time_ram.CheckShockInTimeTemp = 0;
    

  420.     }
    

  421.     else
    

  422.     {
    

  423.         if ((P_ShockIn)&&(g_Time_ram.CheckShockInTimeTemp >= 20))
    

  424.         {
    

  425.             g_Time_ram.CheckShockInTime = 0;
    

  426.             WRC.ShockSensorBit = 0;
    

  427.         }
    

  428.     }
    

  429.     /////////////////////////////////////////////////////////////
    

  430.     ////////////////////////////////////////////////////////////
    

  431.     if ((!P_ResetIn)&&(g_Time_ram.CheckResetInTime >= 1))
    

  432.     {
    

  433.         WRC.RestBit = 1;
    

  434.     }
    

  435.     else
    

  436.     {
    

  437.         if (P_ResetIn)
    

  438.         {
    

  439.             g_Time_ram.CheckResetInTime = 0;
    

  440.             WRC.RestBit = 0;
    

  441.         }
    

  442.     }
    

  443.     if (WRC.RestBit)
    

  444.     {
    

  445.         if (WRC.RestInStatus)
    

  446.         {
    

  447.             WRC.RestInStatus = FALSE;
    

  448.             WRC.RestInHiGoingEdgeBit = 1;
    

  449.         }
    

  450.     }
    

  451.     else
    

  452.     {
    

  453.         if (!WRC.RestInStatus)
    

  454.         {
    

  455.             WRC.RestInStatus = TRUE;
    

  456.             WRC.RestInHiGoingEdgeBit = 0;
    

  457.         }
    

  458.     }
    

  459.     ///////////////////////////////////////////////////////
    

  460.     if ((!P_ManualLockIn)&&(g_Time_ram.ManualLockTime >= 2))
    

  461.     {   
    

  462.         WRC.ManualLock = 1;
    

  463.     }
    

  464.     else
    

  465.     {
    

  466.         if (P_ManualLockIn)
    

  467.         {
    

  468.             g_Time_ram.ManualLockTime = 0;
    

  469.             WRC.ManualLock = 0;
    

  470.         }
    

  471.     }
    

  472.     if ((!P_ManualUnLockIn)&&(g_Time_ram.ManualUnLockTime >= 2))
    

  473.     {   
    

  474.         WRC.ManualUnLock = 1;
    

  475.     }
    

  476.     else
    

  477.     {
    

  478.         if (P_ManualUnLockIn)
    

  479.         {
    

  480.             g_Time_ram.ManualUnLockTime = 0;
    

  481.             WRC.ManualUnLock = 0;
    

  482.         }
    

  483.     }
    

  484.     //////////////////////////////////////////////////////////////////
    

  485. }
    


  486. 

  487. void Check_KeyCode(void)
    

  488. {
    

  489.     static INT8U keyBit = 0;
    

  490.    
    

  491.     if (ReceiveBuffer[2] != 0)
    

  492.     {
    

  493.         if (WRC.K_OldKeyCode == ReceiveBuffer[2])
    

  494.         {
    

  495.             if (ReceiveBuffer[2] != REWORD4)
    

  496.             {
    

  497.                             if (g_Time_ram.TimeForContinueKey_100ms >= 15)                                       
    

  498.                             {
    

  499.                                     g_Time_ram.TimeForContinueKey_100ms = 0;
    

  500.                                    
    

  501.                     if (!keyBit)
    

  502.                     {
    

  503.                         keyBit = 1;
    

  504.                         WRC.KeyCode = ReceiveBuffer[2]|0x30;
    

  505.                     }
    

  506.                         }
    

  507.                     }
    

  508.                     else
    

  509.                     {
    

  510.                 if (g_Time_ram.TimeForContinueKey_100ms >= 20)                                       
    

  511.                             {
    

  512.                                     g_Time_ram.TimeForContinueKey_100ms = 0;
    

  513.                                    
    

  514.                     if (!keyBit)
    

  515.                     {
    

  516.                         keyBit = 1;
    

  517.                         WRC.KeyCode = ReceiveBuffer[2]|0x30;
    

  518.                     }
    

  519.                         }
    

  520.                         
    

  521.                         g_Time_ram.TimeForContinueKey_10ms = 0;
    

  522.                     }
    

  523.                 }
    

  524.             else
    

  525.             {
    

  526.             if (((ReadBuffer[0] == ReceiveBuffer[0])&&(ReadBuffer[1] == ReceiveBuffer[1])&&(ReadBuffer[2] == ReceiveThirdData))
    

  527.                 ||((ReadBuffer[3] == ReceiveBuffer[0])&&(ReadBuffer[4] == ReceiveBuffer[1])&&(ReadBuffer[5] == ReceiveThirdData))
    

  528.                 ||((ReadBuffer[6] == ReceiveBuffer[0])&&(ReadBuffer[7] == ReceiveBuffer[1])&&(ReadBuffer[8] == ReceiveThirdData))
    

  529.                 ||((ReadBuffer[9] == ReceiveBuffer[0])&&(ReadBuffer[10] == ReceiveBuffer[1])&&(ReadBuffer[11] == ReceiveThirdData))
    

  530.                 ||(WRC.WriteCodeBit))
    

  531.             {
    

  532.                 WRC.KeyCode = ReceiveBuffer[2];     
    

  533.                 WRC.K_OldKeyCode = ReceiveBuffer[2];  
    

  534.                 g_Time_ram.TimeForContinueKey_100ms = 0;
    

  535.                 g_Time_ram.TimeForContinueKey_10ms = 0;
    

  536.                 keyBit = 0;
    

  537.             }   
    

  538.             }
    

  539.     }
    

  540.     else
    

  541.     {
    

  542.         WRC.K_OldKeyCode = 0;
    

  543.         g_Time_ram.TimeForContinueKey_100ms = 0;
    

  544.     }
    

  545. }


回复

收藏 举报

相关帖子
tpgf 发表于 2024-4-7 14:50 | 显示全部楼层
解码的过程中我看着应该是对相关标志位进行判定是吗
回复

收藏 举报

wakayi 发表于 2024-4-7 15:35 | 显示全部楼层
感觉引脚初始化的函数那边确实比较多样化
回复

收藏 举报

wowu 发表于 2024-4-7 20:38 | 显示全部楼层
感觉判定没有那么复杂 为什么会有这么多的条件分支呢
回复

收藏 举报

renzheshengui 发表于 2024-4-7 21:12 | 显示全部楼层
对数据的编码解码方式都有哪些呢 开源的
回复

收藏 举报

paotangsan 发表于 2024-4-7 21:46 | 显示全部楼层
这种解码肯定需要提前知道编码的规律吧
回复

收藏 举报

keaibukelian 发表于 2024-4-7 22:20 | 显示全部楼层
无线解码需要特定的解码算法吗
回复

收藏 举报

呐咯密密 发表于 2024-4-9 14:18 | 显示全部楼层
代码还是很详细的
回复

收藏 举报

ClarkLLOTP 发表于 2024-4-15 15:21 来自手机 | 显示全部楼层
编解码用的什么算法啊
回复

收藏 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

albertaabbot

13

主题

1568

帖子

1

粉丝
快速回复 在线客服 返回列表 返回顶部