21ic电子技术开发论坛 › 非技术讨论区 › 活动专区 › 基于KL27的旋转LED
返回列表 发新帖我要提问本帖赏金: 10.00元(功能说明)

[活动] 基于KL27的旋转LED

[复制链接]
 楼主| EDL陆 发表于 2016-2-1 19:58 | 显示全部楼层 |阅读模式
旋转LED, TE, se, AC, ST
本帖最后由 EDL陆 于 2016-2-1 20:06 编辑

  首先自己重新设计了PCB，参考网络上多数人使用无线供电的方式，利用变压器原理，给板上芯片供电,但是在加上无线模块之后,压降太厉害,导致芯片不能正常工作，身边也没有对此比较熟悉的人，教训就是不要再自己不熟悉的地方浪费时间，最终决定换一种方案试一下。如图



反面：中间有两个同心圆，一个接电源，一个接地。电源有马达的轴来供给，为了保证充分接触，选择合适的弹簧套在轴上。为了稍微保持平衡一点，地线也由两个弹簧构成，最好选取软一点的弹簧，不能太硬，不然摩擦会太大。可以想象的到，这样的话旋转起来之后，就不会导致供电有问题了。




正面。排插是留给WIFI模块的，两个595芯片，用来控制16个小灯。

侧视图来一张。


安卓不是很会，现学。在源码的基础上加了自己取字模的功能，更换显示信息。将字模有手机端发送到旋转LED然后存放到Flash，保证数据在掉电后不丢失。接下来试着解决杂声和抖动，完善丰富其他功能。

效果图。

