C语言开发，我们这个行业还专门有人将单片机的C语言开发，甚至51单片机的c语言开发单独拿出来讲。搞得我刚入行的时候，以为那是一种特殊的C语言。甚至比英伟达GPU上那种开发语言还要距离“真正”的C语言更远......[/code]
一个从单片机开始的开发者
学校学的是电子专业，但是做硬件需要耐心和细心，几次电路板设计的失误让我彻底放弃了硬件这块儿。感觉还是软件更合适，学校只学了basic，于是自己学习了C语言的开发，那个时候感觉C语言好难，做pc下的c语言开发，如果涉及到底层，是非常牛X的事情，足以让人望而却步。也没有钱专门去做这方面的培训，于是就从单片机入手。

再贴一下自己第一段跑在单片机上的代码：
       

1. void text(void)
   
2. {
   
3. 
   
4.    bit Flag_add;                                  /*加一标志*/
   
5.    bit Flag_sub;                                  /*减一标志*/   
   
6.    unsigned char max_value;                       /*各时间单位的最大值*/
   
7.    unsigned char min_value;                       /*各时间单位的最小值*/
   
8.          /*if(FUN==1)
   
9.            {   */                                   /*定义标志位*/
   
10.               if(switch_work==0)                 /*移位键*/
    
11.                   {               
    
12.                       if(Shift_on==0)
    
13.                         {
    
14.                                 Shift_on=1;
    
15.                                 buzzer();
    
16.                             clk_number++;
    
17.                             if(clk_number>6)clk_number=1;                             
    
18.                              }
    
19.                         }
    
20.               else
    
21.                    Shift_on=0;
    
22.               if(switch_up==0)                   /*加一键*/
    
23.                   {
    
24.                             if(Add_on==0)
    
25.                               {
    
26.                                       Add_on=1;
    
27.                                         buzzer();
    
28.                             Flag_add=1;
    
29.                                    }
    
30.                          }
    
31.               else
    
32.                         Add_on=0;
    
33.               if(switch_down==0)                   /*减一键*/
    
34.                   {
    
35.                             if(Sub_on==0)
    
36.                               {
    
37.                                       Sub_on=1;
    
38.                                               buzzer();
    
39.                                       Flag_sub=1;
    
40.                                    }
    
41.                    }
    
42.                else
    
43.                    Sub_on=0;
    
44.               switch(clk_number)
    
45.                    {
    
46.                              case 1: max_value=99;min_value=0;break;
    
47.                              case 2: max_value=12;min_value=1;break;
    
48.                              case 3:     if(clk_data[1]==1||
    
49.                                                   clk_data[1]==3||
    
50.                                                   clk_data[1]==5||
    
51.                                                   clk_data[1]==7||
    
52.                                                   clk_data[1]==8||
    
53.                                                   clk_data[1]==10||
    
54.                                                   clk_data[1]==12)
    
55.                                                   max_value=31;       /*1，3，5，7，8，10，12*/
    
56.                                                else if(
    
57.                                                   clk_data[1]==4||
    
58.                                                   clk_data[1]==6||
    
59.                                                   clk_data[1]==9||
    
60.                                                   clk_data[1]==11)
    
61.                                                   max_value=30;                   /*4，6，9，11*/
    
62.                                                else if((clk_data[0]%4==0)||clk_data[0]==0)                          
    
63.                                                   max_value=29;                   /*闰年*/
    
64.                                                else
    
65.                                                   max_value=28;
    
66.                                                min_value=1;
    
67.                                                break;
    
68.                              case 4: max_value=23;min_value=0;break;
    
69.                              case 5: max_value=59;min_value=0;break;
    
70.                              case 6: max_value=7;min_value=1;break;
    
71.                            }
    
72.               if(Flag_add==1)
    
73.                  {
    
74.                            clk_data[clk_number-1]++;         
    
75.                            Flag_add=0;
    
76.                            if(clk_data[clk_number-1]>max_value)
    
77.                          clk_data[clk_number-1]=min_value;                     
    
78.                        }
    
79.               else if(Flag_sub==1)
    
80.                  {
    
81.                           clk_data[clk_number-1]--;        
    
82.                      Flag_sub=0;
    
83.                      if(clk_data[clk_number-1]<min_value||clk_data[clk_number-1]==0xff)
    
84.                         clk_data[clk_number-1]=max_value;  
    
85.                   }
    
86.              if(switch_function==0)
    
87.             {
    
88.                   if(function_on==0)
    
89.                   {
    
90.                             function_on=1;
    
91.                             FUN=0;
    
92.                             buzzer();
    
93.                             function_state=1;
    
94.                             fun0_flag=1;
    
95.                              set_time[0]=(clk_data[4]/10)*0x10+(clk_data[4]%10);
    
96.                           set_time[1]=(clk_data[3]/10)*0x10+(clk_data[3]%10);
    
97.                           set_time[2]=(clk_data[2]/10)*0x10+(clk_data[2]%10);
    
98.                           set_time[3]=(clk_data[1]/10)*0x10+(clk_data[1]%10);
    
99.                           set_time[4]=(clk_data[5]/10)*0x10+(clk_data[5]%10);
    
100.                           set_time[5]=(clk_data[0]/10)*0x10+(clk_data[0]%10);
     
101.                            
     
102.                                           
     
103.                          }
     
104.                      }
     
105.                      else
     
106.                      {
     
107.                              function_on=0;
     
108.                          }                        
     
109.                   
     
110. }

