程序已经有高手帮忙，在此感谢，代码保留，方便大家自己修改 [复制链接]

顶一个，别的忙帮不了。

BUG其实不是我发现的，是玩CW高手们发现的，因为我还不会CW，有问题也不一定发现的了，所以说具体是什么问题还得CW高手来回答大家。谢谢

看下载了85次，我也增加一次，其实没有用，看不懂。。。。


希望高手解决问题！

我认为要
先了解问题的具体情况
再针对性的去阅读程序

BD8SZ:这个记得当年不会cw的时候,玩过bd6ra的4波段,忘了什么名字了,机器内置一个IC,据赵师描述好像是国内谁设计的专用自动键芯片,详细的真记不得,今天看来,不知道真是有这样的芯片,还是一个可编程芯 .. (2017-01-20 05:37) 

你说的应该是Panda2，我记得那个芯片是个8爪的PIC12F系列的单片机，为什么单独弄个mcu实现不理解作者的初衷。现在自动键程序都集成在主单片机了。

那个pic据说是国外的人做的

内容来自Android手机客户端

还没看楼主程序，我去年给自己的自动呼叫器完善了自动键功能（基于STM32），经过测试和ICOM鸡自带自动键逻辑能做到完全一致，不知和楼主的差别有多大

楼主不妨把源代码放出来，有能力上的自然会找您要Fx

内容来自Android手机客户端

yellowyy:楼主不妨把源代码放出来，有能力上的自然会找您要Fx (2017-01-21 08:58) 

帖子里的就是源代码

这机器外观做工都很不错，把玩了几天。家里没天线，没真正测试，准备等春节假期里野外去好好玩一把。
现在就发现的问题反馈如下：
1，音量太小。
2，没找到手键模式。
3，自动键点划长度与间隔会有小幅度的随机变动，造成拍发容易出错。
4，自动CQ会出现乱码。
5，电源键一碰就开机，最好改成跟关机一样，按住一会儿才开机。

nnnn n n #include "bsp_key.h"
#include "bsp_timer.h"
#include "bsp_adc.h"
#include "bsp_oled_api.h"

// 老版本
//开关        PD6/87/K1  PD5/86/K2  PD7/88/K3  PD4/85/K4  PD0/81/K5  PD1/82/K6  
//开关        PC12/80/K7  PC11/79/K8  PC10/78/K9  PA15/77/K10
//编码器      PB4/90/K1-A  PB3/89/K1-B  PA12/71/K9-A  PA11/70/K9-B  PA10/69/K10-A  PA9/68/K10-B
//光电编码器  PD2/83/R1-A  PD3/84/R1-B

// 新版本
//开关        PB4/90/K1   PD6/87/K3
//编码器      PA12/71/K1-A  PA11/70/K1-B
//声音编码器  PA10/69/K2-A  PA9/68/K2-B   -> 后期 改到 57/PD10 58/PD11脚
//光电编码器  PD2/83/R1-A  PD3/84/R1-B
//PE12/43/KEY1 是点控制。PE13/44/KEY2是划控制
//PB0/35脚    PTT开关检测端（此脚使用电阻上拉到3.3V，在SSB模式下，按下话筒开关，开
//        关把此脚对地短路，把35脚电平拉低。单片机控制相应的电路发射，此脚只在SSB模式下起作用）
#define PTT GPIO_Pin_0
#define DIT GPIO_Pin_12
#define DAH GPIO_Pin_13

#define K1 GPIO_Pin_4
#define K2 GPIO_Pin_5
#define K3 GPIO_Pin_6
#define K4 GPIO_Pin_4
#define K5 GPIO_Pin_0
#define K6 GPIO_Pin_1
#define K7 GPIO_Pin_12
#define K8 GPIO_Pin_11

#define K1A GPIO_Pin_12
#define K1B GPIO_Pin_11

#define K2A GPIO_Pin_10
#define K2B GPIO_Pin_11

#define R1A GPIO_Pin_2
#define R1B GPIO_Pin_3

#define KEY_1_PORT GPIOB
#define KEY_23456R1A1BK2A2B_PORT GPIOD
#define KEY_78_PORT GPIOC
#define KEY_K1A1B_PORT GPIOA
#define PADDLE_PORT GPIOE