安卓端部分代码：
复制
  1. public class MainActivity<Params> extends TabActivity implements
    

  2.                 OnClickListener {        
    

  3.         InputStream fin3;
    

  4.         int numChinese=0;
    

  5.         int numAscii=0;
    

  6.         int offChi;
    

  7.         int i,j,k,l;
    

  8.         byte[] temp4 = new byte[32];
    

  9.         int[] temp5 = new int[32];
    

  10.         
    

  11.         int[] temp6 = new int[32];   //最终想要的字模（纵向取模） 同笔记
    

  12.                 
    

  13.         int[] hanzi =new int[32*4];  //首先声明4个汉字的空间
    

  14. //        char[] hanzi =new char[32*4];  //首先声明4个汉字的空间
    

  15.         
    

  16.         byte[] hanBuf2;
    

  17.         byte[] hanBuf21;
    

  18.        
    


  19. 

  20.         /******************************************************************************/
    


  21. 

  22.         @Override
    

  23.         public void onClick(View v) {
    


  24. 

  25.                 switch (v.getId()) {
    


  26. 

  27.                 // 启动2个工作线程:发送、接收。！！！？？
    

  28.                 case R.id.id_btn_connClose:
    


  29. 

  30.                         connectThread();
    

  31.                         break;
    


  32. 

  33.                 case R.id.id_btn_send:
    


  34. 

  35.                         sendData();
    

  36.                         break;
    

  37.                         
    

  38.                 case R.id.id_btn_clear:
    


  39. 

  40.                         clearData();
    

  41.                         break;
    

  42.                 }
    

  43.         }
    


  44. 


  45. 


  46. 

  47.                 private void sendData() {
    

  48.                         String contentSend = edtSend.getText().toString(); //取得输入框字符
    

  49.                         int lenthSend = edtSend.getText().length();        //得到输入字符长度
    

  50.                         if (printWriter == null || contentSend == null) {
    


  51. 

  52.                                 if (printWriter == null) {
    

  53.                                         showInfo("连接失败!");
    

  54.                                         return;
    

  55.                                 }
    

  56.                                 if (contentSend == null) {
    

  57.                                         showInfo("内容为空!");
    

  58.                                         return;
    

  59.                                 }
    

  60.                         }        
    

  61.                         for(i=0;i<lenthSend;i++)  //遍历左右字符
    

  62.                         {
    

  63.                                 char ch=contentSend.charAt(i);
    

  64.                                 String str=String.valueOf(ch);
    

  65.                                 try {
    

  66.                                         byte[] bs = str.getBytes("gb2312");   //得到区位码
    

  67.                                         if(bs.length<2)    //是英文或者符号
    

  68.                                         {
    

  69.                                                 numAscii++;
    

  70.                                                 fin3 = getResources().openRawResource(R.raw.ascii);
    

  71.                                                 fin3.skip((bs[0]-32)*16);
    

  72.                                                 fin3.read(temp4, 0, 16);
    

  73.                                                 //64, 32, -96, -96, -96, -64, 0, 0, 6, 9, 8, 8, 8, 15, 8, 0
    

  74.                                                 for(j=0;j<16;j++)
    

  75.                                                 {
    

  76.                                                         temp5[j]=temp4[j]&0xFF;   //8位无符号
    

  77.                                                 }
    

  78.                                                 
    

  79.                                                 for(k=0;k<8;k++)
    

  80.                                                 {
    

  81.                                                         hanzi[k*2]=temp5[k];
    

  82.                                                         hanzi[k*2+1]=temp5[k+8];
    

  83.                                                 }
    


  84. 

  85.                                                  printWriter.print('A');
    

  86.                                                 printWriter.print((char)(16*3+1));
    

  87.                                 printWriter.print((char)i); //帧号
    

  88.                                 for(l=0;l<16;l++)
    

  89.                                 {
    

  90.                                         int baiwei=hanzi[l]/100;
    

  91.                                         printWriter.print(baiwei);
    

  92.                                         
    

  93.                                         int shiwei=(hanzi[l]%100)/10;
    

  94.                                         printWriter.print(shiwei);
    

  95.                                         
    

  96.                                         int gewei=hanzi[l]%10;
    

  97.                                         printWriter.print(gewei);  
    

  98.                                 }
    

  99.                                 printWriter.print('B');        
    

  100.                                                 printWriter.flush();
    

  101.                                 Thread.currentThread();
    

  102.                                                 Thread.sleep(1000);//阻断1秒
    

  103.                                         }
    

  104.                                         else
    

  105.                                         {
    

  106.                                                 numChinese++;
    

  107.                                                 int quma=bs[0]&0xff;
    

  108.                                                 int weima=bs[1]&0xff;
    

  109.                                                 offChi = ((quma-176)*94+(weima-161))*32;
    

  110.                                                 fin3 = getResources().openRawResource(R.raw.hzkst2);                                 
    

  111.                                                 fin3.skip(offChi);
    

  112.                                                 fin3.read(temp4, 0, 32);
    

  113.                                                 
    

  114.                                                 for(j=0;j<32;j++)
    

  115.                                                 {
    

  116.                                                         temp5[j]=temp4[j]&0xFF;   //8位无符号
    

  117.                                                 }
    

  118.                                                 
    

  119.                                                 for(k=0;k<16;k++)
    

  120.                                                 {
    

  121.                                                         hanzi[k*2]=temp5[k];
    

  122.                                                         hanzi[k*2+1]=temp5[k+16];   //最终字模
    

  123.                                                 }
    

  124.                                                 printWriter.print('A');
    

  125.                                                 printWriter.print((char)(32*3+1));
    

  126.                                 printWriter.print((char)i); //帧号
    

  127.                                 for(l=0;l<32;l++)
    

  128.                                 {
    

  129.                                         int baiwei=hanzi[l]/100;
    

  130.                                         printWriter.print(baiwei);
    

  131.                                         
    

  132.                                         int shiwei=(hanzi[l]%100)/10;
    

  133.                                         printWriter.print(shiwei);
    

  134.                                         
    

  135.                                         int gewei=hanzi[l]%10;
    

  136.                                         printWriter.print(gewei);  
    

  137.                                 }
    

  138.                                 printWriter.print('B');        
    

  139.                                 printWriter.flush();
    

  140.                                 Thread.currentThread();
    

  141.                                                 Thread.sleep(1000);//阻断1秒
    

  142.                                         }
    

  143.                                         
    

  144.                                 } catch (Exception e) {
    

  145.                                         showInfo("字模读取有问题！");
    

  146.                                         // TODO: handle exception
    

  147.                                 }
    

  148.                         }
    

  149.                         //作为结束帧
    

  150.                         printWriter.print('A');
    

  151.                         printWriter.print((char)(1));
    

  152.                         printWriter.print((char)(numChinese*2+numAscii));
    

  153.                         printWriter.print('B');
    

  154.                         printWriter.flush();
    

  155.                         
    

  156.                         numChinese=0;
    

  157.                         numAscii=0;
    

  158.                                 
    

  159.                 }
    


  160. 

  161.                 private void clearData() {
    

  162.                         edtReceiver.setText("");
    

  163.                         
    

  164.                         showInfo("清除成功！");
    

  165.                 }
    


  166. 

  167.                 private void showInfo(String msg) {
    


  168. 

  169.                         Toast.makeText(MainActivity.this, msg, Toast.LENGTH_LONG ).show();
    


  170. 

  171.                 }        
    


  172. 

  173. }
