標(biāo)題: 以八位單片機設(shè)計電子扁煙源程序原理圖，適合初學(xué)者 [打印本頁]
作者: Y_T    時間: 2020-9-21 10:45
標(biāo)題: 以八位單片機設(shè)計電子扁煙源程序原理圖，適合初學(xué)者
電路原理圖如下：



單片機源程序如下:
  1. const uint        Tab_vdd_data[];

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

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

  32. //============================================
  33. // program start
  34. //============================================
  35. //---------------------------------------------------------------

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

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

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

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

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


  279. }

  281. //---------------------------------------------------------------
  282. void        out_off(void)
  283. {
  284.         P_out=1;
  285.         B_out=0;
  286.         B_led_pwm=0;
  287.         
  288. }
  289. //---------------------------------------------------------------
  290. void        out_short(void)
  291. {
  292.         out_off();
  293. //        KeyFlag_2=0;
  294. //        Colours_Cnt=0;
  295.         B_key_handle=1;
  296.         B_led_pwm_bk=0;
  297.         led_flash_init(3,0x07);
  298. }
  299. //---------------------------------------------------------------
  300. void        out_vol(void)
  301. {
  302. uint        i;
  303.         
  304.         if(!B_out)
  305.                 return;
  306.         if(!B_200us)
  307.                 return;        
  308.         R_out_count++;
  309.         if(R_out_count>=C_out_vol_period)        //#define        C_out_vol_period        150        //3s
  310.         {        
  311.                 R_out_count=0;

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

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

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

作者: dj3365191    時間: 2020-9-27 12:06
從標(biāo)題上沒看明白啥意思，什么叫電子扁煙？
作者: Y_T    時間: 2020-9-28 09:05
dj3365191 發(fā)表于 2020-9-27 12:06
從標(biāo)題上沒看明白啥意思，什么叫電子扁煙？

就是小功率電子煙



歡迎光臨 (http://www.torrancerestoration.com/bbs/) Powered by Discuz! X3.1