static KEY_AttrDef key;
bool key_availlble = false;
uint8_t KVal = 0;
uint8_t K9_A = 0;
uint8_t K9_B = 0;

uint8_t kVal    = 0xff; //按键标识，键值
uint16_t kTick   = 0;    //去抖时间kTick * 20毫秒
bool scan_state = true;
uint8_t tick1s = 0;
uint8_t ditUp = 0;
uint8_t ditDown = 0;
uint8_t dahUp = 0;
uint8_t dahDown = 0;
uint8_t pttUp = 0;
uint8_t pttDown = 0;

bool DitPaddle;   // DIT键是否被按下
bool DahPaddle;   // DAH键是否被按下
bool PaddleUpdate = false;
bool PttPressed;  // PTT控制键是否被按下
bool PttFinish;   // PTT按下操作是否被执行
void KEY_EXTI_Config()
{
  EXTI_InitTypeDef EXTI_InitStructure;
  //清空中断标志
  EXTI_ClearITPendingBit(EXTI_Line2);
  EXTI_ClearITPendingBit(EXTI_Line10);
  EXTI_ClearITPendingBit(EXTI_Line11);
  
  //选择中断管脚
  GPIO_EXTILineConfig(GPIO_PortSourceGPIOD, GPIO_PinSource2);
  GPIO_EXTILineConfig(GPIO_PortSourceGPIOD, GPIO_PinSource10);
  GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource11);
  
  EXTI_InitStructure.EXTI_Line = EXTI_Line2; //选择中断线路
  EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt; //设置为中断请求，非事件请求
  EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling; //设置中断触发方式为上下降沿触发
  EXTI_InitStructure.EXTI_LineCmd = ENABLE;                                          //外部中断使能
  EXTI_Init(&EXTI_InitStructure);
  
  EXTI_InitStructure.EXTI_Line = EXTI_Line10; //选择中断线路
  EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt; //设置为中断请求，非事件请求
  EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling; //设置中断触发方式为上下降沿触发
  EXTI_InitStructure.EXTI_LineCmd = ENABLE;                                          //外部中断使能
  EXTI_Init(&EXTI_InitStructure);
  
  EXTI_InitStructure.EXTI_Line = EXTI_Line11; //选择中断线路
  EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt; //设置为中断请求，非事件请求
  EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling; //设置中断触发方式为上下降沿触发
  EXTI_InitStructure.EXTI_LineCmd = ENABLE;                                          //外部中断使能
  EXTI_Init(&EXTI_InitStructure);
}

void GPIO_NVIC_Config()
{
  NVIC_InitTypeDef NVIC_InitStructure;  
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
  
  NVIC_InitStructure.NVIC_IRQChannel = EXTI2_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;  
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;  
  NVIC_Init(&NVIC_InitStructure);
  
  NVIC_InitStructure.NVIC_IRQChannel = EXTI15_10_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;  
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;  
  NVIC_Init(&NVIC_InitStructure);
  
}
void key_init()
{
  GPIO_InitTypeDef GPIO_InitStructure;
  TMR_Init(TIM2, 50, 2000, key_calback);
  TMR_IRQEnable(TIM2);
  
  GPIO_InitStructure.GPIO_Pin =  K1;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  GPIO_Init(KEY_1_PORT, &GPIO_InitStructure);
  GPIO_ResetBits(KEY_1_PORT, K1);
  
  GPIO_InitStructure.GPIO_Pin =  PTT;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  GPIO_Init(KEY_1_PORT, &GPIO_InitStructure);
  
  GPIO_InitStructure.GPIO_Pin =  K2 | K3 | K4 | K5 | K6 | R1A | R1B | K2A | K2B;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  GPIO_Init(KEY_23456R1A1BK2A2B_PORT, &GPIO_InitStructure);
  
  GPIO_InitStructure.GPIO_Pin =  K7 | K8;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  GPIO_Init(KEY_78_PORT, &GPIO_InitStructure);
  
  GPIO_InitStructure.GPIO_Pin =  K1A | K1B;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  GPIO_Init(KEY_K1A1B_PORT, &GPIO_InitStructure);
  
  GPIO_InitStructure.GPIO_Pin =  DIT | DAH;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  GPIO_Init(PADDLE_PORT, &GPIO_InitStructure);
  KEY_EXTI_Config();
  GPIO_NVIC_Config();
  
  // CW模式 ：单键 或 双键判断
  if (GPIO_ReadInputDataBit(PADDLE_PORT, DIT) == 0)
  {
    MENU.cwMode = MANUAL;
  }
  else
  {
    MENU.cwMode = AUTO;
  }
}