取字模相关的主要是sendData函数。
底层部分代码：
复制
  1. #include "includes.h"   //包含总头文件
    

  2. #include "string.h"
    

  3. uint_8 receiveFlag=0;
    

  4. uint_8 startFlag;
    

  5. uint_8 moveFlag;
    


  6. 

  7. #define LED_CLK  GPIO_MAKE_PIN(GPIOC_IDX,3)     //时钟线
    

  8. #define LED_STB  GPIO_MAKE_PIN(GPIOC_IDX,2)     //数据锁存线
    

  9. #define LED_OE   GPIO_MAKE_PIN(GPIOC_IDX,1)     //使能线
    

  10. #define LED_R    GPIO_MAKE_PIN(GPIOC_IDX,0)     //四根红色数据线
    


  11. 

  12. uint_8 bittonum(uint_8 a,uint_8 b,uint_8 c)
    

  13. {
    

  14.         return a*100+b*10+c;
    

  15. }
    


  16. 


  17. 


  18. 

  19. void time_delay(uint_32 delay)
    

  20. {
    

  21.     uint_32 k;
    

  22.     for(k=0;k<delay;k++)
    

  23.     {
    


  24. 

  25.     }
    

  26. }
    

  27. void LED_init()
    

  28. {
    

  29.         //LED接线初始化：全部定义为输出，同时给出初始电平
    

  30.         gpio_init(LED_CLK, GPIO_OUTPUT,0);    //时钟线
    

  31.         gpio_init(LED_STB, GPIO_OUTPUT,0);    //数据锁存线
    

  32.         gpio_init(LED_OE, GPIO_OUTPUT,1);     //使能线
    

  33.         gpio_init(LED_R, GPIO_OUTPUT,1);     //数据线
    

  34. }
    


  35. 

  36. void Write595(uint_8 data_byte)
    

  37. {
    

  38.         uint_8 l,temp;
    

  39.         temp=0x80;
    

  40.         for (l=0;l<8;l++)
    

  41.         {
    

  42.         //取data_byte字节中的一位，从高位开始，送入595(数据上线)
    

  43.             if ((data_byte&temp)==0)
    

  44.                     gpio_set(LED_R,1);   //灭 ，即0表示灭
    

  45.             else
    

  46.             gpio_set(LED_R,0);   //亮，即1表示亮
    


  47. 

  48.             //CLK产生上升沿,使数据送到595移位寄存器
    

  49.         gpio_set(LED_CLK,0);
    

  50.         gpio_set(LED_CLK,1);
    


  51. 

  52.                 temp=temp>>1;
    

  53.         }
    

  54. }
    

  55. int main(void)
    

  56. {
    


  57. 

  58.         uint_8 params[8]={0};
    

  59.     uint_8 ceshizimo[1024];
    

  60.         uint_8 zimo[32];
    

  61.         uint_32 offset;
    

  62.         uint_8 byteNum;  //1byteNum=16字节
    

  63.         //1. 声明主函数使用的变量
    

  64.         uint_32 i,j,k;
    

  65.         uint_8 numChinese;       //表示接收到汉字的个数，定位flash存储的位置
    

  66.         uint_8 numAscii;
    

  67.         uint_32  mRuncount;     //主循环计数器
    

  68.         uint_32 period;
    

  69.         uint_8 duty;
    

  70.         //2. 关总中断
    

  71.         DISABLE_INTERRUPTS;
    

  72.         //3. 初始化外设模块
    

  73.         light_init(RUN_LIGHT_RED,LIGHT_OFF);     //初始化蓝灯
    

  74.         light_init(RUN_LIGHT_GREEN,LIGHT_OFF);     //初始化蓝灯
    

  75.         uart_init(0, 115200); 
    

  76.         uart_init(2, 115200); 
    

  77.         flash_init();
    

  78.         pit_init(0,1000000);
    

  79.         enable_pit_int();
    

  80. //        flash_erase(63);
    

  81.         LED_init();
    

  82.         gpio_init(INF_LIGHT, 0, 0);
    

  83. //        uint_8 value=gpio_get(INF_LIGHT);
    

  84.         gpio_enable_int(INF_LIGHT,FALLING_EDGE);
    


  85. 

  86.         flash_read(62,0,2,¶ms[0]);
    


  87. 

  88.         if(params[0]==0x0A)
    

  89.                 byteNum=params[1];
    

  90.         else
    

  91.                 byteNum=8;
    

  92.         numChinese=0;
    

  93.         numAscii=0;
    

  94.         moveFlag=0;
    

  95.         k=0;
    

  96.         startFlag=0;
    

  97.         mRuncount=0;            //主循环计数器
    

  98.         uart_send_string(0,"TEST0");
    

  99.         uart_send_string(2,"TEST2");
    

  100.         //5. 使能模块中断
    

  101.         uart_enable_re_int(0);
    

  102.         uart_enable_re_int(2);
    

  103.         //6. 开总中断
    

  104.         ENABLE_INTERRUPTS;
    


  105. 

  106.         //进入主循环
    

  107.         //主循环开始==================================================================
    

  108.         for(;;)
    

  109.         {
    


  110. 

  111.             //运行指示灯闪烁-----------------------------------------------
    

  112.             mRuncount++;                           //主循环次数计数器+1
    

  113.             if (mRuncount >= RUN_COUNTER_MAX)  //主循环次数计数器大于设定的宏常数
    

  114.             {
    

  115.                         mRuncount=0;                   //主循环次数计数器清零
    

  116.                         light_change(RUN_LIGHT_GREEN);      //蓝灯（RUN_LIGHT_BLUE）状态变化
    

  117.                     uart_send1(0,'a');
    

  118.             }
    


  119. 

  120.             if(1 == receiveFlag)
    

  121.             {
    

  122.                     //字母或数字
    

  123.                     if(uart_recvBuf[1]==49 )
    

  124.                     {
    

  125.                             //如果是首帧，清flash及相关变量
    

  126.                             if(uart_recvBuf[2]==0)
    

  127.                             {
    

  128.                                 numChinese=0;
    

  129.                                 numAscii=0;
    

  130.                                 flash_erase(63);
    

  131.                             }
    

  132.                             for(i=3,j=0;i<51;i=i+3,j++)
    

  133.                             {
    

  134.                         zimo[j]=bittonum(uart_recvBuf[i]-48,uart_recvBuf[i+1]-48,uart_recvBuf[i+2]-48);
    

  135.                             }
    


  136. 

  137.                             offset=numChinese*32+numAscii*16;
    

  138.                     flash_write(63,offset,16,zimo);   //将字模数据存放到Flash
    

  139.                         numAscii++;
    

  140.                             uart_send1(0,'Z');
    


  141. 

  142.                     }
    

  143.                     //是中文汉字
    

  144.                     else if(uart_recvBuf[1]==97 )
    

  145.                     {
    

  146.                             if(uart_recvBuf[2]==0)
    

  147.                             {
    

  148.                                 numChinese=0;
    

  149.                                 numAscii=0;
    

  150.                                 flash_erase(63);
    

  151.                             }
    

  152.                             for(i=3,j=0;i<99;i=i+3,j++)
    

  153.                             {
    

  154.                         zimo[j]=bittonum(uart_recvBuf[i]-48,uart_recvBuf[i+1]-48,uart_recvBuf[i+2]-48);
    

  155.                             }
    


  156. 

  157.                             offset=numChinese*32+numAscii*16;
    

  158.                     flash_write(63,offset,32,zimo);   //将字模数据存放到Flash
    

  159.                             numChinese++;
    

  160.                             uart_send1(0,'H');
    

  161.                     }
    

  162.                     //结束帧
    

  163.                     else
    

  164.                     {
    

  165.                             flash_erase(62);
    

  166.                             byteNum=uart_recvBuf[2];
    

  167.                             params[0]=0x0A;
    

  168.                             params[1]=byteNum;
    

  169.                             flash_write(62,0,2,params);   //将字模数据存放到Flash
    

  170.                             memcpy(ceshizimo,63*1024,byteNum*16);
    

  171.                             uart_send1(0,'W');
    

  172.                     }
    

  173.                     receiveFlag=0;
    

  174.             }
    

  175.            //以下加入用户程序----------------------------------------------
    

  176.             if(moveFlag==1)  //旋转移动
    

  177.             {
    

  178.                     k=k+2;
    

  179.             }
    


  180. 

  181.         for(i=k;i<128*2+k;i=i+2)
    

  182.             {
    

  183.                 //先发送的是下半部分，再发上半部分
    

  184.                 Write595(ceshizimo[i+1]);   //下半部分
    

  185.                 Write595(ceshizimo[i]);   //上半部分   低位在上
    


  186. 

  187.                         gpio_set(LED_STB,0);
    

  188.                         gpio_set(LED_STB,1);
    


  189. 

  190.                         gpio_set(LED_OE, 0);//使能
    


  191. 

  192.                         time_delay(100);
    


  193. 

  194.                         Write595(0x00);
    

  195.                         Write595(0x00);
    

  196.                         gpio_set(LED_STB,0);
    

  197.                         gpio_set(LED_STB,1);
    

  198.                         gpio_set(LED_OE, 1);//使能
    

  199.                         if(startFlag==1)
    

  200.                         {
    

  201.                                 startFlag=0;
    

  202.                                 break;
    

  203.                         }
    

  204.            }
    

  205.         }  //主循环end_for
    

  206.        //主循环结束==========================================================
    

  207. }
    


  208. 

  209.
等自己完善好程序在与大家分享。
校园一角，预祝新年快乐！！！




本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复 赏

举报

打赏榜单

21ic小管家 打赏了 10.00 元 2016-05-16
理由：【申请有奖】TI USBType-C来袭，测评达人是你吗？活动打赏。

相关帖子
雪花梨电子 发表于 2017-2-26 20:49 | 显示全部楼层
我是沙发吗？哈哈，祝贺，看着很棒嘛 ， 可不可以发我一套耍耍啊。。
回复 赏

举报

 楼主| EDL陆 发表于 2017-3-6 19:19 | 显示全部楼层
雪花梨电子 发表于 2017-2-26 20:49
我是沙发吗？哈哈，祝贺，看着很棒嘛 ， 可不可以发我一套耍耍啊。。

已经交给发包方啦。手上没有了
回复 赏

举报

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

本版积分规则

EDL陆

2

主题

11

帖子

0

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