复制代码

这段代码是运行在51单片机上的处女作，那是14年前的事情了。


当初从单片机开始接触编程，总觉得在linux(或者windows）上做开发好高大上。后来从学习安装linux和基本指令开始，直到在郑州一家做电力系统信息化的小公司接手一个之前时工做的linux项目维护开始（这里非常感谢时工的指点和帮助），后来工作中慢慢熟悉了linux应用开发。到上海后，抽空看看内核和驱动，在后边的工作中陆续用上了，感觉也就那样子吧。这个过程大概持续了四五年，大约14年之后就很少再关注linux的细节了，开始关注软件工程，敏捷开发，面向对象什么的，直到现在还是感觉自己在这方面所知甚少，没有达到设计一款软件时候有非常明确方向，并且有非常有效的手段的感觉，还是一些经验的积累，距离目标甚远。
最近的工作需要解决一些linux内核的问题，也会涉及到bootloader，没有什么特别的地方，方向也很明确，只是花点时间去理解一下linux某种特定机制而已：比如3.0之后内核增加的设备树概念，比如从android带来的低功耗管理等等。
linux的问题是一个理解别人做了什么，怎么做的问题。是一个相对很有边界的问题。
但是软件设计本身是一个在不断演进的问题，是一个没有边界的问题，而且很抽象，所以我一直更多花心思在这上面。

这些年，行业的热点在不停变换，所使用的技术也是不断演进，然而就相对底层的开发而言，变化就小很多。总有某些内容会沉淀下来的，他们需要花费很大的专注和领悟才能达到某种高度，要想有所成就就必须抛弃浮躁，但是这个行业本身又是那样浮躁，真不是一件容易做到的事情，而且做到了也常常看不到效果或者感觉付出没有得到应有的“回报”，取舍总是有的，生活中处处都是。

一个真正的软件工程师应该不能对平台依赖太多，而且尽量不要太依赖某一两种语言。
有很多事和平台无关的知识，也和语言无关。我们就是要在合适的平台上，用合适的语言去构建用户需要的系统。这个系统要兼顾可扩展（根据需要对某些内容方便扩展）和可维护性。有时候要根据具体情况对付出和收益作出权衡。

最近也抽空写一个可以在单片机和linux下都可以使用的简易通信框架：
zxcom




这里是其中一个文件pacet.c：

       

1. #include "packet.h"
   
2. #include "command.h"
   
3. #include "ucomlib.h"
   
4. 
   
5. unsigned int g_cur_msgid = 0;
   
6. 
   
7. static inline unsigned int get_new_msgid()
   
8. {
   
9.         ENTER_CRITICAL();
   
10.         if(g_cur_msgid >= 0x00ffffff){
    
11.                 g_cur_msgid = 0;
    
12.         } else {
    
13.                 g_cur_msgid += 1;
    
14.         }
    
15.         EXIT_CRITICAL();
    
16. 
    
17.         return g_cur_msgid;
    
18. }
    
19. 
    
20. int ZxcomOnPacket(const char *pack,const int len)
    
21. {
    
22.         int ret;
    
23.         unsigned int datalen;
    
24. 
    
25.         char req[100];
    
26.         handler_param_t param;
    
27.         
    
28.         packet_t *packet = (packet_t *)pack;
    
29. 
    
30.         unsigned int dir = GET_DIR(packet->ctrlInfo);
    
31.         unsigned int msg_type = GET_MSG_TYPE(packet->ctrlInfo);
    
32.         cmd_content_t *content = (cmd_content_t *)packet->data;
    
33.         unsigned int msg_id = (unsigned int)GET_MSG_ID(packet->ctrlInfo);
    
34. 
    
35.         if(dir == DIR_REQUEST) {
    
36.                 command_handler_t handler = g_command_manager.get_command(content->cmd_id);
    
37.                 if(handler == NULL){
    
38.                         return ERR_CMD_NOT_EXIST;
    
39.                 }
    
40. 
    
41.                 ret = handler(packet->data);
    
42.                 if(ret != 0) {
    
43. 
    
44.                 }
    
45.         } else if(dir == DIR_RESPONSE) {
    
46.                 if(msg_type == MSG_TYPE_ASYNC) {
    
47.                         ret = CommGetMsg(msg_id,req,&datalen);
    
48.                         if(ret != 0) {
    
49.                                 return ret;
    
50.                         }
    
51. 
    
52.                         packet_t *pk = (packet_t *)req;
    
53.                         cmd_content_t *cmd = (cmd_content_t *)pk->data;
    
54.                         param.req = cmd->param;
    
55.                         param.res = packet->data + sizeof(COMMAND_ID_TYPE);
    
56. 
    
57.                         command_handler_t handler = g_command_manager.get_response(content->cmd_id);
    
58.                         if(handler == NULL){
    
59.                                 return ERR_CMD_NOT_EXIST;
    
60.                         }
    
61.                         
    
62.                         ret = handler(¶m);
    
63.                         if(ret != 0) {
    
64.                         }
    
65.                 }
    
66.         }
    
67. 
    
68.         return 0;
    
69. }
    
70. 
    
71. int ZxcomOnSendMsg(COMMAND_ID_TYPE cmdId,const char *param,const unsigned int paramLen,char *packet)
    
72. {
    
73.         int i,ret;
    
74.         
    
75.         packet_t *pk = (packet_t *)packet;
    
76.         unsigned int msgid = get_new_msgid();
    
77.         
    
78.         pk->ctrlInfo = SET_CTRL_INFO(DIR_REQUEST, MSG_TYPE_ASYNC,msgid);
    
79. 
    
80.         cmd_content_t *cmd = (cmd_content_t *)pk->data;
    
81.         cmd->cmd_id = cmdId;
    
82.         
    
83.         for(i = 0;i < paramLen;i ++) {
    
84.                 cmd->param[i] = param[i];
    
85.         }
    
86. 
    
87.         ret = CommSaveMsg(msgid,packet,paramLen + sizeof(COMMAND_ID_TYPE));
    
88.         if(ret != 0) {
    
89.                 return ret;
    
90.         }
    
91. 
    
92.         return 0;
    
93. }
    
94. 
    
95. int ZxcomOnSendResponse(const void *recv,const char *param,const unsigned int paramLen,char *packet)
    
96. {
    
97.         int i,ret;
    
98. 
    
99.         const char *__mptr = (char *)recv;
    
100.         packet_t *recv_pk = (packet_t *)(__mptr - offsetof(packet_t,data));
     
101.         cmd_content_t *recv_content = (cmd_content_t *)recv_pk->data;
     
102.         
     
103.         packet_t *pk = (packet_t *)packet;
     
104.         
     
105.         pk->ctrlInfo = SET_CTRL_INFO(DIR_RESPONSE, MSG_TYPE_ASYNC,GET_MSG_ID(recv_pk->ctrlInfo));
     
106. 
     
107.         cmd_content_t *content = (cmd_content_t *)pk->data;
     
108.         content->cmd_id = recv_content->cmd_id;
     
109.         
     
110.         for(i = 0;i < paramLen;i ++) {
     
111.                 content->param[i] = param[i];
     
112.         }
     
113. 
     
114.         return 0;
     
115. }

复制代码

希望有人可以把这些C代码跑在单片机上。