uint8_t key_read()
{
  uint16_t port;
  
  port = GPIO_ReadInputData(KEY_1_PORT);
  if( !(port & K1) )
  {
    return 1;
  }
  
  port = GPIO_ReadInputData(KEY_23456R1A1BK2A2B_PORT);
  if ( !(port & K2) )
  {
    return 2;
  }
  
  if( !(port & K3) )
  {
    return 3;
  }
  
  if( !(port & K4) )
  {
    return 4;
  }
  
  if( !(port & K5) )
  {
    return 5;
  }
  
  if( !(port & K6) )
  {
    return 6;
  }
  
  port = GPIO_ReadInputData(KEY_78_PORT);
  if( !(port & K7) )
  {
    return 7;
  }
  
  if( !(port & K8) )
  {
    return 8;
  }
  uint8_t ptt = GPIO_ReadInputDataBit(KEY_1_PORT, PTT);
  if(ptt && PttPressed)
  {
    if(pttDown > 0)
    {
      pttDown = 0;
    }
    pttUp ++;
    if(pttUp >= 1)
    {
      pttUp = 0;
      PttPressed = false;

    }
  }
  else if(!ptt && !PttPressed )
  {
    if(pttUp > 0)
    {
      pttUp = 0;
    }
    pttDown ++;
    if(pttDown >= 1)
    {
      pttDown = 0;
      PttPressed = true;
    }
  }
  
  tick1s ++;
  if(tick1s % 10 == 0)
  {
    if( RF_IsRx() )
    {
      DRMgr.item |= RXCHKItem;
    }
    else
    {
      DRMgr.item |= SWRCHKItem;
      DRMgr.item |= RFCHKItem;
    }
  }
  if(tick1s == 50)
  {
    tick1s = 0;
    DRMgr.item |= DCItem;
  }
  
  port = GPIO_ReadInputData(PADDLE_PORT);

  if(port & DIT)
  {
    if(ditDown > 0)
    {
      ditDown = 0;
    }
    ditUp ++;
    if(ditUp >= 1)
    {
      ditUp = 0;
      DitPaddle = false;
    }
  }
  else
  {
    if(ditUp > 0)
    {
      ditUp = 0;
    }
    ditDown ++;
    if(ditDown >= 1)
    {
      ditDown = 0;
      DitPaddle = true;
    }
  }
  if(port & DAH)
  {
    if(dahDown > 0)
    {
      dahDown = 0;
    }
    dahUp ++;
    if(dahUp >= 1)
    {
      dahUp = 0;
      DahPaddle = false;
    }
  }
  else
  {
    if(dahUp > 0)
    {
      dahUp = 0;
    }
    dahDown ++;
    if(dahDown >= 1)
    {
      dahDown = 0;
      DahPaddle = true;
    }
  }
  
  PaddleUpdate = true;  //用于CW模式的 Paddle更新
  
  return 0xff;
}

void key_readkeyer()
{
  uint16_t port;
  
  port = GPIO_ReadInputData(PADDLE_PORT);
  if(port & DIT)
  {
    DitPaddle = false;
  }
  else
  {
    DitPaddle = true;
  }
  if(port & DAH)
  {
    DahPaddle = false;
  }
  else
  {
    DahPaddle = true;
  }
//  if(port & DIT)
//  {
//    if(ditDown > 0)
//    {
//      ditDown = 0;
//    }
//    ditUp ++;
//    if(ditUp >= 1)
//    {
//      ditUp = 0;
//      DitPaddle = false;
//    }
//  }
//  else
//  {
//    if(ditUp > 0)
//    {
//      ditUp = 0;
//    }
//    ditDown ++;
//    if(ditDown >= 1)
//    {
//      ditDown = 0;
//      DitPaddle = true;
//    }
//  }
//  if(port & DAH)
//  {
//    if(dahDown > 0)
//    {
//      dahDown = 0;
//    }
//    dahUp ++;
//    if(dahUp >= 1)
//    {
//      dahUp = 0;
//      DahPaddle = false;
//    }
//  }
//  else
//  {
//    if(dahUp > 0)
//    {
//      dahUp = 0;
//    }
//    dahDown ++;
//    if(dahDown >= 1)
//    {
//      dahDown = 0;
//      DahPaddle = true;
//    }
//  }
  
  PaddleUpdate = true;  //用于CW模式的 Paddle更新
}

