找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 334|回复: 2
打印 上一主题 下一主题
收起左侧

以八位单片机设计电子扁烟源程序原理图,适合初学者

[复制链接]
跳转到指定楼层
楼主
Y_T 发表于 2020-9-21 10:45 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
电路原理图如下:



单片机源程序如下:
  1. const uint        Tab_vdd_data[];

  2. //const uchar        Tab_out_vol_3V7[];
  3. const uchar Tab_out_vol_3V3[];
  4. //const uchar        Tab_out_vol_1V85[];
  5. //const uchar LED_Colours[7];

  6. //============================================
  7. // interrupt function
  8. //============================================
  9. void INT_FUNCTION(void) interrupt
  10. {
  11.         if(TM2IF)
  12.         {
  13.                 TM2IF=0;
  14.                
  15.                 B_200US_INT=1;
  16.                 R_TIME_INT++;
  17.                 if(R_TIME_INT>=50)
  18.                 {
  19.                         R_TIME_INT=0;
  20.                         B_10MS_INT=1;
  21.                 }               
  22.         }
  23.         else
  24.         {
  25.                 INTF=0;
  26.                 INTF2=0;
  27.         }
  28. }

  29. //============================================
  30. // program start
  31. //============================================
  32. //---------------------------------------------------------------

  33. //===============================================================
  34. void main()
  35. {
  36.         MCK=0xa0;
  37.         delay(3);
  38.         
  39.         INTE=0;
  40.         INTE2=0;
  41.         INTF=0;
  42.         INTF2=0;
  43.         
  44.         IO_INIT();
  45.         //CLR_RAM();
  46.         SYS_INIT();
  47. //        DATA_INIT();
  48.         
  49.         led_flash_init(3,0x07);
  50.         
  51.         //r_r0=read_ad_cur();
  52.         
  53.         GIE=1;
  54. //--------------------------------------------------------------------------------------------------------------------------------
  55.         while(1)
  56.         {
  57.                 asm("CLRWDT");
  58.                 time_up();
  59.                
  60.                 out_vol();
  61.                
  62.                 disp_led();
  63.                
  64.                 key_scan();
  65.                 key_handle();
  66.                
  67.                 USB_charge();
  68.                
  69.                 sleep_handle();
  70.         
  71.         }
  72. }
  73. //--------------------------------------------------------------------------------------------------------------------------------
  74. void        IO_INIT(void)
  75. {
  76.         PT1=0xFF;                                                
  77.         PT1EN=0xC7;                                       
  78.         PT1PU=0x20;                                       
  79.         PT1CON=0x00;                        
  80.         
  81.         PT3=0xFF;                                
  82.         PT3EN=0xFE;                                       
  83.         PT3PU=0x00;                                
  84.         PT3CON=0x01;                                //
  85.         PT1W_1=0;//PT1_3
  86.         
  87.         PT5=0xFF;                                        //                                       
  88.         PT5EN=0xFE;                                        //
  89.         PT5PU=0x00;                                        //
  90.         PT5CON=0x00;                                //
  91.         
  92.         VTHSEL=1;
  93. }
  94. //--------------------------------------------------------------------------------------------------------------------------------
  95. void        IO_INIT_sleep(void)
  96. {
  97.         PT1=0xFF;                                        //
  98.         PT1EN=0xC7;                                        //
  99.         PT1PU=0x20;                                        //
  100.         PT1CON=0x70;                                
  101.         
  102.         PT3=0xFF;                                       
  103.         PT3EN=0xFE;                                
  104.         PT3PU=0x00;                                       
  105.         PT3CON=0x01;                                
  106.         PT1W_1=1;        
  107.         
  108.         PT5=0xFF;                                       
  109.         PT5EN=0xFE;                                       
  110.         PT5PU=0x00;                                
  111.         PT5CON=0x00;                        
  112.         
  113.         VTHSEL=1;
  114. }
  115. //--------------------------------------------------------------------------------------------------------------------------------
  116. void        SYS_INIT(void)
  117. {
  118.         WDTCON=0x04;                        
  119.         WDTIN=0xff;                                
  120.         WDTEN=1;                        
  121.         CST_WDT=0;                                
  122.         asm("CLRWDT");                        

  123.         TM2CON=0xb0;                        
  124.         TM2IN=99;                                
  125.         TM2INH=0;                                //
  126.         TM2IE=1;                                //
  127.         
  128.         SRADCON0=0x03;                                //
  129.                                                                         
  130.         SRADCON1=0x80;                                
  131.         REF_SEL_0=1;                        
  132.         REF_SEL_1=0;                                
  133.         REF_SEL_2=1;
  134.         SRADCON2=0x60;                        
  135.         
  136. }
  137. //--------------------------------------------------------------------------------------------------------------------------------
  138. /*
  139. void        DATA_INIT(void)
  140. {
  141. //        Colours_Cnt=0;
  142. //        ColoursFlag=1;
  143. }*/
  144. //--------------------------------------------------------------------------------------------------------------------------------
  145. uint        read_ad_vdd(void)
  146. {
  147.         uint        i=0;
  148.         uchar        j;
  149.         
  150.         PT3CON=0x01;                                
  151.         
  152.         SRADCON0=0x03;                                
  153.                                                                         
  154.         SRADCON1=0x80;                                
  155.         REF_SEL_0=1;                        
  156.         REF_SEL_1=0;                                
  157.         REF_SEL_2=1;
  158.         SRADCON2=C_vdd_ad_chs;        
  159.                                                         
  160.         SRADS=1;                                       
  161.         asm("nop");
  162.         while(SRADS);                        
  163.         asm("nop");
  164.         i=SRADH&0x0f;                        
  165.         i=i<<8;
  166.         i+=SRADL;
  167.         return i;
  168. }
  169. //--------------------------------------------------------------------------------------------------------------------------------
  170. uint        read_ad_short(void)

  171. {
  172.         uint        i=0;
  173.         
  174.         PT3CON=0x01;                        
  175.         P_out_AD_con=1;
  176.         
  177.         SRADCON0=0x03;                        
  178.                                                                
  179.         SRADCON1=0x80;                        
  180.         REF_SEL_0=1;                        
  181.         REF_SEL_1=0;                                
  182.         REF_SEL_2=1;
  183.         SRADCON2=C_out_ad_chs;        
  184.                                                         
  185.         SRADS=1;
  186.         asm("nop");
  187.         while(SRADS);
  188.         asm("nop");
  189.         i=SRADH&0x0f;                                
  190.         i=i<<8;
  191.         i+=SRADL;
  192.         return i;

  193. }
  194. //--------------------------------------------------------------------------------------------------------------------------------
  195. void        delay(uint i)
  196. {
  197.         while(i--);
  198. }
  199. //--------------------------------------------------------------------------------------------------------------------------------
  200. void        time_up(void)
  201. {
  202.         B_1s=0;
  203.         B_10ms=0;
  204.         B_200us=0;
  205.         
  206.         if(B_200US_INT)
  207.         {
  208.                 B_200US_INT=0;
  209.                 B_200us=1;
  210.         }
  211.         
  212.         if(B_10MS_INT)
  213.         {
  214.                 B_10MS_INT=0;
  215.                 B_10ms=1;
  216.                
  217.                 R_time++;
  218.                 if(R_time>=100)
  219.                 {
  220.                         R_time=0;
  221.                         B_1s=1;
  222.                 }
  223.         }
  224. }
  225. //--------------------------------------------------------------------------------------------------------------------------------
  226. void        out_init(void)
  227. {

  228. uint        i;
  229. uint        j;        
  230.         
  231.         P_out=0;               
  232.         delay(100);
  233.         i=read_ad_short();        
  234.         if(i<C_out_short)        
  235.         {
  236.                 out_short();               
  237.                 return;
  238.         }
  239.         
  240.         j=read_ad_vdd();        
  241.         for(i=0;i<22;i++)        
  242.         {
  243.                 if(j>=Tab_vdd_data[i])        
  244.                         break;                                
  245.         }
  246.         R_out_vol=Tab_out_vol_3V3[i];
  247. /*        switch(R_out_mode)
  248.         {
  249.                 case 0:
  250.                         R_out_vol=Tab_out_vol_3V4[i];
  251.                         break;
  252.                 case 1:
  253.                         R_out_vol=Tab_out_vol_3V7[i];
  254.                         break;
  255.                 case 2:
  256.                         R_out_vol=150;
  257.                         break;
  258.                 default :
  259.                         break;
  260.         }*/
  261.         /*
  262.         if(KeyFlag_2)
  263.                 R_out_vol=Tab_out_vol_1V85[i];
  264. */
  265.         
  266.         R_out_count=0;
  267.         B_out=1;                                                
  268.         B_out_b=0;


  269. }

  270. //---------------------------------------------------------------
  271. void        out_off(void)
  272. {
  273.         P_out=1;
  274.         B_out=0;
  275.         B_led_pwm=0;
  276.         
  277. }
  278. //---------------------------------------------------------------
  279. void        out_short(void)
  280. {
  281.         out_off();
  282. //        KeyFlag_2=0;
  283. //        Colours_Cnt=0;
  284.         B_key_handle=1;
  285.         B_led_pwm_bk=0;
  286.         led_flash_init(3,0x07);
  287. }
  288. //---------------------------------------------------------------
  289. void        out_vol(void)
  290. {
  291. uint        i;
  292.         
  293.         if(!B_out)
  294.                 return;
  295.         if(!B_200us)
  296.                 return;        
  297.         R_out_count++;
  298.         if(R_out_count>=C_out_vol_period)        //#define        C_out_vol_period        150        //3s
  299.         {        
  300.                 R_out_count=0;

  301.         }
  302.         if(R_out_vol>=R_out_count)               
  303.         {                                                               
  304.                 if(B_out_b)
  305.                 {
  306.                         i=read_ad_short();
  307.                         if(i<C_out_short)               
  308.                         {
  309.                                 out_short();        
  310.                                 return;
  311.                         }
  312.                         else if(read_ad_vdd()>C_vdd_low1)               
  313.                                 {                                                               
  314.                                 out_off();                                       
  315.                                 led_flash_init(10,0x07);
  316.                                 B_key_handle=1;
  317.                         //        B_key_lock=~B_key_lock;                        
  318.                                 return;
  319.                                 }
  320.                 }
  321.                
  322.                 B_out_b=1;
  323.                 P_out=0;               
  324.         }
  325.         else               
  326.         {
  327.                
  328.                 B_out_b=0;
  329.                 P_out=1;        
  330.         }
  331.         
  332. }
  333. //--------------------------------------------------------------------------------------------------------------------------------
  334. void        led_on(void)
  335. {
  336.         B_led_bright_ing=1;               
  337.         
  338.         if(R_led_color&0x01)        
  339.                 P_led1=0;                        
  340.         else
  341.                 P_led1=1;
  342.         
  343.         if(R_led_color&0x02)        
  344.                 P_led2=0;
  345.         else
  346.                 P_led2=1;
  347.         
  348.         if(R_led_color&0x04)        
  349.                 P_led3=0;
  350.         else
  351.                 P_led3=1;               
  352.                
  353. }
  354. //---------------------------------------------------------------
  355. void        led_off(void)
  356. {
  357.         B_led_bright_ing=0;               
  358.         
  359.         P_led1=1;
  360.         P_led2=1;
  361.         P_led3=1;
  362. }
  363. //---------------------------------------------------------------
  364. void        disp_led(void)
  365. {
  366.         if(!B_200us)
  367.                 return;
  368.         
  369.         if(B_led_flashing)               
  370.         {
  371.                 if(B_10ms)
  372.                         R_led_count++;
  373.                
  374.                 B_have_action=1;        
  375.                 if(R_led_count>=25)
  376.                 {
  377.                         R_led_count=0;
  378.                         if(B_led_bright_ing)               
  379.                         {
  380.                                 led_off();                                
  381.                         }
  382.                         else                                                
  383.                         {
  384.                                 if(R_led_fn)               
  385.                                 {
  386.                                         R_led_fn--;
  387.                                         led_on();
  388.                                 }
  389.                                 else
  390.                                 {
  391.                                         B_led_flashing=0;               
  392.                                 }
  393.                         }
  394.                 }
  395.                
  396.         }
  397.         else if(B_led_pwm||B_led_pwm_bk)
  398.         {
  399.                 B_have_action=1;
  400.                 R_led_count++;
  401.                 if(R_led_count>=C_led_pwm_period)        
  402.                 {
  403.                         R_led_count=0;
  404.                         if(B_led_pwm)                                                
  405.                         {
  406.                                 if(R_led_duty<C_led_pwm_period)
  407.                                 {
  408.                                         R_led_duty++;
  409.                                 }
  410.                                 
  411.                                 B_led_pwm_bk=1;
  412.                         }
  413.                         else                                                        
  414.                         {
  415.                                 if(R_led_duty)
  416.                                 {
  417.                                         R_led_duty--;
  418.                                 }
  419.                                 else
  420.                                 {
  421.                                         B_led_pwm_bk=0;
  422.                                         out_off();
  423.                                 }
  424.                                 
  425.                         }
  426.                 }
  427.                 if(R_led_count<R_led_duty)
  428.                         led_on();
  429.                 else
  430.                 {
  431.                         led_off();
  432.                         
  433.                 }
  434.                
  435.         }
  436.         
  437.         else if(B_USB_charge)        
  438.         {
  439.                 if(B_USB_ch_full)        
  440.                 {
  441.                         B_have_action=1;
  442.                         led_off();
  443.                 }
  444.                 else                                       
  445.                 {
  446.                         B_have_action=1;
  447.                         R_led_color=0x07;
  448.                         led_on();
  449.                 }
  450.         }
  451.         else                                       
  452.         {
  453.                 led_off();
  454.         }

  455. }
  456. //---------------------------------------------------------------
  457. void        led_flash_init(uchar r_fn,uchar r_color)
  458. {
  459.         R_led_fn=r_fn;                                
  460.         R_led_color=r_color;               
  461.         R_led_count=0;
  462.         B_led_flashing=1;               
  463. }
  464. //---------------------------------------------------------------
  465. void        led_pwm_init(void)
  466. {
  467.         R_led_count=0;
  468.         R_led_duty=0;
  469.         B_led_pwm=1;
  470. }
  471. //--------------------------------------------------------------------------------------------------------------------------------
  472. void        key_scan(void)
  473. {
  474.         if(!B_10ms)
  475.                 return;
  476.         
  477.         if(R_key_time<0xff)
  478.                 R_key_time++;
  479.         
  480.         if(R_key_time==50)               
  481.         {
  482.                 B_key_short=1;
  483.         }
  484.         
  485.         if(!P_MIC)
  486.         {
  487.                 if(B_key_hold)                        
  488.                 {
  489.                         B_have_action=1;        
  490.                         
  491.                         R_key_tremble--;
  492.                         if(R_key_tremble==0)        
  493.                         {
  494.                                 B_key_hold=0;        
  495.                                 B_key_handle=0;        
  496.                                 R_smoke_time=0;
  497.                         }
  498.                 }
  499.                 else                                       
  500.                 {
  501.                         R_key_tremble=0;
  502.                         if(R_key_time>50)               
  503.                                 R_key_much=0;
  504.                 }
  505.         }
  506.         else        
  507.         {
  508.                 if(B_key_hold)                        
  509.                 {
  510.                         R_key_tremble=4;
  511.                         
  512.                         if(R_key_time>25)
  513.                                 R_key_much=0;
  514.                 }
  515.                 else               
  516.                 {
  517.                         B_have_action=1;
  518.                         
  519.                         R_key_tremble++;
  520.                         if(R_key_tremble>=4)
  521.                         {
  522.                                 B_key_hold=1;
  523.                                 R_key_much++;
  524.                                 R_key_time=0;
  525.                         }
  526.                 }
  527.         }
  528. }
  529. //--------------------------------------------------------------------------------------------------------------------------------
  530. void        key_handle(void)
  531. {
  532.         if(B_key_handle)               
  533.                 return;
  534.         if(B_USB_charge)        
  535.                 return;
  536.         if(B_led_flashing)               
  537.                 return;
  538.                
  539.         if(B_key_hold)                        
  540.         {
  541.                
  542.                
  543. /*                if(B_key_lock)
  544.                         return;
  545.                 */
  546.                 if(B_out)                                                
  547.                 {
  548.                         if(B_10ms)
  549.                         {
  550.                                 R_smoke_time++;
  551.                                 if(R_smoke_time>=800)               
  552.                                 {
  553.                                         R_smoke_time=0;
  554.                                         out_off();                        
  555.                                         B_led_pwm_bk=0;
  556.                                         R_led_duty=0;
  557.                                         led_flash_init(3,0X07);
  558.                                         B_key_handle=1;
  559.                                 }
  560.                                 
  561.                         }
  562.                                 
  563.                         B_have_action=1;
  564.                 }
  565.                 else               
  566.                 {
  567.                         B_have_action=1;
  568.                         
  569.                         if(read_ad_vdd()>C_vdd_low)               
  570.                         {                                                        
  571.                                 led_flash_init(10,0x07);
  572.                                 B_key_handle=1;
  573.                         //        B_key_lock=~B_key_lock;               
  574.                                 out_off();               
  575.                                 return;
  576.                         }
  577.                         
  578.                         out_init();                        
  579. //                        B_out=1;
  580.                         if(B_out)
  581.                         {
  582.                                 R_led_color=0X07;
  583.                                 led_pwm_init();
  584.                         }
  585.                 }
  586.                
  587.                
  588.         }
  589.         else                        
  590.         {
  591.                 if(B_out)
  592.                 {
  593.                         out_off();
  594.                 }
  595.         }
  596. /*               
  597.         if(B_key_short&&(!B_key_lock))                        
  598.         {                                                                                
  599.                 if(R_key_much==3)
  600.                 {        
  601.                         R_out_mode++;
  602.                         if(R_out_mode>=3)
  603.                                 R_out_mode=0;
  604.                         
  605.                         led_flash_init(3,Tab_out_mode_color[R_out_mode]);
  606.                 }
  607.                
  608.                 if(R_key_much==2)
  609.                 {
  610.                         KeyFlag_2=1;
  611.                         out_init();               
  612.                         led_flash_init(30,LED_Colours[0]);
  613.                         
  614.                 }
  615.                 B_have_action=1;
  616.                 B_key_short=0;
  617.         }*/
  618. }
  619. //----------------------------------------------------------

  620. void        USB_charge(void)
  621. {
  622.         if(!B_10ms)
  623.                 return;
  624.         
  625.         if(P_ChgON)               
  626.         {
  627.                 B_have_action=1;
  628.                
  629.                 if(B_USB_charge)        
  630.                 {
  631.                         R_USB_count=50;                        
  632.                         if(P_ChgOK)               
  633.                         {
  634.                                 if(B_USB_ch_full)
  635.                                 {
  636.                                         R_USB_count2=50;
  637.                                 }
  638.                                 else
  639.                                 {
  640.                                         R_USB_count2++;
  641.                                         if(R_USB_count2>=50)
  642.                                         {
  643.                                                 B_USB_ch_full=1;
  644.                                         }
  645.                                 }
  646.                         }
  647.                         else               
  648.                         {
  649.                                 if(B_USB_ch_full)
  650.                                 {
  651.                                         R_USB_count2--;
  652.                                         if(R_USB_count2==0)
  653.                                         {
  654.                                                 B_USB_ch_full=0;
  655.                                         }
  656.                                 }
  657.                                 else
  658.                                 {
  659.                                         R_USB_count2=0;
  660.                                 }
  661.                         }
  662.                         
  663.                         
  664.                 }
  665.                 else                                
  666.                 {
  667.                         R_USB_count++;
  668.                         if(R_USB_count>=50)
  669.                         {
  670.                                 B_USB_charge=1;
  671.                                 B_USB_ch_full=0;
  672.                                 led_flash_init(5,0x07);
  673.                                 out_off();
  674.                         }
  675.                 }
  676.         }
  677. //--------------------------
  678.         else                        
  679.         {
  680.                 if(B_USB_charge)        
  681.                 {
  682.                         B_have_action=1;               
  683.                         
  684.                         R_USB_count--;
  685.                         if(R_USB_count==0)
  686.                         {
  687.                                 B_USB_charge=0;                                       
  688.                                 B_USB_ch_full=0;                        
  689. //                                B_full_lf=0;                                       
  690.                                 led_flash_init(2,0x07);
  691. //                                chk_led_delayON=1;
  692. //                                led_raceCnt1=0;
  693. //                                R_led_race=0;
  694.                         }
  695.                 }
  696.                 else        
  697.                 {
  698.                         R_USB_count=0;
  699.                         
  700.                         
  701.                 }
  702.         }
  703. }
  704. //--------------------------------------------------------------------------------------------------------------------------------
  705. void        sleep_handle(void)
  706. {
  707.         if(!B_10ms)
  708.                 return;
  709.         
  710.         if(B_have_action)
  711.         {
  712.                 B_have_action=0;
  713.                 R_sleep_delay=0;
  714.                
  715.         }
  716.         else
  717.         {
  718.                 R_sleep_delay++;
  719.                 if(R_sleep_delay>=100)               
  720.                 {
  721.                         SRADEN=0;
  722.                         T2EN=0;
  723.                         TM2IE=0;
  724.                         
  725.                         IO_INIT_sleep();
  726.                         delay(10000);
  727.                         
  728.                         asm("CLRWDT");
  729.                         WDTEN=0;                //        
  730.                         CST_WDT=1;                //
  731.                         
  732.                         E1IF=0;
  733.                         E1IE=1;
  734.                         
  735.                         asm("SLEEP");
  736.                         asm("nop");
  737.                         asm("nop");
  738.                         asm("nop");
  739.                         asm("nop");
  740.                         
  741.                         E1IE=0;
  742.                         
  743.                         T2EN=1;
  744.                         TM2IE=1;
  745.                         
  746.                         WDTEN=1;                //        
  747.                         CST_WDT=0;                //
  748.                         
  749.                         IO_INIT();
  750.                         
  751.                         
  752.                         R_sleep_delay=0;
  753.                         
  754.                 }
  755.         }
复制代码

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励!

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享分享 分享淘帖 顶 踩
回复

使用道具 举报

沙发
dj3365191 发表于 2020-9-27 12:06 | 只看该作者
从标题上没看明白啥意思,什么叫电子扁烟?
回复

使用道具 举报

板凳
 楼主| Y_T 发表于 2020-9-28 09:05 | 只看该作者
dj3365191 发表于 2020-9-27 12:06
从标题上没看明白啥意思,什么叫电子扁烟?

就是小功率电子烟
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表