bool key_ispress(KEY_AttrDef *rkey)
{
  *rkey = key;
  return key_availlble;
}

void key_clear()
{
  key_availlble = false;
}

uint8_t upCnt = 0;
void key_calback( void  )
{
  uint8_t kTmp = key_read();
  
  if(kVal == 0xff)      //之前状态无按键
  {
    kVal = kTmp;
    key.state = keyNull;
    kTick = 0;
    return;
  }
  
  if(kTmp != kVal)      //和前次按键不同
  {
    upCnt ++;
    if (upCnt >= 2)
    {
      upCnt = 0;
      if(kTmp == 0xff)    //短按弹起
      {
        if( key.state == keyShot)
        {
          key_availlble = true;
        }
      }
      kVal = kTmp;        //保存新按键值
      kTick = 0;
      return;
    }
  }
  else
  {
    kTick ++;
    if( upCnt > 0 )
    {
      upCnt = 0;
    }
    if(kTick == 4)          //20ms * 1 = 20ms
    {
      key.state = keyShot;
      key.val = kVal;
    }  
    
    if(kTick == 50)      //按住2秒后
    {
      key.val = kVal;
      key.state = keyLong;
      key_availlble = true;
    }
  }
}

void KEY_SoftwareSet(uint8_t kval, KEY_State state)
{
  if( key_availlble == false)
  {
    key.val = kval;
    key.state = state;
    key_availlble = true;
  }
}
// R1 - line_2
void EXTI2_IRQHandler(void)
{
  if (EXTI_GetITStatus(EXTI_Line2) == SET)
  {
    // 锁定状态
    if ( ATT.val )
    {
      EXTI_ClearITPendingBit(EXTI_Line2);
      return;
    }
    
    if (GPIO_ReadInputDataBit(KEY_23456R1A1BK2A2B_PORT, R1B) == 0) // A-下降沿 B-高电平 为正
    {
      // VFO和MEM模式下，调频旋钮都可用，但在MEM模式下 不记忆
      //if (AIMgr.item > 0)
      {    
        if (FREQ.val >= BAUD[ FREQ.numOfbaud ][2])
        {
          FREQ.val = BAUD[ FREQ.numOfbaud ][2];
          if (FREQ.item & TSItem)
          {
            FREQ.val /= 100;
            FREQ.val *= 100;
          }        
        }
        else
        {
          if(AIMgr.item & MENUSETItem)
          {
            MENU_SetUp(MENU.numOfmenu);
          }
          else if ((FREQ.item & RITItem) && !(AIMgr.item))
          {
            if (VFO.RIT >= UPPER_OF_RIT)
            {
              VFO.RIT = UPPER_OF_RIT;
            }
            else
            {              
              if (FREQ.item & TSItem)
              {
                if ((VFO.RIT + 100) < UPPER_OF_RIT)
                {
                  VFO.RIT += 100;
                }
              }
              else
              {
                VFO.RIT ++;
              }
            }
          }
          else
          {
            if (FREQ.item & TSItem)
            {
              FREQ.val += 100;
            }
            else
            {
              FREQ.val ++;
            }
          }
        }
        if (AIMgr.item & MENUSETItem)
        {
          DRMgr.item |= MENUSETItem;
        }
        else if (AIMgr.item & MEMSETItem)
        {
          DRMgr.item |= MEMSETItem;
        }
        else
        {
          DRMgr.item |= FREQItem;
        }
      }
    }
    else
    {
      //if (AIMgr.item > 0)
      {
        if (FREQ.val <= BAUD[ FREQ.numOfbaud ][0])
        {
          FREQ.val = BAUD[ FREQ.numOfbaud ][0];
          if (FREQ.item & TSItem)
          {
            FREQ.val /= 100;
            FREQ.val *= 100;
          }
        }
        else
        {
          if(AIMgr.item & MENUSETItem)
          {
            MENU_SetDown(MENU.numOfmenu);
          }
          else if ((FREQ.item & RITItem) && !(AIMgr.item))  // RIT选中时，且在非设置状态下 起作用
          {
            if (VFO.RIT <= LOWER_OF_RIT)
            {
              VFO.RIT = LOWER_OF_RIT;
            }
            else
            {
              if (FREQ.item & TSItem)
              {
                if((VFO.RIT - 100) >= LOWER_OF_RIT)
                {
                  VFO.RIT -= 100;
                }
              }
              else
              {
                VFO.RIT --;
              }
            }
          }
          else
          {
            if (FREQ.item & TSItem)
            {
              if( FREQ.val >= 100)
              {
                FREQ.val -= 100;
              }
            }
            else
            {
              FREQ.val --;
            }
          }
        }
        
        if (AIMgr.item & MENUSETItem)
        {
          DRMgr.item |= MENUSETItem;
        }
        else if (AIMgr.item & MEMSETItem)
        {
          DRMgr.item |= MEMSETItem;
        }
        else
        {
          DRMgr.item |= FREQItem;
        }
      }
    }
    EXTI_ClearITPendingBit(EXTI_Line2);
  }
}

// K2 - line 10
// K1 - line_11
void EXTI15_10_IRQHandler(void)
{
  if (EXTI_GetITStatus(EXTI_Line10) == SET)
  {
    if ((AIMgr.item & MENUSETItem) || (AIMgr.item & MEMSETItem) || RF_IsTx())
    {
      
    }
    else if(GPIO_ReadInputDataBit(KEY_23456R1A1BK2A2B_PORT, K2A) == 0)
    {
      if (GPIO_ReadInputDataBit(KEY_23456R1A1BK2A2B_PORT, K2B) == 0)  // B-下降沿 A-高电平 为正
      {
        if (AIMgr.item == WPMSETItem)
        {
          if (WPM.val >= 60)
          {
            WPM.val = 60;
          }
          else
          {
            WPM.val ++;
          }
          DRMgr.item |= WPMSETItem;
        }
        else
        {
          if(VOL.val >= 60)
          {
            VOL.val = 60;
          }else{
            VOL.val ++;
          }
        }
      }
      else
      {
        if (AIMgr.item == WPMSETItem)
        {
          if (WPM.val <= 4)
          {
            WPM.val = 4;
          }
          else
          {
            WPM.val --;
          }
          DRMgr.item |= WPMSETItem;
        }
        else
        {
          if(VOL.val <= 0)
          {
            VOL.val = 0;
          }else{
            VOL.val --;
          }
        }
      }
      DRMgr.item |= VOLItem;
      
    }
    EXTI_ClearITPendingBit(EXTI_Line10);
  }
  
  if (EXTI_GetITStatus(EXTI_Line11) == SET)
  {
    if (RF_IsTx())
    {
      
    }
    else if ((AIMgr.item & MENUSETItem) || (FREQ.item & MEMItem) || (FREQ.item & VFOItem))
    {
      if ( GPIO_ReadInputDataBit(KEY_K1A1B_PORT, K1B) == 0)
      {
        if (GPIO_ReadInputDataBit(KEY_K1A1B_PORT, K1A) == 0)
        {
          if(AIMgr.item == MENUSETItem)
          {
            if (MENU.numOfmenu >= SIZE_OF_MENU-1)
            {
              MENU.numOfmenu = SIZE_OF_MENU-1;
            }
            else
            {
              MENU.numOfmenu ++;
            }
            DRMgr.item |= MENUSETItem;
          }
          else if (AIMgr.item == MEMSETItem || FREQ.item & MEMItem)
          {
            
            if (FREQ.numOfmem >= SIZE_OF_MEM-1)
            {
              FREQ.numOfmem = SIZE_OF_MEM-1;
            }
            else
            {
              FREQ.numOfmem ++;
            }
            //FREQ.val =MEM[FREQ.numOfmem].freq;
            MEM_Get();
            if(AIMgr.item == MEMSETItem)
            {
              DRMgr.item |= MEMSETItem;
              DRMgr.item |= RADIOItem;
            }
            else
            {
              DRMgr.item |= FREQItem;
              DRMgr.item |= RADIOItem;
            }
            DRMgr.item |= FILItem;
          }
          else if (FREQ.item & VFOItem)
          {
            if (FREQ.numOfbaud >= SIZE_OF_BAUD-1)
            {
              FREQ.numOfbaud = 0;
            }
            else
            {
              FREQ.numOfbaud ++;
            }
            
            VFO_Get();
            DRMgr.item |= FREQItem;
            DRMgr.item |= RADIOItem;
            DRMgr.item |= FILItem;
          }
        }
        else
        {
          if(AIMgr.item == MENUSETItem)
          {
            if (MENU.numOfmenu <= 0)
            {
              MENU.numOfmenu = 0;
            }
            else
            {
              MENU.numOfmenu --;
            }
            DRMgr.item |= MENUSETItem;
          }
          else if (AIMgr.item == MEMSETItem || FREQ.item & MEMItem)
          {
            
            if (FREQ.numOfmem <= 0)
            {
              FREQ.numOfmem = 0;
            }
            else
            {
              FREQ.numOfmem --;
            }
            //FREQ.val = MEM[FREQ.numOfmem].freq;
            MEM_Get();
            if(AIMgr.item == MEMSETItem)
            {
              DRMgr.item |= MEMSETItem;  
              DRMgr.item |= RADIOItem;
            }
            else
            {
              DRMgr.item |= FREQItem;
              DRMgr.item |= RADIOItem;
            }
            DRMgr.item |= FILItem;
          }
          else if (FREQ.item & VFOItem)
          {
            if (FREQ.numOfbaud == 0)
            {
              FREQ.numOfbaud = SIZE_OF_BAUD-1;
            }
            else
            {
              FREQ.numOfbaud --;
            }
            
            VFO_Get();
            DRMgr.item |= FREQItem;
            DRMgr.item |= RADIOItem;
            DRMgr.item |= FILItem;
          }
        }  
      }
    }
    EXTI_ClearITPendingBit(EXTI_Line11);
  }
}

这个是控制部分的代码
大伙给看看

bg4tmc:这机器外观做工都很不错，把玩了几天。家里没天线，没真正测试，准备等春节假期里野外去好好玩一把。
现在就发现的问题反馈如下：
1，音量太小。
2，没找到手键模式。
3，自动键点划长度与 .. (2017-01-21 11:12) 

音量限制了，没有放到最大增益
自动键手动键自动识别，菜单里也有设置

目前CW程序还是存在一些问题，正在想法解决

电源键，如果可以修改到不是问题

开源可能会取得更大的进步 ，GitHub就不必了，可以采用具有中国特色的开源分享方式

FUCK "IF ELSE"，集思广益！！

下载了，看看能否有啥思路。

要想修改单片机程序中的不足或错误，必须要实际运行程序，看看机器那里有问题，针对错误去找相关部分的程序，现在仅仅看程序，恐怕看不出来什么。
可惜学的是C51语言，STM32的没有接触，要不能免费弄个机器玩玩 。

发过来，估计问题在于循环中点划重叠，循环语句上加入优先划还是点，还要加上自动调整延时判断，最后考虑是不是空间够。

内容来自Android手机客户端

bh4bwx:发过来，估计问题在于循环中点划重叠，循环语句上加入优先划还是点，还要加上自动调整延时判断，最后考虑是不是空间够。 (2017-01-23 09:05) 

以前我们做过简单的自动键，在拍发过程中，划长度判断是肯定需要的，我说的不仅是单个划的长度，而且多划的长度是否完成，也要进行判断，不能在没完成的情况下拍入点而中断了原来划的时长或者数量。

这个程序太复杂了，C语言不行，我就不研究了，没那水平。

如果实在没有人接我再试， 最近正在搞arm，可以尝试一下，俺c的基础还是不错的
应该就是如楼上所说的，点划间隔策略算法部分估计不完善所致